Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.software-eng > #2472 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-01-05 12:26 -0600 |
| Last post | 2021-01-05 22:43 +0000 |
| Articles | 20 on this page of 113 — 4 participants |
Back to article view | Back to comp.software-eng
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 12:26 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 13:37 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 21:15 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 15:42 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:24 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-05 23:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 07:55 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 13:17 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-06 21:48 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-06 16:38 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-07 05:28 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Deceiver?) olcott <NoOne@NoWhere.com> - 2021-01-07 10:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:41 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 13:45 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 18:11 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-07 17:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:47 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Ben's Dishonesty?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-08 18:00 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 11:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 15:59 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 21:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-08 23:08 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Jeff Barnett <jbb@notatt.com> - 2021-01-08 22:36 -0700
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 05:39 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 12:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 22:28 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-09 16:51 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-09 23:22 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 10:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:15 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-12 12:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 12:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 18:53 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] olcott <NoOne@NoWhere.com> - 2021-01-11 14:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 20:19 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) olcott <NoOne@NoWhere.com> - 2021-01-11 20:46 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](Axiomatic basis) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-11 22:23 -0800
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 09:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 10:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](decider defined) olcott <NoOne@NoWhere.com> - 2021-01-12 19:14 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 11:00 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) olcott <NoOne@NoWhere.com> - 2021-01-12 13:40 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](laser focused) olcott <NoOne@NoWhere.com> - 2021-01-12 18:32 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](actual behavior) olcott <NoOne@NoWhere.com> - 2021-01-12 19:44 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:27 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 12:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 19:51 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) olcott <NoOne@NoWhere.com> - 2021-01-12 14:06 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 09:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 10:33 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 13:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 16:31 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 19:36 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-10 02:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-09 23:12 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:34 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-11 12:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-11 19:01 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 10:31 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 17:32 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 12:59 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 20:07 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 14:49 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 16:47 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-01-12 14:50 -0800
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-12 23:33 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 00:31 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:05 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-12 21:07 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 15:16 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Stupid?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-13 22:34 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:08 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 09:32 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 10:48 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-16 15:09 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 16:54 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 11:22 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:33 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 19:25 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](logical necessity) olcott <NoOne@NoWhere.com> - 2021-01-14 12:28 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 18:43 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 00:39 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-13 11:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 14:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 15:27 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](the gist of things) olcott <NoOne@NoWhere.com> - 2021-01-13 16:22 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 09:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-14 17:10 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:26 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](PUT) olcott <NoOne@NoWhere.com> - 2021-01-14 11:25 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 20:53 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-12 19:55 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 18:57 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) olcott <NoOne@NoWhere.com> - 2021-01-13 21:21 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-13 22:15 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 09:18 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 10:41 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-14 12:16 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 14:50 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) olcott <NoOne@NoWhere.com> - 2021-01-16 16:04 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](gullible fools) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-17 04:46 +0000
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Linz/Sipser) olcott <NoOne@NoWhere.com> - 2021-01-16 15:23 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] (brain dead morons) olcott <NoOne@NoWhere.com> - 2021-01-05 16:03 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] olcott <NoOne@NoWhere.com> - 2021-01-05 16:10 -0600
Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-01-05 22:43 +0000
Page 3 of 6 — ← Prev page 1 2 [3] 4 5 6 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 10:23 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) |
| Message-ID | <jaydnXZ-xImNUGDCnZ2dnUU7-bnNnZ2d@giganews.com> |
| In reply to | #2522 |
On 1/12/2021 10:10 AM, Richard Damon wrote:
> On 1/12/21 10:36 AM, olcott wrote:
>> On 1/11/2021 9:32 PM, Richard Damon wrote:
>>> On 1/11/21 9:46 PM, olcott wrote:
>>>> On 1/11/2021 6:49 PM, Richard Damon wrote:
>>>>> On 1/11/21 6:46 PM, olcott wrote:
>>>>>>
>>>>>> Because H_Hat() meets the "Infinite Recursion detection" criteria
>>>>>> it can
>>>>>> be verified that H_Hat() would actually never halt unless its
>>>>>> simulation
>>>>>> is stopped.
>>>>>
>>>>> Ok, I take the answer to be no.
>>>>>
>>>>> You mean your incorrectly applied condition (because the code fails to
>>>>> meet your requirement (f) becuase there IS condtrol flow inside Halts
>>>>> which is betweent the two calls.
>>>> When a judge decides whether or not a defendant is guilty the judge is a
>>>> separate and distinct entity from the defendant.
>>>>
>>>> In this same way the halt decider and the simulator are separate and
>>>> distinct entities from the program under test.
>>>>
>>>>
>>>
>>> But if the Judge himself helped commit the crime, then he can also be
>>> found to be guilty of it.
>>>
>>> IF the program under test uses the Halt Decider, that that instance of
>>> the Halt Decider is also responsible for its actions. >
>>
>>
>> If you cannot point out any specific error in the following yet still
>> disagree with it that would be evidence that it is over your head or
>> evidence that your review is biased.
>
> I have pointed out specifiec error, and YOU are the one who does not
> respond in the specifics, but only repeats unbased claims.
>>
>> An unbiased review would never disagree with anything without pointing
>> out a specific error basis for this disagreement.
>>
>> (1) It is never true that the infinite invocation of a function would
>> ever return a value to its caller.
>>
>
> Yes, If the function is ACTUALLY infinite in invocation, it would never
> return to it caller, which means that it would then fail to meet the
> definition of a decider.
>
>> (2) This same rule applies to the otherwise infinite invocation of a
>> function where the only reason that the invocation is not infinite is
>> that the caller has been aborted.
>
> WRONG. If a computation is a decider, then it MUST return its answer to
> its caller, otherwise it fails to be a decider.
>
(1) A function that is invoked in infinite recursion never returns a
result to its caller.
(2) If the caller in (1) is aborted then it still never receives a
result from the function that it invoked in infinite recursion.
(3) The halt decider shown below must abort H_Hat() to prevent its own
infinite execution.
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 11:06 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) |
| Message-ID | <AZWdnfuReZifSmDCnZ2dnUU7-UPNnZ2d@giganews.com> |
| In reply to | #2524 |
On 1/12/2021 10:38 AM, Richard Damon wrote: > On 1/12/21 11:23 AM, olcott wrote: >> On 1/12/2021 10:10 AM, Richard Damon wrote: >>> On 1/12/21 10:36 AM, olcott wrote: >>>> On 1/11/2021 9:32 PM, Richard Damon wrote: >>>>> On 1/11/21 9:46 PM, olcott wrote: >>>>>> On 1/11/2021 6:49 PM, Richard Damon wrote: >>>>>>> On 1/11/21 6:46 PM, olcott wrote: >>>>>>>> >>>>>>>> Because H_Hat() meets the "Infinite Recursion detection" criteria >>>>>>>> it can >>>>>>>> be verified that H_Hat() would actually never halt unless its >>>>>>>> simulation >>>>>>>> is stopped. >>>>>>> >>>>>>> Ok, I take the answer to be no. >>>>>>> >>>>>>> You mean your incorrectly applied condition (because the code >>>>>>> fails to >>>>>>> meet your requirement (f) becuase there IS condtrol flow inside Halts >>>>>>> which is betweent the two calls. >>>>>> When a judge decides whether or not a defendant is guilty the judge >>>>>> is a >>>>>> separate and distinct entity from the defendant. >>>>>> >>>>>> In this same way the halt decider and the simulator are separate and >>>>>> distinct entities from the program under test. >>>>>> >>>>>> >>>>> >>>>> But if the Judge himself helped commit the crime, then he can also be >>>>> found to be guilty of it. >>>>> >>>>> IF the program under test uses the Halt Decider, that that instance of >>>>> the Halt Decider is also responsible for its actions. > >>>> >>>> >>>> If you cannot point out any specific error in the following yet still >>>> disagree with it that would be evidence that it is over your head or >>>> evidence that your review is biased. >>> >>> I have pointed out specifiec error, and YOU are the one who does not >>> respond in the specifics, but only repeats unbased claims. >>>> >>>> An unbiased review would never disagree with anything without pointing >>>> out a specific error basis for this disagreement. >>>> >>>> (1) It is never true that the infinite invocation of a function would >>>> ever return a value to its caller. >>>> >>> >>> Yes, If the function is ACTUALLY infinite in invocation, it would never >>> return to it caller, which means that it would then fail to meet the >>> definition of a decider. >>> >>>> (2) This same rule applies to the otherwise infinite invocation of a >>>> function where the only reason that the invocation is not infinite is >>>> that the caller has been aborted. >>> >>> WRONG. If a computation is a decider, then it MUST return its answer to >>> its caller, otherwise it fails to be a decider. >>> >> (1) A function that is invoked in infinite recursion never returns a >> result to its caller. >> >> (2) If the caller in (1) is aborted then it still never receives a >> result from the function that it invoked in infinite recursion. > > A Turing Machine that is a decider can NOT abort its caller and still be > a decider. That was the part that is over your head. Here is the correction: Any Turing machine that makes a decision on an input by what-so-ever means <is> a decider for this input. The term decider doesn't really have a standard meaning. In fact, it is lamentable that Sipser chose the terms decider and recognizer, since they seem to confuse students. Intuitively, a decider should be a Turing machine that given an input, halts and either accepts or rejects, relaying its answer in one of many equivalent ways, such as halting at an ACCEPT or REJECT state, or leaving its answer on the output tape. answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall Assistant Professor in the Henry and Marilyn Taub Department of Computer Science at the Technion – Israel Institute of Technology. https://cs.stackexchange.com/questions/84433/what-is-decider That you simply ignore these corrections and continue to make the same mistake over and over without making any attempt to find any error in these corrections is quite dishonest. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 19:14 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](decider defined) |
| Message-ID | <Bu-dnabYMJ0Z1GPCnZ2dnUU7-ffNnZ2d@giganews.com> |
| In reply to | #2527 |
On 1/12/2021 11:43 AM, Richard Damon wrote:
> On 1/12/21 12:06 PM, olcott wrote:
>> On 1/12/2021 10:38 AM, Richard Damon wrote:
>
>>> A Turing Machine that is a decider can NOT abort its caller and still be
>>> a decider.
>>
>> That was the part that is over your head. Here is the correction:
>> Any Turing machine that makes a decision on an input by what-so-ever
>> means <is> a decider for this input.
>
> WRONG. CATAGORICALLY. Would you say that I made a correct prediction of
> something it I wrote my answer on a piece of paper and then ate it, and
> then after the results was truly known, told you that was what I wrote down?
>
> The Decider needs to document how it will answer. Based on that
> documentation, the 'caller' can ALWAYS get that answer. If the Decider
> halts in a state defined as an answer, then the caller is built by
> modifying that state to rather than halt, process that answer according
> to its template. If the decider chooses to halt in a state NOT defined
> as an answer, then it has failed to meet its definition of deciding.
>>
>> The term decider doesn't really have a standard meaning.
>> In fact, it is lamentable that Sipser chose the terms decider
>> and recognizer, since they seem to confuse students.>
>> Intuitively, a decider should be a Turing machine that given
>> an input, halts and either accepts or rejects, relaying its
>> answer in one of many equivalent ways, such as halting
>> at an ACCEPT or REJECT state, or leaving its answer on
>> the output tape.
>>
>
> Yes, there are multiple ways that a Turing Decide could leave its
> answer, but it needs to define how it will do this. It is also possible
> to show that however it does this, it is then possible to wrap that
> decider in a wrapper to leave that same answer in any other possible way
> to indicate, thus the assumption that the decide answers by going to one
> of two states can ALWAYS be achieved by wrapping any decider that uses
> some other docuemented method, and converts it into one of those two
> states.
>
>> answered Nov 25 '17 at 8:35 Yuval Filmus top 0.03% overall
>> Assistant Professor in the Henry and Marilyn
>> Taub Department of Computer Science at the
>> Technion – Israel Institute of Technology.
>> https://cs.stackexchange.com/questions/84433/what-is-decider
>>
>>
>> That you simply ignore these corrections and continue to make the same
>> mistake over and over without making any attempt to find any error in
>> these corrections is quite dishonest.
>>
>
> This means that if Halts doesn't return the answer to H_Hat in the top
> level machine, either the whole machine was built wrong (your fault) or
> Halt failed to properly answer (again your fault).
>
Halts() does return 0 to Input_Would_Halt variable in main() thus
totally fulfilling the requirements of a decider.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 11:00 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) |
| Message-ID | <0e2dndTrYvEnSGDCnZ2dnUU7-e3NnZ2d@giganews.com> |
| In reply to | #2522 |
On 1/12/2021 10:45 AM, Malcolm McLean wrote: > On Tuesday, 12 January 2021 at 16:10:05 UTC, Richard Damon wrote: >> On 1/12/21 10:36 AM, olcott wrote: >>> On 1/11/2021 9:32 PM, Richard Damon wrote: >>>> On 1/11/21 9:46 PM, olcott wrote: >>>>> On 1/11/2021 6:49 PM, Richard Damon wrote: >>>>>> On 1/11/21 6:46 PM, olcott wrote: >>>>>>> >>>>>>> Because H_Hat() meets the "Infinite Recursion detection" criteria >>>>>>> it can >>>>>>> be verified that H_Hat() would actually never halt unless its >>>>>>> simulation >>>>>>> is stopped. >>>>>> >>>>>> Ok, I take the answer to be no. >>>>>> >>>>>> You mean your incorrectly applied condition (because the code fails to >>>>>> meet your requirement (f) becuase there IS condtrol flow inside Halts >>>>>> which is betweent the two calls. >>>>> When a judge decides whether or not a defendant is guilty the judge is a >>>>> separate and distinct entity from the defendant. >>>>> >>>>> In this same way the halt decider and the simulator are separate and >>>>> distinct entities from the program under test. >>>>> >>>>> >>>> >>>> But if the Judge himself helped commit the crime, then he can also be >>>> found to be guilty of it. >>>> >>>> IF the program under test uses the Halt Decider, that that instance of >>>> the Halt Decider is also responsible for its actions. > >>> >>> >>> If you cannot point out any specific error in the following yet still >>> disagree with it that would be evidence that it is over your head or >>> evidence that your review is biased. >> I have pointed out specifiec error, and YOU are the one who does not >> respond in the specifics, but only repeats unbased claims. >>> >>> An unbiased review would never disagree with anything without pointing >>> out a specific error basis for this disagreement. >>> >>> (1) It is never true that the infinite invocation of a function would >>> ever return a value to its caller. >>> >> Yes, If the function is ACTUALLY infinite in invocation, it would never >> return to it caller, which means that it would then fail to meet the >> definition of a decider. >>> (2) This same rule applies to the otherwise infinite invocation of a >>> function where the only reason that the invocation is not infinite is >>> that the caller has been aborted. >> >> WRONG. If a computation is a decider, then it MUST return its answer to >> its caller, otherwise it fails to be a decider. >> > The Linz proof relies on H being a Turing machine. Therefore it can be > embedded in H_Hat. If you break this relationship or rule, the proof doesn't > work. That doesn't mean that the offered "H" is not a decider, just that > it is not a Turing machine. The Siper proof is the same standard: "Do the opposite of whatever the halt decider decides" and has the halt decider as a sub-routine. Now we construct a new Turing machine D with H as a subroutine. This new TM calls H to determine what M does when the input to M is its own description <M>. Once D has determined this information, it does the opposite. That is, it rejects if M accepts and accepts if M does not accept. The following is a description of D. (Sipser 1997) http://www.liarparadox.org/sipser_165.pdf Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: PWS Publishing Company (165-167) Whether or not H is embedded in H_Hat() is not relevant As long as the standard: "Do the opposite of whatever the halt decider decides" is shown to be decidable the basis of all of these proofs has been refuted. It is much more effective communication to use the simplest possible case of the basis of all of the conventional halting problem undecidability proofs. > You can build a trivial decider that isn't a Turing machine and claim that > you have refuted Linz, but you haven't really done anything very interesting, > because the trivial decider can be trivially turned into a Turing machine > and then embedded. > I have shown exactly how the simplest possible case of the common basis of all of the conventional halting problem undecidability proofs can be correctly decided. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 13:40 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) |
| Message-ID | <PI6dnXEzn5S6ZmDCnZ2dnUU7-bnNnZ2d@giganews.com> |
| In reply to | #2526 |
On 1/12/2021 1:03 PM, Malcolm McLean wrote:
> On Tuesday, 12 January 2021 at 17:00:49 UTC, olcott wrote:
>> On 1/12/2021 10:45 AM, Malcolm McLean wrote:
>>
>> Whether or not H is embedded in H_Hat() is not relevant
>>
>> As long as the standard:
>> "Do the opposite of whatever the halt decider decides"
>>
>> is shown to be decidable the basis of all of these proofs has been refuted.
>>
> You don't have two Turing machines in the H / H_Hat relationship such that
> H correctly decides H_Hat. It's impossible and it's obviously impossible,
> and at one point I thought that we had agreed on that. You have to change the
> rules a bit.
It is self-evident that:
(1) the following Halts() / H_Hat() is in the standard
"do the opposite of whatever the halt decider decides"
configuration that is the basis of the the conventional halting problem
undecidability proofs.
(2) Every computation that would not halt if its simulation were not
halted is by logical necessity a non-halting computation.
Arguing against self-evident truth is like arguing that black cats are
not black.
Try and find any way to show that Halts() does not correctly decide
not-halting on H_Hat() by finding a single mistake with any of the
following.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
Output_Debug_Trace() [0001112e] size(124) capacity(65536)
[0000087e](01) 55 push ebp
[0000087f](02) 8bec mov ebp,esp
[00000881](01) 51 push ecx
[00000882](05) 684e080000 push 0000084e
[00000887](05) 684e080000 push 0000084e
[0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
[0000084e](01) 55 push ebp
[0000084f](02) 8bec mov ebp,esp
[00000851](01) 51 push ecx
[00000852](03) 8b4508 mov eax,[ebp+08]
[00000855](01) 50 push eax
[00000856](03) 8b4d08 mov ecx,[ebp+08]
[00000859](01) 51 push ecx
[0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
[0000084e](01) 55 push ebp
[0000084f](02) 8bec mov ebp,esp
[00000851](01) 51 push ecx
[00000852](03) 8b4508 mov eax,[ebp+08]
[00000855](01) 50 push eax
[00000856](03) 8b4d08 mov ecx,[ebp+08]
[00000859](01) 51 push ecx
[0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
Infinite Recursion detection AXIOM (self-evident truth)
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween
The above execution trace meets the criteria of the Infinite Recursion
detection AXIOM, thus providing the basis for Halts() to stop simulating
H_Hat() and decide not-halting.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 18:32 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](laser focused) |
| Message-ID | <jrqdncZXo_ZdomPCnZ2dnUU7-eXNnZ2d@giganews.com> |
| In reply to | #2534 |
On 1/12/2021 2:24 PM, Malcolm McLean wrote:
> On Tuesday, 12 January 2021 at 19:40:31 UTC, olcott wrote:
>> On 1/12/2021 1:03 PM, Malcolm McLean wrote:
>>> On Tuesday, 12 January 2021 at 17:00:49 UTC, olcott wrote:
>>>> On 1/12/2021 10:45 AM, Malcolm McLean wrote:
>>>>
>>>> Whether or not H is embedded in H_Hat() is not relevant
>>>>
>>>> As long as the standard:
>>>> "Do the opposite of whatever the halt decider decides"
>>>>
>>>> is shown to be decidable the basis of all of these proofs has been refuted.
>>>>
>>> You don't have two Turing machines in the H / H_Hat relationship such that
>>> H correctly decides H_Hat. It's impossible and it's obviously impossible,
>>> and at one point I thought that we had agreed on that. You have to change the
>>> rules a bit.
>> It is self-evident that:
>>
>> (1) the following Halts() / H_Hat() is in the standard
>> "do the opposite of whatever the halt decider decides"
>> configuration that is the basis of the the conventional halting problem
>> undecidability proofs.
>>
>> (2) Every computation that would not halt if its simulation were not
>> halted is by logical necessity a non-halting computation.
>>
>> Arguing against self-evident truth is like arguing that black cats are
>> not black.
>>
>> Try and find any way to show that Halts() does not correctly decide
>> not-halting on H_Hat() by finding a single mistake with any of the
>> following.
>> void H_Hat(u32 P)
>> {
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>> Output("Input_Would_Halt =", Input_Would_Halt);
>> }
>> Output_Debug_Trace() [0001112e] size(124) capacity(65536)
>> [0000087e](01) 55 push ebp
>> [0000087f](02) 8bec mov ebp,esp
>> [00000881](01) 51 push ecx
>> [00000882](05) 684e080000 push 0000084e
>> [00000887](05) 684e080000 push 0000084e
>> [0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
>> [0000084e](01) 55 push ebp
>> [0000084f](02) 8bec mov ebp,esp
>> [00000851](01) 51 push ecx
>> [00000852](03) 8b4508 mov eax,[ebp+08]
>> [00000855](01) 50 push eax
>> [00000856](03) 8b4d08 mov ecx,[ebp+08]
>> [00000859](01) 51 push ecx
>> [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
>> [0000084e](01) 55 push ebp
>> [0000084f](02) 8bec mov ebp,esp
>> [00000851](01) 51 push ecx
>> [00000852](03) 8b4508 mov eax,[ebp+08]
>> [00000855](01) 50 push eax
>> [00000856](03) 8b4d08 mov ecx,[ebp+08]
>> [00000859](01) 51 push ecx
>> [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
>> Infinite Recursion detection AXIOM (self-evident truth)
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> The above execution trace meets the criteria of the Infinite Recursion
>> detection AXIOM, thus providing the basis for Halts() to stop simulating
>> H_Hat() and decide not-halting.
>>
> That's a debug trace of the call to Halts(). But Halts() should return a value to
> Input_Would_Halt. That's what we're interested in, not the debug trace.
>
It does return a a value to Input_Would_Halt.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
> The debug trace is for when you call H_Hat(H_Hat) directly, to confirm that
> Halts() has determined the behaviour correctly.
>
I am going to stay laser focused on the aspects of the above halting
decision until at least one person here totally understands that Halts()
does correctly decide not-halting for H_Hat() in the above computation.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 19:44 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](actual behavior) |
| Message-ID | <o_Odndu1cYQPzWPCnZ2dnUU7-S_NnZ2d@giganews.com> |
| In reply to | #2526 |
On 1/12/2021 11:32 AM, Richard Damon wrote:
> On 1/12/21 12:00 PM, olcott wrote:
>> On 1/12/2021 10:45 AM, Malcolm McLean wrote:
>>> On Tuesday, 12 January 2021 at 16:10:05 UTC, Richard Damon wrote:
>>>> On 1/12/21 10:36 AM, olcott wrote:
>>>>> On 1/11/2021 9:32 PM, Richard Damon wrote:
>>>>>> On 1/11/21 9:46 PM, olcott wrote:
>>>>>>> On 1/11/2021 6:49 PM, Richard Damon wrote:
>>>>>>>> On 1/11/21 6:46 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>> Because H_Hat() meets the "Infinite Recursion detection" criteria
>>>>>>>>> it can
>>>>>>>>> be verified that H_Hat() would actually never halt unless its
>>>>>>>>> simulation
>>>>>>>>> is stopped.
>>>>>>>>
>>>>>>>> Ok, I take the answer to be no.
>>>>>>>>
>>>>>>>> You mean your incorrectly applied condition (because the code
>>>>>>>> fails to
>>>>>>>> meet your requirement (f) becuase there IS condtrol flow inside
>>>>>>>> Halts
>>>>>>>> which is betweent the two calls.
>>>>>>> When a judge decides whether or not a defendant is guilty the
>>>>>>> judge is a
>>>>>>> separate and distinct entity from the defendant.
>>>>>>>
>>>>>>> In this same way the halt decider and the simulator are separate and
>>>>>>> distinct entities from the program under test.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But if the Judge himself helped commit the crime, then he can also be
>>>>>> found to be guilty of it.
>>>>>>
>>>>>> IF the program under test uses the Halt Decider, that that instance of
>>>>>> the Halt Decider is also responsible for its actions. >
>>>>>
>>>>>
>>>>> If you cannot point out any specific error in the following yet still
>>>>> disagree with it that would be evidence that it is over your head or
>>>>> evidence that your review is biased.
>>>> I have pointed out specifiec error, and YOU are the one who does not
>>>> respond in the specifics, but only repeats unbased claims.
>>>>>
>>>>> An unbiased review would never disagree with anything without pointing
>>>>> out a specific error basis for this disagreement.
>>>>>
>>>>> (1) It is never true that the infinite invocation of a function would
>>>>> ever return a value to its caller.
>>>>>
>>>> Yes, If the function is ACTUALLY infinite in invocation, it would never
>>>> return to it caller, which means that it would then fail to meet the
>>>> definition of a decider.
>>>>> (2) This same rule applies to the otherwise infinite invocation of a
>>>>> function where the only reason that the invocation is not infinite is
>>>>> that the caller has been aborted.
>>>>
>>>> WRONG. If a computation is a decider, then it MUST return its answer to
>>>> its caller, otherwise it fails to be a decider.
>>>>
>>> The Linz proof relies on H being a Turing machine. Therefore it can be
>>> embedded in H_Hat. If you break this relationship or rule, the proof
>>> doesn't
>>> work. That doesn't mean that the offered "H" is not a decider, just that
>>> it is not a Turing machine.
>>
>> The Siper proof is the same standard:
>> "Do the opposite of whatever the halt decider decides"
>> and has the halt decider as a sub-routine.
>>
>> Now we construct a new Turing machine D with H as a
>> subroutine. This new TM calls H to determine what M
>> does when the input to M is its own description <M>.
>> Once D has determined this information, it does the
>> opposite. That is, it rejects if M accepts and accepts
>> if M does not accept. The following is a description of D. (Sipser 1997)
>>
>> http://www.liarparadox.org/sipser_165.pdf
>>
>> Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
>> PWS Publishing Company (165-167)
>>
>> Whether or not H is embedded in H_Hat() is not relevant
>
> You don't understand what a subroutine is in a Turing Machine I guess. A
> subroutine in a Turing Machine is FULLY part of the machine it is part
> of. A Turing Machine can not use any 'code' that is not part of it.
>>
>> As long as the standard:
>> "Do the opposite of whatever the halt decider decides"
>>
>> is shown to be decidable the basis of all of these proofs has been refuted.
>>
>> It is much more effective communication to use the simplest possible
>> case of the basis of all of the conventional halting problem
>> undecidability proofs.
>>
>>> You can build a trivial decider that isn't a Turing machine and claim
>>> that
>>> you have refuted Linz, but you haven't really done anything very
>>> interesting,
>>> because the trivial decider can be trivially turned into a Turing machine
>>> and then embedded.
>>>
>>
>> I have shown exactly how the simplest possible case of the common basis
>> of all of the conventional halting problem undecidability proofs can be
>> correctly decided.
>>
>>
>
> But it fails. Your Halts either fails to decider per the specification
> or it decided wrongly, when tested to the true test of the decider,
> what the actual machine that the input represents is run would do.
>
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
If you want to see that the code above code actually would be infinitely
recursive if its simulation was not stopped
we could execute the code in halt decider disabled mode and set the
maximum number of lines executed to its maximum 64-bit value. In this
case the debug trace output would be printed on a stack of paper 74
light years tall.
Although 74 light years of output would be convincing the only sure way
to really verify infinite execution is analytically.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-12 17:27 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](over your head) |
| Message-ID | <20210112091555.326@kylheku.com> |
| In reply to | #2522 |
On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
> (1) It is never true that the infinite invocation of a function would
> ever return a value to its caller.
That is true, but in your program, you've unwittingly switched H_Hat
from infinite execution to termination. A simple call from main
to H_Hat(H_Hat) will show that it terminates.
This is because your decider aborts the simulation after several levels
of nesting, and returns 0, which causes H_Hat to quit.
Here is how you can fix it:
1. Firstly, since you're claiming that your system answers a different
question, rename the Halts function accordingly:
u32 HasToBeStoppedToPreventInfiniteExecution(u32 P, u32 I);
(I mean, if you think the "Halts?" question is wrong, and you have
replaced it with the correct one, why would you continue to use the
name of the incorrect one?)
2. When HasToBeStoppedToPreventInfiniteExecution detects recursion, it
should return 1 to indicate that the simulation has to be stopped.
You see? H_Hat will take this 1 return value, and then proceed to get
into an infinite loop.
You have consistency! H_Hat(H_Hat) is not terminating, and your
function correctly says that it has to be stopped to prevent its
infinite execution.
Basically, the polarity has been reversed:
u32 HasToBeStoppedToPreventInfiniteExecution(u32 P, u32 I);
means the same thing as:
u32 DoesNotHalt(u32 P, u32 I);
and so, H_Hat isn't "behaving opposite" any longer, so there is no
"pathological" self-reference.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 12:50 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) |
| Message-ID | <ofqdnSQ2HITscmDCnZ2dnUU7-WXNnZ2d@giganews.com> |
| In reply to | #2529 |
On 1/12/2021 11:27 AM, Kaz Kylheku wrote:
> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
>> (1) It is never true that the infinite invocation of a function would
>> ever return a value to its caller.
>
> That is true, but in your program, you've unwittingly switched H_Hat
> from infinite execution to termination. A simple call from main
> to H_Hat(H_Hat) will show that it terminates.
>
We can't change subject like that and ever hope to come to any meeting
of minds. We must stay laser focused on one single point at a time or an
honest dialogue is not maintained.
If we prove that Halts() correctly decides not-halting for H_Hat() in
the following computation then no other computation on any other input
has any bearing what-so-ever on the correctness of this computation.
void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
[0000087e](01) 55 push ebp
[0000087f](02) 8bec mov ebp,esp
[00000881](01) 51 push ecx
[00000882](05) 684e080000 push 0000084e
[00000887](05) 684e080000 push 0000084e
[0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
[0000084e](01) 55 push ebp
[0000084f](02) 8bec mov ebp,esp
[00000851](01) 51 push ecx
[00000852](03) 8b4508 mov eax,[ebp+08]
[00000855](01) 50 push eax
[00000856](03) 8b4d08 mov ecx,[ebp+08]
[00000859](01) 51 push ecx
[0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
[0000084e](01) 55 push ebp
[0000084f](02) 8bec mov ebp,esp
[00000851](01) 51 push ecx
[00000852](03) 8b4508 mov eax,[ebp+08]
[00000855](01) 50 push eax
[00000856](03) 8b4d08 mov ecx,[ebp+08]
[00000859](01) 51 push ecx
[0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
Infinite Recursion detection AXIOM
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween
The above execution trace meets the criteria of the Infinite Recursion
detection AXIOM, thus providing the basis for Halts() to stop simulating
H_Hat() and decide not-halting.
The way that we prove that it is correct is the impossibility of finding
any error.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-12 19:51 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) |
| Message-ID | <20210112112040.16@kylheku.com> |
| In reply to | #2532 |
["Followup-To:" header set to comp.theory.]
On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
> On 1/12/2021 11:27 AM, Kaz Kylheku wrote:
>> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote:
>>> (1) It is never true that the infinite invocation of a function would
>>> ever return a value to its caller.
>>
>> That is true, but in your program, you've unwittingly switched H_Hat
>> from infinite execution to termination. A simple call from main
>> to H_Hat(H_Hat) will show that it terminates.
>>
> We can't change subject like that and ever hope to come to any meeting
> of minds. We must stay laser focused on one single point at a time or an
> honest dialogue is not maintained.
Staying literally laser-focused on one point is how car crashes happen.
Staying laser-focused on the head of one mole allows three others to pop
up in the meanwhile.
You better be laser-focused on the entire big picture and all its
details.
> If we prove that Halts() correctly decides not-halting for H_Hat() in
Halts does correctly decide non-halting; it incorrectly decides
what it's supposed to decide, namely halting.
> [0000087e](01) 55 push ebp
> [0000087f](02) 8bec mov ebp,esp
> [00000881](01) 51 push ecx
> [00000882](05) 684e080000 push 0000084e
> [00000887](05) 684e080000 push 0000084e
> [0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
> [0000084e](01) 55 push ebp
> [0000084f](02) 8bec mov ebp,esp
> [00000851](01) 51 push ecx
> [00000852](03) 8b4508 mov eax,[ebp+08]
> [00000855](01) 50 push eax
> [00000856](03) 8b4d08 mov ecx,[ebp+08]
> [00000859](01) 51 push ecx
> [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
^^^^^^^^
> [0000084e](01) 55 push ebp
^^^^^^^^
Something is missing: a call to 66E occurred, but we are suddenly
tracing 84E.
This, I'm guessing, is because 66E is not in "user space": Halts is
considerd part of the "kernel" of the simulator.
And so, the trace goes "radio silent" until 84E appears.
I'm guessing that 84E is H_Hat. It has not been directly called; this
instruction at 84E is being reported by the next embedded level of
simulation.
We have nothing like a complete trace here; all we have is slices of
each simulation level which confirm the obvious fact we already know:
that H_Hat makes a call to Halts.
H_Hat terminates because the simulation ends at a certain number of
levels. The top level Halts call returns 0, and so the top-level H_Hat
call terminates. Every nested/simulated call to H_Hat is also
progressing toward termination, except that those are stopped dead in
their tracks when the outer-most simulation abruptly ends.
The claim that H_Hat is an infinitely recursing execution is flatly
false.
> [0000084f](02) 8bec mov ebp,esp
> [00000851](01) 51 push ecx
> [00000852](03) 8b4508 mov eax,[ebp+08]
> [00000855](01) 50 push eax
> [00000856](03) 8b4d08 mov ecx,[ebp+08]
> [00000859](01) 51 push ecx
> [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat)
But we know from your descriptions that Halts actually looks something
like his this:
u32 Halts(u32 P, u32 I)
{
// initialize simulator somehow from P, I
Simulator sim(P, I);
for (;;) {
u32 stepResult = sim.DebugStep();
// various decisions
}
...
}
So, everything between the entry to Halts and DebugStep is invisible
in the instruction trace; when Halts is called, he next instruction to
be reported is one logged by DebugStep.
Am I close?
Halts is an integral part of H_Hat; if you don't trace through it,
you're not tracing H_Hat completely.
> Infinite Recursion detection AXIOM
> (a) Within an execution trace
> (b) The same function is called
> (c) From the same machine address
> (d) With the same data // Richard Damon credit
> (e) A second time
> (f) Without any control flow instructions inbetween
These rules are incorrect if they are not applied to the complete,
uncensored instruction stream.
Condition (f) says "Without any ...". That can show a false positive if
there are instructions missing from the report.
The only way you can be sure that a "Without any ..." condition holds is
by exhaustively examining the absolutely complete instruction stream,
and seeing there are no such instructions.
So that is to say, using the incomplete data you are *falsely* detecting
infinite recursion, because the above conditions are not exposed to
those conditional instructions which are responsible for preventing
recursion. They see only tiny slices of the emulation that show H_Hat
calling Halts.
Having falsely detected infinite recursion, you abort the simulation,
and that act ensures that there is no infinite recursion, which causes the
result to be false. The result being false causes itself to become
false.
You've perpetuated a "self-falsifying self-reference", LOL.
What I don't understand is that you don't declare this work to be
"pathological".
You are very selectively in what sorts of self-reference you call
pathological. If you came up with it, it's just dandy. If someone else
came up with it, it's pathological.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-12 14:06 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement] [ Complete Proof ](of a single point) |
| Message-ID | <tvKdnW3tzfGmnGPCnZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #2535 |
On 1/12/2021 1:51 PM, Kaz Kylheku wrote: > ["Followup-To:" header set to comp.theory.] > On 2021-01-12, olcott <NoOne@NoWhere.com> wrote: >> On 1/12/2021 11:27 AM, Kaz Kylheku wrote: >>> On 2021-01-12, olcott <NoOne@NoWhere.com> wrote: >>>> (1) It is never true that the infinite invocation of a function would >>>> ever return a value to its caller. >>> >>> That is true, but in your program, you've unwittingly switched H_Hat >>> from infinite execution to termination. A simple call from main >>> to H_Hat(H_Hat) will show that it terminates. >>> >> We can't change subject like that and ever hope to come to any meeting >> of minds. We must stay laser focused on one single point at a time or an >> honest dialogue is not maintained. > > Staying literally laser-focused on one point is how car crashes happen. > > Staying laser-focused on the head of one mole allows three others to pop > up in the meanwhile. > > You better be laser-focused on the entire big picture and all its > details. > >> If we prove that Halts() correctly decides not-halting for H_Hat() in > > Halts does correctly decide non-halting; it incorrectly decides > what it's supposed to decide, namely halting. > >> [0000087e](01) 55 push ebp >> [0000087f](02) 8bec mov ebp,esp >> [00000881](01) 51 push ecx >> [00000882](05) 684e080000 push 0000084e >> [00000887](05) 684e080000 push 0000084e >> [0000088c](05) e8ddfdffff call 0000066e ;CALL Halts(H_Hat, H_Hat) >> [0000084e](01) 55 push ebp >> [0000084f](02) 8bec mov ebp,esp >> [00000851](01) 51 push ecx >> [00000852](03) 8b4508 mov eax,[ebp+08] >> [00000855](01) 50 push eax >> [00000856](03) 8b4d08 mov ecx,[ebp+08] >> [00000859](01) 51 push ecx >> [0000085a](05) e80ffeffff call 0000066e ;CALL Halts(H_Hat, H_Hat) > ^^^^^^^^ >> [0000084e](01) 55 push ebp > ^^^^^^^^ > > Something is missing: a call to 66E occurred, but we are suddenly > tracing 84E. > > This, I'm guessing, is because 66E is not in "user space": Halts is > considerd part of the "kernel" of the simulator. > > And so, the trace goes "radio silent" until 84E appears. > > I'm guessing that 84E is H_Hat. It has not been directly called; this > instruction at 84E is being reported by the next embedded level of > simulation. > > We have nothing like a complete trace here; all we have is slices of > each simulation level which confirm the obvious fact we already know: > that H_Hat makes a call to Halts. > > H_Hat terminates because the simulation ends at a certain number of > levels. The top level Halts call returns 0, and so the top-level H_Hat > call terminates. Every nested/simulated call to H_Hat is also > progressing toward termination, except that those are stopped dead in > their tracks when the outer-most simulation abruptly ends. > > The claim that H_Hat is an infinitely recursing execution is flatly > false. > No this is a very stupid fallacy of equivocation error on your part. It is a very stupid error because I have explained this dozens of times. Does the simulation of the input have to be stopped to prevent its otherwise infinite execution? Does the simulation of the input have to be stopped to prevent its otherwise infinite execution? Does the simulation of the input have to be stopped to prevent its otherwise infinite execution? Does the simulation of the input have to be stopped to prevent its otherwise infinite execution? Does the simulation of the input have to be stopped to prevent its otherwise infinite execution? The stupid mistake that you made is thinking that the question was: Is the input infinitely recursive? Within the context that I have explained this to you many times it is very hard to believe that this is an actual mistake and not flat out dishonesty. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 09:36 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <2Lidnf0WkaIfUGTCnZ2dnUU7-enNnZ2d@giganews.com> |
| In reply to | #2491 |
On 1/9/2021 5:46 AM, Malcolm McLean wrote: > On Saturday, 9 January 2021 at 02:35:52 UTC, olcott wrote: >> On 1/8/2021 8:22 PM, Ben Bacarisse wrote: >> >>> You have explained, clearly, the ways in which the two algorithms >>> differ: one is a simulation that does not return a value, the other is a >>> partial simulation that does. I can't see why you want to deny this >>> now. It the core of the ruse you are trying to pull. >> >> How can you say something as stupid as this knowing that I have >> repeatedly told you many times that there is only one single instance of >> the machine code? >> > A halt decider has to be a function of the input machine and the input > machine's tape. If it is a function of the input machine, the input > machine's tape, and something else, even a simple flag, then it's > easy to meet Linz's challenge. If you disguise the "something else" then > it might be a clever cheat, but it's just a cheat. There cannot possibly be such thing as an actual cheat. If the Halt decider correctly decides that the input meets the specification of this infinite recursion axiom then it has correctly decided what would otherwise be infinite recursion: We can see that the halt decider did correctly decide that the prior invocation was infinitely recursive on the basis of: (a) The same function is called (b) From the same machine address (c) With the same data // Richard Damon credit (c) A second time (d) Without any control flow instructions inbetween >> >> I probably should give up talking to you, you are just like a person >> that believes that Trump won by a landslide even though his approval >> rating was always very subtantially under water. >> > Do you have access to intelligence briefings? If not, what makes you so > sure that the President is incorrect when he maintains that the election > was stolen from him by fraud? > (1) Trump's approval rating has been under water by a large margin for his whole term. (an average of 10% under water) (2) A presidential approval rating that has always been by a large margin defines the term "election loser" in a Democracy. (3) Because the approval rating scientific survey can be easily replicated for little cost if it was invalid Trump supporters could prove this. (4) No such alternative approval rating study was ever done. Therefore the weight of evidence of this one single fact proves that Trump knows that he is lying about being cheated in the election. https://projects.fivethirtyeight.com/trump-approval-ratings/?fbclid=IwAR2Bsb_QL3pYTQkzVu48FL1XM62unMND8eTksL87KZ-iDJI8DolmR_nBLHo -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 09:39 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <2LidnfwWkaK4U2TCnZ2dnUU7-emdnZ2d@giganews.com> |
| In reply to | #2499 |
On 1/9/2021 9:36 AM, olcott wrote: > On 1/9/2021 5:46 AM, Malcolm McLean wrote: >> On Saturday, 9 January 2021 at 02:35:52 UTC, olcott wrote: >>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote: >>> >>>> You have explained, clearly, the ways in which the two algorithms >>>> differ: one is a simulation that does not return a value, the other >>>> is a >>>> partial simulation that does. I can't see why you want to deny this >>>> now. It the core of the ruse you are trying to pull. >>> >>> How can you say something as stupid as this knowing that I have >>> repeatedly told you many times that there is only one single instance of >>> the machine code? >>> >> A halt decider has to be a function of the input machine and the input >> machine's tape. If it is a function of the input machine, the input >> machine's tape, and something else, even a simple flag, then it's >> easy to meet Linz's challenge. If you disguise the "something else" then >> it might be a clever cheat, but it's just a cheat. > > There cannot possibly be such thing as an actual cheat. > If the Halt decider correctly decides that the input meets the > specification of this infinite recursion axiom then it has correctly > decided what would otherwise be infinite recursion: > > We can see that the halt decider did correctly decide that the prior > invocation was infinitely recursive on the basis of: > (a) The same function is called > (b) From the same machine address > (c) With the same data // Richard Damon credit > (c) A second time > (d) Without any control flow instructions inbetween > >>> >>> I probably should give up talking to you, you are just like a person >>> that believes that Trump won by a landslide even though his approval >>> rating was always very subtantially under water. >>> >> Do you have access to intelligence briefings? If not, what makes you so >> sure that the President is incorrect when he maintains that the election >> was stolen from him by fraud? >> > > (1) Trump's approval rating has been under water by a large margin for > his whole term. (an average of 10% under water) > > (2) A presidential approval rating that has always been under water by a large > margin defines the term "election loser" in a Democracy. > > (3) Because the approval rating scientific survey can be easily > replicated for little cost if it was invalid Trump supporters could > prove this. > > (4) No such alternative approval rating study was ever done. > > Therefore the weight of evidence of this one single fact proves that > Trump knows that he is lying about being cheated in the election. > > https://projects.fivethirtyeight.com/trump-approval-ratings/?fbclid=IwAR2Bsb_QL3pYTQkzVu48FL1XM62unMND8eTksL87KZ-iDJI8DolmR_nBLHo > > > > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 10:33 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <86-dnUsh6Y1vR2TCnZ2dnUU7-d_NnZ2d@giganews.com> |
| In reply to | #2499 |
On 1/9/2021 10:12 AM, Malcolm McLean wrote: > On Saturday, 9 January 2021 at 15:36:42 UTC, olcott wrote: >> On 1/9/2021 5:46 AM, Malcolm McLean wrote: >>> On Saturday, 9 January 2021 at 02:35:52 UTC, olcott wrote: >>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote: >>>> >>>>> You have explained, clearly, the ways in which the two algorithms >>>>> differ: one is a simulation that does not return a value, the other is a >>>>> partial simulation that does. I can't see why you want to deny this >>>>> now. It the core of the ruse you are trying to pull. >>>> >>>> How can you say something as stupid as this knowing that I have >>>> repeatedly told you many times that there is only one single instance of >>>> the machine code? >>>> >>> A halt decider has to be a function of the input machine and the input >>> machine's tape. If it is a function of the input machine, the input >>> machine's tape, and something else, even a simple flag, then it's >>> easy to meet Linz's challenge. If you disguise the "something else" then >>> it might be a clever cheat, but it's just a cheat. >> There cannot possibly be such thing as an actual cheat. >> If the Halt decider correctly decides that the input meets the >> specification of this infinite recursion axiom then it has correctly >> decided what would otherwise be infinite recursion: >> We can see that the halt decider did correctly decide that the prior >> invocation was infinitely recursive on the basis of: >> (a) The same function is called >> (b) From the same machine address >> (c) With the same data // Richard Damon credit >> (c) A second time >> (d) Without any control flow instructions inbetween >> > c) must be wrong. It's impossible for a function of the same data > to behave in two different ways. The [detect infinite recursion axiom] detects that a function would continue to act in the same "infinite recursion" way unless its simulation was stopped. > You can however disguise the fact > that it's not operating on the same data. An there is no need to because H_Hat is always operating on its own machine address. >>>> >>>> I probably should give up talking to you, you are just like a person >>>> that believes that Trump won by a landslide even though his approval >>>> rating was always very subtantially under water. >>>> >>> Do you have access to intelligence briefings? If not, what makes you so >>> sure that the President is incorrect when he maintains that the election >>> was stolen from him by fraud? >>> >> (1) Trump's approval rating has been under water by a large margin for >> his whole term. (an average of 10% under water) >> >> (2) A presidential approval rating that has always been by a large >> margin defines the term "election loser" in a Democracy. >> >> (3) Because the approval rating scientific survey can be easily >> replicated for little cost if it was invalid Trump supporters could >> prove this. >> >> (4) No such alternative approval rating study was ever done. >> >> Therefore the weight of evidence of this one single fact proves that >> Trump knows that he is lying about being cheated in the election. >> > The polls grossly underestimated Trump's support. Trump said that > this was done deliberately by a biased media in order to create > momentum for Joe Biden. The same is likely true of approval ratings. > > Trump has access to intelligence reports, you do not. So Trump is Nothing in the world can overcome the simple fact that his approval rating was always under water by a large margin for his entire presidency besides an alternative scientific survey. https://projects.fivethirtyeight.com/trump-approval-ratings/?fbclid=IwAR2Bsb_QL3pYTQkzVu48FL1XM62unMND8eTksL87KZ-iDJI8DolmR_nBLHo If the scientific surveys that showed his approval rating was significantly under water for his whole presidency were fabricated his supporters would have immediately proved this with a counter-survey. Since his supporters never derived a counter-survey this is sufficiently conclusive proof that the approval rating surveys conveyed the actual truth. A president that has an approval rating that is never above -4% and mostly always -10% never ever wins reelection. The above link shows the ratings of many past presidents. Anyone that leads a concerted effort to overthrow a Democratic election by force commits the crime of Treason. https://www.law.cornell.edu/uscode/text/18/2381 > is a far better position than you to know whether the election was > fraudulent. Of course he also has a motive to lie or to deceive himself, > but that's just as much true of his opponents > > In short, you don't know whether the election was stolen or not. > Nor does any normal person. I certainly hope it wasn't, otherwise > it's the end of democracy. But it isn't a great stretch to believe > that Trump exceeded the tolerance of the American establishment.. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 13:18 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <TNGdndW8LPMUnGfCnZ2dnUU7-WHNnZ2d@giganews.com> |
| In reply to | #2499 |
On 1/9/2021 12:57 PM, Richard Damon wrote: > On 1/9/21 10:36 AM, olcott wrote: >> On 1/9/2021 5:46 AM, Malcolm McLean wrote: >>> On Saturday, 9 January 2021 at 02:35:52 UTC, olcott wrote: >>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote: >>>> >>>>> You have explained, clearly, the ways in which the two algorithms >>>>> differ: one is a simulation that does not return a value, the other >>>>> is a >>>>> partial simulation that does. I can't see why you want to deny this >>>>> now. It the core of the ruse you are trying to pull. >>>> >>>> How can you say something as stupid as this knowing that I have >>>> repeatedly told you many times that there is only one single instance of >>>> the machine code? >>>> >>> A halt decider has to be a function of the input machine and the input >>> machine's tape. If it is a function of the input machine, the input >>> machine's tape, and something else, even a simple flag, then it's >>> easy to meet Linz's challenge. If you disguise the "something else" then >>> it might be a clever cheat, but it's just a cheat. >> >> There cannot possibly be such thing as an actual cheat. >> If the Halt decider correctly decides that the input meets the >> specification of this infinite recursion axiom then it has correctly >> decided what would otherwise be infinite recursion: >> >> We can see that the halt decider did correctly decide that the prior >> invocation was infinitely recursive on the basis of: >> (a) The same function is called >> (b) From the same machine address >> (c) With the same data // Richard Damon credit >> (c) A second time >> (d) Without any control flow instructions inbetween > > > By which rules, Halts is infinitely recursive and thus non-halting and > thus fails to meet the requirements of a decider. > Did you notice that I gave you credit for the (c) part of that? This aspect was the only valid critique of any material imperfection of any aspect of my whole Halts() / H() correctly deciding H_Hat() presentation. Every other critique of the correctness of my work was entirely based on a lack of correct understanding. The halt decider simply simulates the program under test (PUT) until it detects that this PUT meets the infinite recursion detection axiom criteria. When we keep a strict wall of separation between the halt decider and its program under test then the halt decider only examines the execution trace of the program under test as the whole basis of its halting decision. When the infinite recursion detection axiom criteria is met then this meets the non-halting criteria: On 11/27/2020 9:02 PM, Ben Bacarisse wrote: > A computation that would not halt if its simulation were not > halted is indeed a non-halting computation. On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote: > Every computation that would not halt if its simulation > were not halted is by logical necessity a non-halting computation. Then the halt decider can stop simulating its input and report not halting. > The real probelm is that (d) isn't satisfied as there IS a control flow > instruction between, hidden in Halts. > > Your hiding that part of the trace is the cheat. > It is merely the strict wall of separation between the halt decider and its program under test. The halt decider only examines the behavior of the program under test until it determines that this behavior meets the criteria of one of the two non-halting AXIOMS. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 16:31 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <Vp6dnRLRdrUgs2fCnZ2dnUU7-efNnZ2d@giganews.com> |
| In reply to | #2503 |
On 1/9/2021 3:46 PM, Richard Damon wrote: > On 1/9/21 2:18 PM, olcott wrote: >> On 1/9/2021 12:57 PM, Richard Damon wrote: >>> On 1/9/21 10:36 AM, olcott wrote: >>>> On 1/9/2021 5:46 AM, Malcolm McLean wrote: >>>>> On Saturday, 9 January 2021 at 02:35:52 UTC, olcott wrote: >>>>>> On 1/8/2021 8:22 PM, Ben Bacarisse wrote: >>>>>> >>>>>>> You have explained, clearly, the ways in which the two algorithms >>>>>>> differ: one is a simulation that does not return a value, the other >>>>>>> is a >>>>>>> partial simulation that does. I can't see why you want to deny this >>>>>>> now. It the core of the ruse you are trying to pull. >>>>>> >>>>>> How can you say something as stupid as this knowing that I have >>>>>> repeatedly told you many times that there is only one single >>>>>> instance of >>>>>> the machine code? >>>>>> >>>>> A halt decider has to be a function of the input machine and the input >>>>> machine's tape. If it is a function of the input machine, the input >>>>> machine's tape, and something else, even a simple flag, then it's >>>>> easy to meet Linz's challenge. If you disguise the "something else" >>>>> then >>>>> it might be a clever cheat, but it's just a cheat. >>>> >>>> There cannot possibly be such thing as an actual cheat. >>>> If the Halt decider correctly decides that the input meets the >>>> specification of this infinite recursion axiom then it has correctly >>>> decided what would otherwise be infinite recursion: >>>> >>>> We can see that the halt decider did correctly decide that the prior >>>> invocation was infinitely recursive on the basis of: >>>> (a) The same function is called >>>> (b) From the same machine address >>>> (c) With the same data // Richard Damon credit >>>> (c) A second time >>>> (d) Without any control flow instructions inbetween >>> >>> >>> By which rules, Halts is infinitely recursive and thus non-halting and >>> thus fails to meet the requirements of a decider. >>> >> >> Did you notice that I gave you credit for the (c) part of that? > > Yes. >> >> This aspect was the only valid critique of any material imperfection of >> any aspect of my whole Halts() / H() correctly deciding H_Hat() >> presentation. Every other critique of the correctness of my work was >> entirely based on a lack of correct understanding. >> > > Nope, that was just a simple example that was quick to provide. > > You 'proof' fails the simple test of observing what happens after Halts > returns (or observing that Halts fails to returns and thus fails). > If you make sure to ignore every detail of the execution trace then based on this ignorance it may seemed that I have not proved my point. If you try to find an actual mistake and fail because there are no mistakes then (then and only then) you might understand. >> The halt decider simply simulates the program under test (PUT) until it >> detects that this PUT meets the infinite recursion detection axiom >> criteria. > > I note that you are now calling this rule an Axiom. An Axiom is usually > a generally accepted truth. Do you have ANY source (other than yourself) https://www.merriam-webster.com/dictionary/axiom 2: an established rule or principle or a self-evident truth Infinite Recursion detection AXIOM (a) Within an execution trace (b) The same function is called (c) From the same machine address (d) With the same data // Richard Damon credit (e) A second time (f) Without any control flow instructions inbetween I refer to this updated version as an axiom on the basis that it is impossibly false thus a [self-evident truth] as required by the definition of axiom. In epistemology (theory of knowledge), a self-evident proposition is a proposition that is known to be true by understanding its meaning without proof... https://en.wikipedia.org/wiki/Self-evidence That the same function called with the same data must derive the same result is an axiom of computer science. > of someone else proposing this 'Axiom' as you are using it. The other > definition is something self-evidently true to all, as far as I see, > only YOU seem to think this is self evident in the way you are using it. > It can be verified as true entirely on the basis of its meaning. > I will note, the key deficiency between YOUR use and what is generally > accepted is that you are excluding 'system' code in the loop. THAT is > what you need to establish as something commonly accepted. I have no idea what this could possibly mean. >> >> When we keep a strict wall of separation between the halt decider and >> its program under test then the halt decider only examines the execution >> trace of the program under test as the whole basis of its halting decision. >> >> When the infinite recursion detection axiom criteria is met then this >> meets the non-halting criteria: >> >> On 11/27/2020 9:02 PM, Ben Bacarisse wrote: >>> A computation that would not halt if its simulation were not >>> halted is indeed a non-halting computation. >> >> On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote: >>> Every computation that would not halt if its simulation >>> were not halted is by logical necessity a non-halting computation. >> >> Then the halt decider can stop simulating its input and report not halting. >> >>> The real probelm is that (d) isn't satisfied as there IS a control flow >>> instruction between, hidden in Halts. >>> >>> Your hiding that part of the trace is the cheat. >>> >> >> It is merely the strict wall of separation between the halt decider and >> its program under test. The halt decider only examines the behavior of >> the program under test until it determines that this behavior meets the >> criteria of one of the two non-halting AXIOMS. >> > > BUT that is incorrect. There should be a wall of seperation between > Halts and the program that it simulates, but there can NOT be a wall of > seperation between Halts and its caller. > There is ALWAYS a wall of separation between Halts() and the program that it simulates under every possible condition ALL THE TIME including when H_Hat() invokes Halts(). We are not freaking answering the question does H_Hat() halt on its freaking input? We are answering the question: Does the simulator of H_Hat() have to stop simulating H_Hat() to prevent the infinite execution of H_Hat() ? Halts() makes sure to screen out ALL of its own code (and all the operating system code) when it is doing halt deciding. It is utterly forbidden to examine its own code when it makes its halting decision. If Halts() was allowed to examine its own code this would taint the halting decision and not maintain the required wall of separation. > In fact, when Halts simulates the program under input, the trace it sees > should include ALL of the code that that input program generates, > NOTHING in there is really 'system' code, but it is ALL program under test. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 19:36 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <HN-dnVwEBeizx2fCnZ2dnUU7-YPNnZ2d@giganews.com> |
| In reply to | #2506 |
On 1/9/2021 7:22 PM, dklei...@gmail.com wrote:
> On Saturday, January 9, 2021 at 2:31:32 PM UTC-8, olcott wrote:
>>>
>> If you make sure to ignore every detail of the execution trace then
>> based on this ignorance it may seemed that I have not proved my point.
>>
>> If you try to find an actual mistake and fail because there are no
>> mistakes then (then and only then) you might understand.
>
> Reading an execution trace proves nothing. What is the point you imagine
> it will prove. No one will find any mistakes in the trace. It is simply a
> presentation of alleged facts.
>
If you understand the mapping between the C language and the x86
language and you understand this:
Infinite Recursion detection AXIOM
(a) Within an execution trace
(b) The same function is called
(c) From the same machine address
(d) With the same data // Richard Damon credit
(e) A second time
(f) Without any control flow instructions inbetween
then the x86 execution trace of this
void H_Hat(u32 P)
{
Output("H_Hat(P)", P);
u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
return;
}
int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt =", Input_Would_Halt);
}
proves this:
By showing how the simplest form of how the:
"Do the opposite of whatever the halt decider decides"
basis of all the conventional halting problem undecidability
proofs is correctly decided as non-halting I have refuted
the basis of all of these proofs.
Now we construct a new Turing machine D with H
as a subroutine. This new TM calls H to determine
what M does when the input to M is its own description
<M>. Once D has determined this information,
it does the opposite. That is, it rejects if M accepts and
accepts if M does not accept. (Sipser 1997)
http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-01-10 02:10 +0000 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <20210109180210.993@kylheku.com> |
| In reply to | #2509 |
["Followup-To:" header set to comp.theory.]
On 2021-01-10, olcott <NoOne@NoWhere.com> wrote:
> On 1/9/2021 7:22 PM, dklei...@gmail.com wrote:
>> On Saturday, January 9, 2021 at 2:31:32 PM UTC-8, olcott wrote:
>>>>
>>> If you make sure to ignore every detail of the execution trace then
>>> based on this ignorance it may seemed that I have not proved my point.
>>>
>>> If you try to find an actual mistake and fail because there are no
>>> mistakes then (then and only then) you might understand.
>>
>> Reading an execution trace proves nothing. What is the point you imagine
>> it will prove. No one will find any mistakes in the trace. It is simply a
>> presentation of alleged facts.
>>
>
> If you understand the mapping between the C language and the x86
> language and you understand this:
>
> Infinite Recursion detection AXIOM
> (a) Within an execution trace
> (b) The same function is called
> (c) From the same machine address
> (d) With the same data // Richard Damon credit
> (e) A second time
> (f) Without any control flow instructions inbetween
>
> then the x86 execution trace of this
>
> void H_Hat(u32 P)
> {
> Output("H_Hat(P)", P);
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> return;
> }
The fact is, that this obtains a value of 0 and halts.
You know it, which is why you refuse to post a test case which does
include that call.
> int main()
> {
> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
This call to Halts simulates H_Hat(H_Hat). That simulated H_Hat
is also progressing toward halting, because it calls Halts(P, P)
which is working toward the same zero. Only, this is never reached
because this is one simulation level deeper.
The inner Halts is looking for the same terminating condition, but since
it is nested, it has no chance to get that far. The outer-most, oldest
simulation terminates everything first.
Botom line, 0 is the wrong answer: H_Hat(H_Hat) halts. A top-level call
will clearly halt. The simulated H_Hat(H_Hat) doesn't have a chance to
halt, only because the simulator aborts the simulation and wrongly
proclaims that H_Hat(H_Hat) doesn't halt.
--
TXR Programming Language: http://nongnu.org/txr
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-09 23:12 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <Y5GdnRKKWYVfEWfCnZ2dnUU7-VfNnZ2d@giganews.com> |
| In reply to | #2510 |
On 1/9/2021 8:10 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-01-10, olcott <NoOne@NoWhere.com> wrote:
>> On 1/9/2021 7:22 PM, dklei...@gmail.com wrote:
>>> On Saturday, January 9, 2021 at 2:31:32 PM UTC-8, olcott wrote:
>>>>>
>>>> If you make sure to ignore every detail of the execution trace then
>>>> based on this ignorance it may seemed that I have not proved my point.
>>>>
>>>> If you try to find an actual mistake and fail because there are no
>>>> mistakes then (then and only then) you might understand.
>>>
>>> Reading an execution trace proves nothing. What is the point you imagine
>>> it will prove. No one will find any mistakes in the trace. It is simply a
>>> presentation of alleged facts.
>>>
>>
>> If you understand the mapping between the C language and the x86
>> language and you understand this:
>>
>> Infinite Recursion detection AXIOM
>> (a) Within an execution trace
>> (b) The same function is called
>> (c) From the same machine address
>> (d) With the same data // Richard Damon credit
>> (e) A second time
>> (f) Without any control flow instructions inbetween
>>
>> then the x86 execution trace of this
>>
>> void H_Hat(u32 P)
>> {
>> Output("H_Hat(P)", P);
>> u32 Input_Halts = Halts(P, P);
>> if (Input_Halts)
>> HERE: goto HERE;
>> return;
>> }
>
> The fact is, that this obtains a value of 0 and halts.
>
> You know it, which is why you refuse to post a test case which does
> include that call.
>
>> int main()
>> {
>> u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>
> This call to Halts simulates H_Hat(H_Hat). That simulated H_Hat
> is also progressing toward halting, because it calls Halts(P, P)
> which is working toward the same zero. Only, this is never reached
> because this is one simulation level deeper.
>
It is infinitely one simulation level deeper that is why aborting its
execution before it returns a value to H_Hat() is required.
> The inner Halts is looking for the same terminating condition, but since
> it is nested, it has no chance to get that far. The outer-most, oldest
> simulation terminates everything first.
>
> Botom line, 0 is the wrong answer: H_Hat(H_Hat) halts.
It is only the wrong answer if we are asking the question:
Does the input halt on its input?
If we are asking the question:
Does the simulation of the input have to be stopped to prevent its
otherwise infinite execution?
Then it is the right answer.
I may quit talking to you you seem too damned disrespectful.
You are totally ignoring my explanations.
> A top-level call
> will clearly halt. The simulated H_Hat(H_Hat) doesn't have a chance to
> halt, only because the simulator aborts the simulation and wrongly
> proclaims that H_Hat(H_Hat) doesn't halt.
>
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-01-11 12:34 -0600 |
| Subject | Re: Halting Problem Final Conclusion [2021 update to my 2004 statement](Boolean?) |
| Message-ID | <s7ednfJDcMW6B2HCnZ2dnUU7-dvNnZ2d@giganews.com> |
| In reply to | #2511 |
On 1/10/2021 7:53 AM, Malcolm McLean wrote: > On Sunday, 10 January 2021 at 13:40:10 UTC, Richard Damon wrote: >> On 1/10/21 12:12 AM, olcott wrote: >>> >>> >>> It is only the wrong answer if we are asking the question: >>> Does the input halt on its input? >>> >>> If we are asking the question: >>> Does the simulation of the input have to be stopped to prevent its >>> otherwise infinite execution? >>> >>> Then it is the right answer. >>> >> At which point you need to admit that you aren't working on the >> classical Hating Problem, which asks the first question, but some other >> question, and thus your answer isn't applicable to proofs like Linz >> which ARE based on the first question. >> >> Your insistance otherwise is basically saying that the you have made >> some amazing discovery about how dogs bark by studing the meow of the >> cat. Unless you can PROVE that the results happen to be applicable, it >> isn't. >> > There are two obvious cheats. > > The first is to say that H is not a function of P and I, but P, I and a flag which > is set when called from H_Hat, clear when called elsewhere. > The second is to say that H aborts rather than returning a value, so H_Hat > never gets the chance to invert its behaviour. This moronically stupid statement presumes that there are cases where a function called in infinite recursion must still return a value to its caller. Maybe there are also cases where a baby kitten actually is a type of office building? When a simulator simulates an input program on its input and this simulation would be infinite unless it was stopped then this simulator becomes a correct halt decider for this input when it decides to stop this simulation and report non-halting. > Stated as baldly as this, anyone would reject them as clearly violating the > conditions, and therefore of no interest. However if you disguise them, it might > not be so clear that this is the core of what you are doing. Changing the question > is the second cheat. To give credit where it is due, it's not entirely obvious that > this is what is happening. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 3 of 6 — ← Prev page 1 2 [3] 4 5 6 Next page →
Back to top | Article view | comp.software-eng
csiph-web