Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #25120 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2020-11-11 08:45 -0600 |
| Last post | 2020-11-12 22:11 -0600 |
| Articles | 20 on this page of 37 — 6 participants |
Back to article view | Back to comp.theory
Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) olcott <NoOne@NoWhere.com> - 2020-11-11 08:45 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2020-11-11 15:23 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) olcott <NoOne@NoWhere.com> - 2020-11-11 09:26 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-11 17:29 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) olcott <NoOne@NoWhere.com> - 2020-11-11 17:13 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-12 01:06 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology) olcott <NoOne@NoWhere.com> - 2020-11-11 19:20 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-12 02:08 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 00:09 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-12 08:06 -0700
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 09:19 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-12 10:40 -0700
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 12:21 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-12 12:09 -0700
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 22:46 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-13 01:22 -0700
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 07:55 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 07:57 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) André G. Isaak <agisaak@gm.invalid> - 2020-11-13 09:12 -0700
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 10:21 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 11:17 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 07:48 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 10:22 -0500
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 09:28 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 10:46 -0500
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 10:16 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-13 11:44 -0500
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-13 11:22 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-13 15:54 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-11-12 15:23 +0000
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 09:30 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-12 11:19 -0500
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 10:36 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Richard Damon <Richard@Damon-Family.org> - 2020-11-12 12:47 -0500
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2020-11-12 12:21 -0800
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 22:48 -0600
Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) olcott <NoOne@NoWhere.com> - 2020-11-12 22:11 -0600
Page 1 of 2 [1] 2 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-11 08:45 -0600 |
| Subject | Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added) |
| Message-ID | <99OdnUMIl-GGZDbCnZ2dnUU7-fHNnZ2d@giganews.com> |
// Simplified version of Linz H_Hat DOES NOT copy itself
01 void H_Hat(u32 P) // (bottom of page 319)
02 {
03 if (H(P, P))
04 HERE: goto HERE;
05 else
06 HALT
07 }
// Linz H with some of the ⊢* states shown
08 bool H(u32 P, u32 I) // Page 318
09 {
10 bool Halted = false;
11 bool Aborted = false;
12 while (!Halted && !Aborted)
13 {
14 Halted = DebugStep(P, I);
15 Aborted = Needs_To_Be_Aborted();
16 }
17 return !Aborted;
18 }
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company.
When-so-ever a halt decider correctly determines that its input would
never halt unless forced to halt by this halt decider this halt decider
has made a correct not-halting determination.
Unless H forces its input to halt: H(H_Hat, H_Hat) its first parameter
specifies infinite recursion at its line 03.
NEW MATERIAL ADDED HERE
int main()
H_Hat(H_Hat);
H_Hat(H_Hat) calls H(H_Hat, H_Hat) that decides that its first parameter
(also the parameter to H_Hat) would never halt unless the halt decider
forces them to halt. The execution trace proves that this is true.
H_Hat was intentionally designed to do the opposite of whatever the halt
decider decides to thwart a correct halting decision. The halt decider
got smarter and its halting decision is no longer thwarted.
The decision of every decider can only be correctly measured against its
input. The question is did the decider meet its own criterion measure
for its input?
Greater_Than(5,7) is false
Greater_Than(7,5) is true
When the criterion measure of a halt decider is:
Does the input have to be forced to stop to prevent its infinite execution?
And the input does have to be forced to stop to prevent its infinite
execution.
Then the halt decider necessarily made a correct halting decision.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2020-11-11 15:23 +0000 |
| Message-ID | <PoqdncKlmcZ-nDHCnZ2dnUU78VvNnZ2d@brightview.co.uk> |
| In reply to | #25120 |
On 11/11/2020 14:45, olcott wrote: <.. snip content already addressed many times in other posts ..>> > NEW MATERIAL ADDED HERE <.. snip content already addressed many times in other posts ..>> > Greater_Than(5,7) is false > Greater_Than(7,5) is true Irrelevant. Please stop spamming this newsgroup. Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-11 09:26 -0600 |
| Message-ID | <gfKdnT_tT51dnzHCnZ2dnUU7-YmdnZ2d@giganews.com> |
| In reply to | #25123 |
On 11/11/2020 9:23 AM, Mike Terry wrote: > On 11/11/2020 14:45, olcott wrote: > > <.. snip content already addressed many times in other posts ..>> > >> NEW MATERIAL ADDED HERE > > <.. snip content already addressed many times in other posts ..>> > >> Greater_Than(5,7) is false >> Greater_Than(7,5) is true > > Irrelevant. > > Please stop spamming this newsgroup. > > Mike. You can be in psychological denial of this yet cannot possibly show that it is incorrect: The decision of every decider can only be correctly measured against its input. The question is did the decider meet its own criterion measure for its input? -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-11 17:29 +0000 |
| Message-ID | <87eekzvm3j.fsf@bsb.me.uk> |
| In reply to | #25120 |
olcott <NoOne@NoWhere.com> writes:
> 01 void H_Hat(u32 P)
> 02 {
> 03 if (H(P, P))
> 04 HERE: goto HERE;
> 05 else
> 06 HALT
> 07 }
>
> 08 bool H(u32 P, u32 I)
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
> When-so-ever a halt decider correctly determines that its input would
> never halt unless forced to halt by this halt decider this halt
> decider has made a correct not-halting determination.
The applicable criterion is whether the input represents a finite
computation or not. You can repeat your own criterion as many times as
you like, but it is not what the halting problem is about.
H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
wrongly return false.
One thing has obviously now become clear to you: determining the halting
of the input program exactly as it is given is not possible in all
cases. You have had to resort to redefining what that problem is.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-11 17:13 -0600 |
| Message-ID | <gL2dnS-jao2E7THCnZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #25136 |
On 11/11/2020 11:29 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> 01 void H_Hat(u32 P)
>> 02 {
>> 03 if (H(P, P))
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>>
>> 08 bool H(u32 P, u32 I)
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>
>> When-so-ever a halt decider correctly determines that its input would
>> never halt unless forced to halt by this halt decider this halt
>> decider has made a correct not-halting determination.
>
> The applicable criterion is whether the input represents a finite
> computation or not. You can repeat your own criterion as many times as
> you like, but it is not what the halting problem is about.
>
> H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
> wrongly return false.
>
> One thing has obviously now become clear to you: determining the halting
> of the input program exactly as it is given is not possible in all
> cases. You have had to resort to redefining what that problem is.
>
The problem is exactly the same the only thing that has changed is the
criterion measure that defines the set of halting and not-halting
computations.
PROOF We assume that ATM is decidable and obtain a
contradiction. Suppose that H is a decider for ATM.
On input <M, w>, where M is a TM and w is a string,
H halts and accepts if M accepts w. Furthermore, H
halts and rejects if M fails to accept w. In other words,
we assume that H is a TM, where
H(<M, w>) =
{ accept if M accepts w
{ reject if M does not accept w.
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.
D = "On input <M>, where M is a TM:
1. Run H on input <M, <M>>.
2. Output the opposite of what H outputs;
that is if H accepts, reject and if H rejects, accept."
http://www.liarparadox.org/sipser_165.pdf
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston:
PWS Publishing Company (165-167)
The new criterion measure can not be fooled by an input that does the
opposite of whatever the halt decider decides.
When we change the criterion measure from:
(a) Does machine M halt on its input w?
To this new criteria:
(b) When machine <M> on input w is simulated on UTM H does this
simulation have to be forced to stop to prevent its infinite execution?
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-12 01:06 +0000 |
| Message-ID | <87o8k3s7rt.fsf@bsb.me.uk> |
| In reply to | #25147 |
olcott <NoOne@NoWhere.com> writes:
> On 11/11/2020 11:29 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> 01 void H_Hat(u32 P)
>>> 02 {
>>> 03 if (H(P, P))
>>> 04 HERE: goto HERE;
>>> 05 else
>>> 06 HALT
>>> 07 }
>>>
>>> 08 bool H(u32 P, u32 I)
>>> 09 {
>>> 10 bool Halted = false;
>>> 11 bool Aborted = false;
>>> 12 while (!Halted && !Aborted)
>>> 13 {
>>> 14 Halted = DebugStep(P, I);
>>> 15 Aborted = Needs_To_Be_Aborted();
>>> 16 }
>>> 17 return !Aborted;
>>> 18 }
>>
>>> When-so-ever a halt decider correctly determines that its input would
>>> never halt unless forced to halt by this halt decider this halt
>>> decider has made a correct not-halting determination.
>>
>> The applicable criterion is whether the input represents a finite
>> computation or not. You can repeat your own criterion as many times as
>> you like, but it is not what the halting problem is about.
>>
>> H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
>> wrongly return false.
>>
>> One thing has obviously now become clear to you: determining the halting
>> of the input program exactly as it is given is not possible in all
>> cases. You have had to resort to redefining what that problem is.
>
> The problem is exactly the same the only thing that has changed is the
> criterion measure that defines the set of halting and not-halting
> computations.
This is one of the silliest things you have every said, and that is a
high bar. You don't get to re-define what a halting computation is.
H(H_Hat, H_Hat) is false but H_Hat(H_Hat) is a finite computation. Move
on.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-11 19:20 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology) |
| Message-ID | <QbydnSYawPNcEDHCnZ2dnUU7-RHNnZ2d@giganews.com> |
| In reply to | #25161 |
On 11/11/2020 7:06 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/11/2020 11:29 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> 01 void H_Hat(u32 P)
>>>> 02 {
>>>> 03 if (H(P, P))
>>>> 04 HERE: goto HERE;
>>>> 05 else
>>>> 06 HALT
>>>> 07 }
>>>>
>>>> 08 bool H(u32 P, u32 I)
>>>> 09 {
>>>> 10 bool Halted = false;
>>>> 11 bool Aborted = false;
>>>> 12 while (!Halted && !Aborted)
>>>> 13 {
>>>> 14 Halted = DebugStep(P, I);
>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>> 16 }
>>>> 17 return !Aborted;
>>>> 18 }
>>>
>>>> When-so-ever a halt decider correctly determines that its input would
>>>> never halt unless forced to halt by this halt decider this halt
>>>> decider has made a correct not-halting determination.
>>>
>>> The applicable criterion is whether the input represents a finite
>>> computation or not. You can repeat your own criterion as many times as
>>> you like, but it is not what the halting problem is about.
>>>
>>> H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
>>> wrongly return false.
>>>
>>> One thing has obviously now become clear to you: determining the halting
>>> of the input program exactly as it is given is not possible in all
>>> cases. You have had to resort to redefining what that problem is.
>>
>> The problem is exactly the same the only thing that has changed is the
>> criterion measure that defines the set of halting and not-halting
>> computations.
>
> This is one of the silliest things you have every said, and that is a
> high bar. You don't get to re-define what a halting computation is.
>
> H(H_Hat, H_Hat) is false but H_Hat(H_Hat) is a finite computation. Move
> on.
>
So in other words you are saying that:
A computation that would never halt unless forced to halt would halt
without being forced to halt?
Do you understand what a tautology is?
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-11-12 02:08 +0000 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology) |
| Message-ID | <87d00js4wp.fsf@bsb.me.uk> |
| In reply to | #25163 |
olcott <NoOne@NoWhere.com> writes:
> On 11/11/2020 7:06 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 11/11/2020 11:29 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> 01 void H_Hat(u32 P)
>>>>> 02 {
>>>>> 03 if (H(P, P))
>>>>> 04 HERE: goto HERE;
>>>>> 05 else
>>>>> 06 HALT
>>>>> 07 }
>>>>>
>>>>> 08 bool H(u32 P, u32 I)
>>>>> 09 {
>>>>> 10 bool Halted = false;
>>>>> 11 bool Aborted = false;
>>>>> 12 while (!Halted && !Aborted)
>>>>> 13 {
>>>>> 14 Halted = DebugStep(P, I);
>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>> 16 }
>>>>> 17 return !Aborted;
>>>>> 18 }
>>>>
>>>>> When-so-ever a halt decider correctly determines that its input would
>>>>> never halt unless forced to halt by this halt decider this halt
>>>>> decider has made a correct not-halting determination.
>>>>
>>>> The applicable criterion is whether the input represents a finite
>>>> computation or not. You can repeat your own criterion as many times as
>>>> you like, but it is not what the halting problem is about.
>>>>
>>>> H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
>>>> wrongly return false.
>>>>
>>>> One thing has obviously now become clear to you: determining the halting
>>>> of the input program exactly as it is given is not possible in all
>>>> cases. You have had to resort to redefining what that problem is.
>>>
>>> The problem is exactly the same the only thing that has changed is the
>>> criterion measure that defines the set of halting and not-halting
>>> computations.
>>
>> This is one of the silliest things you have every said, and that is a
>> high bar. You don't get to re-define what a halting computation is.
>>
>> H(H_Hat, H_Hat) is false but H_Hat(H_Hat) is a finite computation. Move
>> on.
>
> So in other words you are saying that:
>
> A computation that would never halt unless forced to halt would halt
> without being forced to halt?
No. There are no hypotheticals ("would...", "would not...") in my
statement. You can not possibly fail to understand these two simple
facts:
(1) H(H_Hat, H_Hat) is false
(2) H_Hat(H_Hat) is a finite computation
They show that H is wrong about that one case. Redefining what the
right answer is is just pathetic.
(I've started to avoid saying "halting computation" preferring "finite
computation" instead simply because of your pathetic ruse to redefine
what a halting computation is. In the end, all discussions with cranks
end up in a mess of re-defined words.)
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-12 00:09 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <D5idnX7ICPwJTDHCnZ2dnUU7-KHNnZ2d@giganews.com> |
| In reply to | #25171 |
On 11/11/2020 8:08 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/11/2020 7:06 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/11/2020 11:29 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> 01 void H_Hat(u32 P)
>>>>>> 02 {
>>>>>> 03 if (H(P, P))
>>>>>> 04 HERE: goto HERE;
>>>>>> 05 else
>>>>>> 06 HALT
>>>>>> 07 }
>>>>>>
>>>>>> 08 bool H(u32 P, u32 I)
>>>>>> 09 {
>>>>>> 10 bool Halted = false;
>>>>>> 11 bool Aborted = false;
>>>>>> 12 while (!Halted && !Aborted)
>>>>>> 13 {
>>>>>> 14 Halted = DebugStep(P, I);
>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>> 16 }
>>>>>> 17 return !Aborted;
>>>>>> 18 }
>>>>>
>>>>>> When-so-ever a halt decider correctly determines that its input would
>>>>>> never halt unless forced to halt by this halt decider this halt
>>>>>> decider has made a correct not-halting determination.
>>>>>
>>>>> The applicable criterion is whether the input represents a finite
>>>>> computation or not. You can repeat your own criterion as many times as
>>>>> you like, but it is not what the halting problem is about.
>>>>>
>>>>> H_Hat(H_Hat) is (apparently) a finite computation, and H(H_Hat, H_Hat)
>>>>> wrongly return false.
>>>>>
>>>>> One thing has obviously now become clear to you: determining the halting
>>>>> of the input program exactly as it is given is not possible in all
>>>>> cases. You have had to resort to redefining what that problem is.
>>>>
>>>> The problem is exactly the same the only thing that has changed is the
>>>> criterion measure that defines the set of halting and not-halting
>>>> computations.
>>>
>>> This is one of the silliest things you have every said, and that is a
>>> high bar. You don't get to re-define what a halting computation is.
>>>
>>> H(H_Hat, H_Hat) is false but H_Hat(H_Hat) is a finite computation. Move
>>> on.
>>
>> So in other words you are saying that:
>>
>> A computation that would never halt unless forced to halt would halt
>> without being forced to halt?
>
> No. There are no hypotheticals ("would...", "would not...") in my
> statement. You can not possibly fail to understand these two simple
> facts:
>
> (1) H(H_Hat, H_Hat) is false
It is an easily verified fact that the above computation would never
halt unless the halt decider forces it to halt. Do you deny this
verified fact?
> (2) H_Hat(H_Hat) is a finite computation
>
> They show that H is wrong about that one case. Redefining what the
> right answer is is just pathetic.
>
> (I've started to avoid saying "halting computation" preferring "finite
> computation" instead simply because of your pathetic ruse to redefine
> what a halting computation is. In the end, all discussions with cranks
> end up in a mess of re-defined words.)
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-12 08:06 -0700 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <rojj2h$jl2$1@dont-email.me> |
| In reply to | #25178 |
On 2020-11-11 23:09, olcott wrote:
> On 11/11/2020 8:08 PM, Ben Bacarisse wrote:
>> No. There are no hypotheticals ("would...", "would not...") in my
>> statement. You can not possibly fail to understand these two simple
>> facts:
>>
>> (1) H(H_Hat, H_Hat) is false
>
> It is an easily verified fact that the above computation would never
> halt unless the halt decider forces it to halt. Do you deny this
> verified fact?
I'm not sure how you can justify calling a statement which is simply
wrong a fact, let alone a verified fact. That's like stating that Biden
didn't win is a fact.
Several different people have provided clear demonstrations that
H(H_Hat, H_Hat) will halt even if the uppermost abort code doesn't force
its input to halt. You have either ignored these arguments entirely or
claimed that they were 'too convoluted'.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-12 09:19 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <1PadnXhiTNMWzzDCnZ2dnUU7-Q_NnZ2d@giganews.com> |
| In reply to | #25189 |
On 11/12/2020 9:06 AM, André G. Isaak wrote:
> On 2020-11-11 23:09, olcott wrote:
>> On 11/11/2020 8:08 PM, Ben Bacarisse wrote:
>
>>> No. There are no hypotheticals ("would...", "would not...") in my
>>> statement. You can not possibly fail to understand these two simple
>>> facts:
>>>
>>> (1) H(H_Hat, H_Hat) is false
>>
>> It is an easily verified fact that the above computation would never
>> halt unless the halt decider forces it to halt. Do you deny this
>> verified fact?
>
> I'm not sure how you can justify calling a statement which is simply
> wrong a fact, let alone a verified fact. That's like stating that Biden
> didn't win is a fact.
OK that is great. There is no sense talking with people that deny
verified facts. I will focus on completing x86utm so that I have
empirical proof that it is a verified fact.
// Simplified Linz Ĥ (bottom of page 319)
01 void H_Hat(u32 P)
02 {
03 if (H(P, P))
04 HERE: goto HERE;
05 else
06 HALT
07 }
// Linz H with some of the ⊢* states shown
08 bool H(u32 P, u32 I) // Page 318
09 {
10 bool Halted = false;
11 bool Aborted = false;
12 while (!Halted && !Aborted)
13 {
14 Halted = DebugStep(P, I);
15 Aborted = Needs_To_Be_Aborted();
16 }
17 return !Aborted;
18 }
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company.
> Several different people have provided clear demonstrations that
> H(H_Hat, H_Hat) will halt even if the uppermost abort code doesn't force
> its input to halt. You have either ignored these arguments entirely or
> claimed that they were 'too convoluted'.
>
> André
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-12 10:40 -0700 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <rojs1q$rb2$1@dont-email.me> |
| In reply to | #25191 |
On 2020-11-12 08:19, olcott wrote:
> On 11/12/2020 9:06 AM, André G. Isaak wrote:
>> On 2020-11-11 23:09, olcott wrote:
>>> On 11/11/2020 8:08 PM, Ben Bacarisse wrote:
>>
>>>> No. There are no hypotheticals ("would...", "would not...") in my
>>>> statement. You can not possibly fail to understand these two simple
>>>> facts:
>>>>
>>>> (1) H(H_Hat, H_Hat) is false
>>>
>>> It is an easily verified fact that the above computation would never
>>> halt unless the halt decider forces it to halt. Do you deny this
>>> verified fact?
>>
>> I'm not sure how you can justify calling a statement which is simply
>> wrong a fact, let alone a verified fact. That's like stating that
>> Biden didn't win is a fact.
>
> OK that is great. There is no sense talking with people that deny
> verified facts. I will focus on completing x86utm so that I have
> empirical proof that it is a verified fact.
Maybe you should actually address the argument I provided, which I will
repeat below.
The following is a modified version of your code. As I stated, the only
difference between this code and yours is that in this version the
uppermost call to H *and only the uppermost call* to H has its abort
code disabled.
According to you, H, when called with (H_Hat, H_Hat) as its input *must*
abort its input to prevent it from running forever, but the following
does *not* run forever despite the fact that the uppermost H cannot
abort its input.
So your claim that this "computation would never halt unless the halt
decider forces it to halt" is a "verified fact" is simply false. It is
not a fact at all.
int main()
{
H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
}
// Simplified version of Linz H_Hat DOES NOT copy itself
01 void H_Hat(u32 P) // (bottom of page 319)
02 {
03 if (H(P, P, true)) // **** ADDED PARAMETER ****
04 HERE: goto HERE;
05 else
06 HALT
07 }
// Linz H with some of the ⊢* states shown
08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
09 {
10 bool Halted = false;
11 bool Aborted = false;
12 while (!Halted && !Aborted)
13 {
14 Halted = DebugStep(P, I);
14.5 if UseAbortCode // ***** ADDED LINE *****
15 Aborted = Needs_To_Be_Aborted();
16 }
17 return !Aborted;
18 }
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-12 12:21 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <6sKdnbsZcO6i4DDCnZ2dnUU7-b3NnZ2d@giganews.com> |
| In reply to | #25199 |
On 11/12/2020 11:40 AM, André G. Isaak wrote:
> On 2020-11-12 08:19, olcott wrote:
>> On 11/12/2020 9:06 AM, André G. Isaak wrote:
>>> On 2020-11-11 23:09, olcott wrote:
>>>> On 11/11/2020 8:08 PM, Ben Bacarisse wrote:
>>>
>>>>> No. There are no hypotheticals ("would...", "would not...") in my
>>>>> statement. You can not possibly fail to understand these two simple
>>>>> facts:
>>>>>
>>>>> (1) H(H_Hat, H_Hat) is false
>>>>
>>>> It is an easily verified fact that the above computation would never
>>>> halt unless the halt decider forces it to halt. Do you deny this
>>>> verified fact?
>>>
>>> I'm not sure how you can justify calling a statement which is simply
>>> wrong a fact, let alone a verified fact. That's like stating that
>>> Biden didn't win is a fact.
>>
>> OK that is great. There is no sense talking with people that deny
>> verified facts. I will focus on completing x86utm so that I have
>> empirical proof that it is a verified fact.
>
> Maybe you should actually address the argument I provided, which I will
> repeat below.
>
> The following is a modified version of your code. As I stated, the only
> difference between this code and yours is that in this version the
> uppermost call to H *and only the uppermost call* to H has its abort
> code disabled.
>
> According to you, H, when called with (H_Hat, H_Hat) as its input *must*
> abort its input to prevent it from running forever, but the following
> does *not* run forever despite the fact that the uppermost H cannot
> abort its input.
>
> So your claim that this "computation would never halt unless the halt
> decider forces it to halt" is a "verified fact" is simply false. It is
> not a fact at all.
>
> int main()
> {
> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
> }
>
> // Simplified version of Linz H_Hat DOES NOT copy itself
> 01 void H_Hat(u32 P) // (bottom of page 319)
> 02 {
> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
> 04 HERE: goto HERE;
> 05 else
> 06 HALT
> 07 }
>
> // Linz H with some of the ⊢* states shown
> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
> 09 {
> 10 bool Halted = false;
> 11 bool Aborted = false;
> 12 while (!Halted && !Aborted)
> 13 {
> 14 Halted = DebugStep(P, I);
> 14.5 if UseAbortCode // ***** ADDED LINE *****
> 15 Aborted = Needs_To_Be_Aborted();
> 16 }
> 17 return !Aborted;
> 18 }
>
> André
>
I am not completely certain exactly what that execution trace would do.
I am completely certain that unless one of the H_Hat invocations in the
otherwise infinitely recursive call chain is aborted that H_Hat()
continues to execute infinite recursion.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-12 12:09 -0700 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <rok18h$4lb$1@dont-email.me> |
| In reply to | #25201 |
On 2020-11-12 11:21, olcott wrote:
> On 11/12/2020 11:40 AM, André G. Isaak wrote:
<snippage>
>> The following is a modified version of your code. As I stated, the
>> only difference between this code and yours is that in this version
>> the uppermost call to H *and only the uppermost call* to H has its
>> abort code disabled.
>>
>> According to you, H, when called with (H_Hat, H_Hat) as its input
>> *must* abort its input to prevent it from running forever, but the
>> following does *not* run forever despite the fact that the uppermost H
>> cannot abort its input.
>>
>> So your claim that this "computation would never halt unless the halt
>> decider forces it to halt" is a "verified fact" is simply false. It is
>> not a fact at all.
>>
>> int main()
>> {
>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>> }
>>
>> // Simplified version of Linz H_Hat DOES NOT copy itself
>> 01 void H_Hat(u32 P) // (bottom of page 319)
>> 02 {
>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>> 04 HERE: goto HERE;
>> 05 else
>> 06 HALT
>> 07 }
>>
>> // Linz H with some of the ⊢* states shown
>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>> 09 {
>> 10 bool Halted = false;
>> 11 bool Aborted = false;
>> 12 while (!Halted && !Aborted)
>> 13 {
>> 14 Halted = DebugStep(P, I);
>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>> 15 Aborted = Needs_To_Be_Aborted();
>> 16 }
>> 17 return !Aborted;
>> 18 }
>>
>> André
>>
>
> I am not completely certain exactly what that execution trace would do.
Well, since it's a trivial modification of your own code, tracing
shouldn't be too difficult.
H emulates H_Hat(H_Hat), but with its abort code disabled so it cannot
abort H_Hat(H_Hat).
The outer H_Hat calls H again to emulate the Inner H_Hat.
The H called by H_Hat aborts the inner H_Hat.
That H then returns control to the outer H_Hat which terminates.
Control returns to the uppermost H which then also terminates.
The point is that H_Hat(H_Hat) *will* terminate on its own. Your claim
that the uppermost H *had* to terminate H_Hat(H_Hat) is simply false. If
your outermost H does not terminate it, it will not go into infinite
execution; it will halt.
> I am completely certain that unless one of the H_Hat invocations in the
> otherwise infinitely recursive call chain is aborted that H_Hat()
> continues to execute infinite recursion.
Yes, but in your code it is the *wrong* instance of your H that is doing
the aborting. The outermost H absolutely does not *have* to terminate
its input, as the emulated H_Hat(H_Hat) *would* terminate without being
aborted by the outer H.
And that is fundamentally what the halting problems asks: does
H_Hat(H_Hat) halt on its own? It does, except that your outermost H
doesn't let it get that far, which means that your outermost H isn't
correctly answering the question you claim it is answering, i.e. did I
*have* to halt my input to prevent an infinite execution.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-12 22:46 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <gZqdncfvF40HkjPCnZ2dnUU7-U_NnZ2d@giganews.com> |
| In reply to | #25204 |
On 11/12/2020 1:09 PM, André G. Isaak wrote:
> On 2020-11-12 11:21, olcott wrote:
>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>
> <snippage>
>
>>> The following is a modified version of your code. As I stated, the
>>> only difference between this code and yours is that in this version
>>> the uppermost call to H *and only the uppermost call* to H has its
>>> abort code disabled.
>>>
>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>> *must* abort its input to prevent it from running forever, but the
>>> following does *not* run forever despite the fact that the uppermost
>>> H cannot abort its input.
>>>
>>> So your claim that this "computation would never halt unless the halt
>>> decider forces it to halt" is a "verified fact" is simply false. It
>>> is not a fact at all.
>>>
>>> int main()
>>> {
>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>> }
>>>
>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>> 02 {
>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>> 04 HERE: goto HERE;
>>> 05 else
>>> 06 HALT
>>> 07 }
>>>
>>> // Linz H with some of the ⊢* states shown
>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>> 09 {
>>> 10 bool Halted = false;
>>> 11 bool Aborted = false;
>>> 12 while (!Halted && !Aborted)
>>> 13 {
>>> 14 Halted = DebugStep(P, I);
>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>> 15 Aborted = Needs_To_Be_Aborted();
>>> 16 }
>>> 17 return !Aborted;
>>> 18 }
>>>
>>> André
>>>
>>
>> I am not completely certain exactly what that execution trace would do.
>
> Well, since it's a trivial modification of your own code, tracing
> shouldn't be too difficult.
>
> H emulates H_Hat(H_Hat), but with its abort code disabled so it cannot
> abort H_Hat(H_Hat).
>
> The outer H_Hat calls H again to emulate the Inner H_Hat.
>
> The H called by H_Hat aborts the inner H_Hat.
>
> That H then returns control to the outer H_Hat which terminates.
>
> Control returns to the uppermost H which then also terminates.
>
> The point is that H_Hat(H_Hat) *will* terminate on its own. Your claim
> that the uppermost H *had* to terminate H_Hat(H_Hat) is simply false. If
> your outermost H does not terminate it, it will not go into infinite
> execution; it will halt.
>
>> I am completely certain that unless one of the H_Hat invocations in
>> the otherwise infinitely recursive call chain is aborted that H_Hat()
>> continues to execute infinite recursion.
>
> Yes, but in your code it is the *wrong* instance of your H that is doing
> the aborting. The outermost H absolutely does not *have* to terminate
> its input, as the emulated H_Hat(H_Hat) *would* terminate without being
> aborted by the outer H.
>
> And that is fundamentally what the halting problems asks: does
> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
> doesn't let it get that far, which means that your outermost H isn't
> correctly answering the question you claim it is answering, i.e. did I
> *have* to halt my input to prevent an infinite execution.
>
> André
>
When-so-ever UTM halt decider H decides that:
(1) its input (<P>,I) would never halt unless H stopped simulating it
and
(2) its input (<P>,I) would never halt unless H stopped simulating it
then H has made a correct not-halting decision on this input.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-13 01:22 -0700 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <rolfok$l7u$1@dont-email.me> |
| In reply to | #25210 |
On 2020-11-12 21:46, olcott wrote:
> On 11/12/2020 1:09 PM, André G. Isaak wrote:
>> On 2020-11-12 11:21, olcott wrote:
>>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>>
>> <snippage>
>>
>>>> The following is a modified version of your code. As I stated, the
>>>> only difference between this code and yours is that in this version
>>>> the uppermost call to H *and only the uppermost call* to H has its
>>>> abort code disabled.
>>>>
>>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>>> *must* abort its input to prevent it from running forever, but the
>>>> following does *not* run forever despite the fact that the uppermost
>>>> H cannot abort its input.
>>>>
>>>> So your claim that this "computation would never halt unless the
>>>> halt decider forces it to halt" is a "verified fact" is simply
>>>> false. It is not a fact at all.
>>>>
>>>> int main()
>>>> {
>>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>>> }
>>>>
>>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>>> 02 {
>>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>>> 04 HERE: goto HERE;
>>>> 05 else
>>>> 06 HALT
>>>> 07 }
>>>>
>>>> // Linz H with some of the ⊢* states shown
>>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>>> 09 {
>>>> 10 bool Halted = false;
>>>> 11 bool Aborted = false;
>>>> 12 while (!Halted && !Aborted)
>>>> 13 {
>>>> 14 Halted = DebugStep(P, I);
>>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>> 16 }
>>>> 17 return !Aborted;
>>>> 18 }
>>>>
>>>> André
>>>>
>>>
>>> I am not completely certain exactly what that execution trace would do.
>>
>> Well, since it's a trivial modification of your own code, tracing
>> shouldn't be too difficult.
>>
>> H emulates H_Hat(H_Hat), but with its abort code disabled so it cannot
>> abort H_Hat(H_Hat).
>>
>> The outer H_Hat calls H again to emulate the Inner H_Hat.
>>
>> The H called by H_Hat aborts the inner H_Hat.
>>
>> That H then returns control to the outer H_Hat which terminates.
>>
>> Control returns to the uppermost H which then also terminates.
>>
>> The point is that H_Hat(H_Hat) *will* terminate on its own. Your claim
>> that the uppermost H *had* to terminate H_Hat(H_Hat) is simply false.
>> If your outermost H does not terminate it, it will not go into
>> infinite execution; it will halt.
>>
>>> I am completely certain that unless one of the H_Hat invocations in
>>> the otherwise infinitely recursive call chain is aborted that H_Hat()
>>> continues to execute infinite recursion.
>>
>> Yes, but in your code it is the *wrong* instance of your H that is
>> doing the aborting. The outermost H absolutely does not *have* to
>> terminate its input, as the emulated H_Hat(H_Hat) *would* terminate
>> without being aborted by the outer H.
>>
>> And that is fundamentally what the halting problems asks: does
>> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
>> doesn't let it get that far, which means that your outermost H isn't
>> correctly answering the question you claim it is answering, i.e. did I
>> *have* to halt my input to prevent an infinite execution.
>>
>> André
>>
>
> When-so-ever UTM halt decider H decides that:
> (1) its input (<P>,I) would never halt unless H stopped simulating it
> and
> (2) its input (<P>,I) would never halt unless H stopped simulating it
> then H has made a correct not-halting decision on this input.
It's unclear to me what you hope to achieve by repeating this mantra.
The point I make above is that clause (2) of your mantra is not met in
this case, meaning that H has not made the correct decision on this input.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 07:55 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <R-GdnW9VNrf5DTPCnZ2dnUU7-SPNnZ2d@giganews.com> |
| In reply to | #25212 |
On 11/13/2020 2:22 AM, André G. Isaak wrote:
> On 2020-11-12 21:46, olcott wrote:
>> On 11/12/2020 1:09 PM, André G. Isaak wrote:
>>> On 2020-11-12 11:21, olcott wrote:
>>>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>>>
>>> <snippage>
>>>
>>>>> The following is a modified version of your code. As I stated, the
>>>>> only difference between this code and yours is that in this version
>>>>> the uppermost call to H *and only the uppermost call* to H has its
>>>>> abort code disabled.
>>>>>
>>>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>>>> *must* abort its input to prevent it from running forever, but the
>>>>> following does *not* run forever despite the fact that the
>>>>> uppermost H cannot abort its input.
>>>>>
>>>>> So your claim that this "computation would never halt unless the
>>>>> halt decider forces it to halt" is a "verified fact" is simply
>>>>> false. It is not a fact at all.
>>>>>
>>>>> int main()
>>>>> {
>>>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>>>> }
>>>>>
>>>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>>>> 02 {
>>>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>>>> 04 HERE: goto HERE;
>>>>> 05 else
>>>>> 06 HALT
>>>>> 07 }
>>>>>
>>>>> // Linz H with some of the ⊢* states shown
>>>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>>>> 09 {
>>>>> 10 bool Halted = false;
>>>>> 11 bool Aborted = false;
>>>>> 12 while (!Halted && !Aborted)
>>>>> 13 {
>>>>> 14 Halted = DebugStep(P, I);
>>>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>> 16 }
>>>>> 17 return !Aborted;
>>>>> 18 }
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I am not completely certain exactly what that execution trace would do.
>>>
>>> Well, since it's a trivial modification of your own code, tracing
>>> shouldn't be too difficult.
>>>
>>> H emulates H_Hat(H_Hat), but with its abort code disabled so it
>>> cannot abort H_Hat(H_Hat).
>>>
>>> The outer H_Hat calls H again to emulate the Inner H_Hat.
>>>
>>> The H called by H_Hat aborts the inner H_Hat.
>>>
>>> That H then returns control to the outer H_Hat which terminates.
>>>
>>> Control returns to the uppermost H which then also terminates.
>>>
>>> The point is that H_Hat(H_Hat) *will* terminate on its own. Your
>>> claim that the uppermost H *had* to terminate H_Hat(H_Hat) is simply
>>> false. If your outermost H does not terminate it, it will not go into
>>> infinite execution; it will halt.
>>>
>>>> I am completely certain that unless one of the H_Hat invocations in
>>>> the otherwise infinitely recursive call chain is aborted that
>>>> H_Hat() continues to execute infinite recursion.
>>>
>>> Yes, but in your code it is the *wrong* instance of your H that is
>>> doing the aborting. The outermost H absolutely does not *have* to
>>> terminate its input, as the emulated H_Hat(H_Hat) *would* terminate
>>> without being aborted by the outer H.
>>>
>>> And that is fundamentally what the halting problems asks: does
>>> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
>>> doesn't let it get that far, which means that your outermost H isn't
>>> correctly answering the question you claim it is answering, i.e. did
>>> I *have* to halt my input to prevent an infinite execution.
>>>
>>> André
>>>
>>
>> When-so-ever UTM halt decider H decides that:
>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>> and
>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>> then H has made a correct not-halting decision on this input.
>
> It's unclear to me what you hope to achieve by repeating this mantra.
> The point I make above is that clause (2) of your mantra is not met in
> this case, meaning that H has not made the correct decision on this input.
>
> André
>
Your modification to an otherwise correct halt decider was merely a
convoluted example of the original example of simply removing line 14
altogether and then on the basis of this breaking change claiming that
the halt decider does not work.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 07:57 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <R-GdnW5VNrczDTPCnZ2dnUU7-SOdnZ2d@giganews.com> |
| In reply to | #25215 |
On 11/13/2020 7:55 AM, olcott wrote:
> On 11/13/2020 2:22 AM, André G. Isaak wrote:
>> On 2020-11-12 21:46, olcott wrote:
>>> On 11/12/2020 1:09 PM, André G. Isaak wrote:
>>>> On 2020-11-12 11:21, olcott wrote:
>>>>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>>>>
>>>> <snippage>
>>>>
>>>>>> The following is a modified version of your code. As I stated, the
>>>>>> only difference between this code and yours is that in this
>>>>>> version the uppermost call to H *and only the uppermost call* to H
>>>>>> has its abort code disabled.
>>>>>>
>>>>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>>>>> *must* abort its input to prevent it from running forever, but the
>>>>>> following does *not* run forever despite the fact that the
>>>>>> uppermost H cannot abort its input.
>>>>>>
>>>>>> So your claim that this "computation would never halt unless the
>>>>>> halt decider forces it to halt" is a "verified fact" is simply
>>>>>> false. It is not a fact at all.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>>>>> }
>>>>>>
>>>>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>>>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>>>>> 02 {
>>>>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>>>>> 04 HERE: goto HERE;
>>>>>> 05 else
>>>>>> 06 HALT
>>>>>> 07 }
>>>>>>
>>>>>> // Linz H with some of the ⊢* states shown
>>>>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>>>>> 09 {
>>>>>> 10 bool Halted = false;
>>>>>> 11 bool Aborted = false;
>>>>>> 12 while (!Halted && !Aborted)
>>>>>> 13 {
>>>>>> 14 Halted = DebugStep(P, I);
>>>>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>> 16 }
>>>>>> 17 return !Aborted;
>>>>>> 18 }
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I am not completely certain exactly what that execution trace would
>>>>> do.
>>>>
>>>> Well, since it's a trivial modification of your own code, tracing
>>>> shouldn't be too difficult.
>>>>
>>>> H emulates H_Hat(H_Hat), but with its abort code disabled so it
>>>> cannot abort H_Hat(H_Hat).
>>>>
>>>> The outer H_Hat calls H again to emulate the Inner H_Hat.
>>>>
>>>> The H called by H_Hat aborts the inner H_Hat.
>>>>
>>>> That H then returns control to the outer H_Hat which terminates.
>>>>
>>>> Control returns to the uppermost H which then also terminates.
>>>>
>>>> The point is that H_Hat(H_Hat) *will* terminate on its own. Your
>>>> claim that the uppermost H *had* to terminate H_Hat(H_Hat) is simply
>>>> false. If your outermost H does not terminate it, it will not go
>>>> into infinite execution; it will halt.
>>>>
>>>>> I am completely certain that unless one of the H_Hat invocations in
>>>>> the otherwise infinitely recursive call chain is aborted that
>>>>> H_Hat() continues to execute infinite recursion.
>>>>
>>>> Yes, but in your code it is the *wrong* instance of your H that is
>>>> doing the aborting. The outermost H absolutely does not *have* to
>>>> terminate its input, as the emulated H_Hat(H_Hat) *would* terminate
>>>> without being aborted by the outer H.
>>>>
>>>> And that is fundamentally what the halting problems asks: does
>>>> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
>>>> doesn't let it get that far, which means that your outermost H isn't
>>>> correctly answering the question you claim it is answering, i.e. did
>>>> I *have* to halt my input to prevent an infinite execution.
>>>>
>>>> André
>>>>
>>>
>>> When-so-ever UTM halt decider H decides that:
>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>> and
>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>> then H has made a correct not-halting decision on this input.
>>
>> It's unclear to me what you hope to achieve by repeating this mantra.
>> The point I make above is that clause (2) of your mantra is not met in
>> this case, meaning that H has not made the correct decision on this
>> input.
>>
>> André
>>
>
> Your modification to an otherwise correct halt decider was merely a
> convoluted example of the original example of simply removing line 14
line 15
> altogether and then on the basis of this breaking change claiming that
> the halt decider does not work.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2020-11-13 09:12 -0700 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <romb98$eoo$1@dont-email.me> |
| In reply to | #25215 |
On 2020-11-13 06:55, olcott wrote:
> On 11/13/2020 2:22 AM, André G. Isaak wrote:
>> On 2020-11-12 21:46, olcott wrote:
>>> On 11/12/2020 1:09 PM, André G. Isaak wrote:
>>>> On 2020-11-12 11:21, olcott wrote:
>>>>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>>>>
>>>> <snippage>
>>>>
>>>>>> The following is a modified version of your code. As I stated, the
>>>>>> only difference between this code and yours is that in this
>>>>>> version the uppermost call to H *and only the uppermost call* to H
>>>>>> has its abort code disabled.
>>>>>>
>>>>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>>>>> *must* abort its input to prevent it from running forever, but the
>>>>>> following does *not* run forever despite the fact that the
>>>>>> uppermost H cannot abort its input.
>>>>>>
>>>>>> So your claim that this "computation would never halt unless the
>>>>>> halt decider forces it to halt" is a "verified fact" is simply
>>>>>> false. It is not a fact at all.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>>>>> }
>>>>>>
>>>>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>>>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>>>>> 02 {
>>>>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>>>>> 04 HERE: goto HERE;
>>>>>> 05 else
>>>>>> 06 HALT
>>>>>> 07 }
>>>>>>
>>>>>> // Linz H with some of the ⊢* states shown
>>>>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>>>>> 09 {
>>>>>> 10 bool Halted = false;
>>>>>> 11 bool Aborted = false;
>>>>>> 12 while (!Halted && !Aborted)
>>>>>> 13 {
>>>>>> 14 Halted = DebugStep(P, I);
>>>>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>> 16 }
>>>>>> 17 return !Aborted;
>>>>>> 18 }
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I am not completely certain exactly what that execution trace would
>>>>> do.
>>>>
>>>> Well, since it's a trivial modification of your own code, tracing
>>>> shouldn't be too difficult.
>>>>
>>>> H emulates H_Hat(H_Hat), but with its abort code disabled so it
>>>> cannot abort H_Hat(H_Hat).
>>>>
>>>> The outer H_Hat calls H again to emulate the Inner H_Hat.
>>>>
>>>> The H called by H_Hat aborts the inner H_Hat.
>>>>
>>>> That H then returns control to the outer H_Hat which terminates.
>>>>
>>>> Control returns to the uppermost H which then also terminates.
>>>>
>>>> The point is that H_Hat(H_Hat) *will* terminate on its own. Your
>>>> claim that the uppermost H *had* to terminate H_Hat(H_Hat) is simply
>>>> false. If your outermost H does not terminate it, it will not go
>>>> into infinite execution; it will halt.
>>>>
>>>>> I am completely certain that unless one of the H_Hat invocations in
>>>>> the otherwise infinitely recursive call chain is aborted that
>>>>> H_Hat() continues to execute infinite recursion.
>>>>
>>>> Yes, but in your code it is the *wrong* instance of your H that is
>>>> doing the aborting. The outermost H absolutely does not *have* to
>>>> terminate its input, as the emulated H_Hat(H_Hat) *would* terminate
>>>> without being aborted by the outer H.
>>>>
>>>> And that is fundamentally what the halting problems asks: does
>>>> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
>>>> doesn't let it get that far, which means that your outermost H isn't
>>>> correctly answering the question you claim it is answering, i.e. did
>>>> I *have* to halt my input to prevent an infinite execution.
>>>>
>>>> André
>>>>
>>>
>>> When-so-ever UTM halt decider H decides that:
>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>> and
>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>> then H has made a correct not-halting decision on this input.
>>
>> It's unclear to me what you hope to achieve by repeating this mantra.
>> The point I make above is that clause (2) of your mantra is not met in
>> this case, meaning that H has not made the correct decision on this
>> input.
>>
>> André
>>
>
> Your modification to an otherwise correct halt decider was merely a
> convoluted example of the original example of simply removing line 14
> altogether and then on the basis of this breaking change claiming that
> the halt decider does not work.
In that case, you'd be able to point to a specific flaw in my argument
rather than simply repeating your mantra. My modification makes it clear
that the wrong decision is being reached. If you believe otherwise, you
need to actually address which step in my analysis is incorrect. You can't.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-11-13 10:21 -0600 |
| Subject | Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts) |
| Message-ID | <36mdnWYnfcQcLzPCnZ2dnUU7-UnNnZ2d@giganews.com> |
| In reply to | #25233 |
On 11/13/2020 10:12 AM, André G. Isaak wrote:
> On 2020-11-13 06:55, olcott wrote:
>> On 11/13/2020 2:22 AM, André G. Isaak wrote:
>>> On 2020-11-12 21:46, olcott wrote:
>>>> On 11/12/2020 1:09 PM, André G. Isaak wrote:
>>>>> On 2020-11-12 11:21, olcott wrote:
>>>>>> On 11/12/2020 11:40 AM, André G. Isaak wrote:
>>>>>
>>>>> <snippage>
>>>>>
>>>>>>> The following is a modified version of your code. As I stated,
>>>>>>> the only difference between this code and yours is that in this
>>>>>>> version the uppermost call to H *and only the uppermost call* to
>>>>>>> H has its abort code disabled.
>>>>>>>
>>>>>>> According to you, H, when called with (H_Hat, H_Hat) as its input
>>>>>>> *must* abort its input to prevent it from running forever, but
>>>>>>> the following does *not* run forever despite the fact that the
>>>>>>> uppermost H cannot abort its input.
>>>>>>>
>>>>>>> So your claim that this "computation would never halt unless the
>>>>>>> halt decider forces it to halt" is a "verified fact" is simply
>>>>>>> false. It is not a fact at all.
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> H(H_Hat, H_Hat, false); // **** ADDED PARAMETER ****
>>>>>>> }
>>>>>>>
>>>>>>> // Simplified version of Linz H_Hat DOES NOT copy itself
>>>>>>> 01 void H_Hat(u32 P) // (bottom of page 319)
>>>>>>> 02 {
>>>>>>> 03 if (H(P, P, true)) // **** ADDED PARAMETER ****
>>>>>>> 04 HERE: goto HERE;
>>>>>>> 05 else
>>>>>>> 06 HALT
>>>>>>> 07 }
>>>>>>>
>>>>>>> // Linz H with some of the ⊢* states shown
>>>>>>> 08 bool H(u32 P, u32 I, bool UseAbortCode) // ** CHANGED LINE **
>>>>>>> 09 {
>>>>>>> 10 bool Halted = false;
>>>>>>> 11 bool Aborted = false;
>>>>>>> 12 while (!Halted && !Aborted)
>>>>>>> 13 {
>>>>>>> 14 Halted = DebugStep(P, I);
>>>>>>> 14.5 if UseAbortCode // ***** ADDED LINE *****
>>>>>>> 15 Aborted = Needs_To_Be_Aborted();
>>>>>>> 16 }
>>>>>>> 17 return !Aborted;
>>>>>>> 18 }
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> I am not completely certain exactly what that execution trace
>>>>>> would do.
>>>>>
>>>>> Well, since it's a trivial modification of your own code, tracing
>>>>> shouldn't be too difficult.
>>>>>
>>>>> H emulates H_Hat(H_Hat), but with its abort code disabled so it
>>>>> cannot abort H_Hat(H_Hat).
>>>>>
>>>>> The outer H_Hat calls H again to emulate the Inner H_Hat.
>>>>>
>>>>> The H called by H_Hat aborts the inner H_Hat.
>>>>>
>>>>> That H then returns control to the outer H_Hat which terminates.
>>>>>
>>>>> Control returns to the uppermost H which then also terminates.
>>>>>
>>>>> The point is that H_Hat(H_Hat) *will* terminate on its own. Your
>>>>> claim that the uppermost H *had* to terminate H_Hat(H_Hat) is
>>>>> simply false. If your outermost H does not terminate it, it will
>>>>> not go into infinite execution; it will halt.
>>>>>
>>>>>> I am completely certain that unless one of the H_Hat invocations
>>>>>> in the otherwise infinitely recursive call chain is aborted that
>>>>>> H_Hat() continues to execute infinite recursion.
>>>>>
>>>>> Yes, but in your code it is the *wrong* instance of your H that is
>>>>> doing the aborting. The outermost H absolutely does not *have* to
>>>>> terminate its input, as the emulated H_Hat(H_Hat) *would* terminate
>>>>> without being aborted by the outer H.
>>>>>
>>>>> And that is fundamentally what the halting problems asks: does
>>>>> H_Hat(H_Hat) halt on its own? It does, except that your outermost H
>>>>> doesn't let it get that far, which means that your outermost H
>>>>> isn't correctly answering the question you claim it is answering,
>>>>> i.e. did I *have* to halt my input to prevent an infinite execution.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> When-so-ever UTM halt decider H decides that:
>>>> (1) its input (<P>,I) would never halt unless H stopped simulating it
>>>> and
>>>> (2) its input (<P>,I) would never halt unless H stopped simulating it
>>>> then H has made a correct not-halting decision on this input.
>>>
>>> It's unclear to me what you hope to achieve by repeating this mantra.
>>> The point I make above is that clause (2) of your mantra is not met
>>> in this case, meaning that H has not made the correct decision on
>>> this input.
>>>
>>> André
>>>
>>
>> Your modification to an otherwise correct halt decider was merely a
>> convoluted example of the original example of simply removing line 14
>> altogether and then on the basis of this breaking change claiming that
>> the halt decider does not work.
>
> In that case, you'd be able to point to a specific flaw in my argument
> rather than simply repeating your mantra. My modification makes it clear
> that the wrong decision is being reached. If you believe otherwise, you
> need to actually address which step in my analysis is incorrect. You can't.
>
> André
>
Your example merely made it harder to understand that a correct decision
was made. An execution trace would be the best way to show exactly how
your example is not any refutation of this:
If a UTM decider H decides that:
(1) Its input (<P>,I) would never halt unless H stopped simulating it
and
(2) Its input (<P>,I) would never halt unless H stopped simulating it
then H has made a correct decision on this input.
Since H does divide all of its inputs into {halting and not-halting} it
is a halt decider.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 1 of 2 [1] 2 Next page →
Back to top | Article view | comp.theory
csiph-web