Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #25120 > unrolled thread

Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added)

Started byolcott <NoOne@NoWhere.com>
First post2020-11-11 08:45 -0600
Last post2020-11-12 22:11 -0600
Articles 20 on this page of 37 — 6 participants

Back to article view | Back to comp.theory


Contents

  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 →


#25120 — Refuting the halting problem proofs by deciding the previously undecidable input (V5) (new material added)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-11 08:45 -0600
SubjectRefuting 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]


#25123

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2020-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]


#25124

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#25136

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-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]


#25147

Fromolcott <NoOne@NoWhere.com>
Date2020-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]


#25161

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-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]


#25163 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-11 19:20 -0600
SubjectRe: 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]


#25171 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (tautology)

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-11-12 02:08 +0000
SubjectRe: 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]


#25178 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-12 00:09 -0600
SubjectRe: 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]


#25189 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-12 08:06 -0700
SubjectRe: 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]


#25191 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-12 09:19 -0600
SubjectRe: 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]


#25199 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-12 10:40 -0700
SubjectRe: 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]


#25201 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-12 12:21 -0600
SubjectRe: 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]


#25204 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-12 12:09 -0700
SubjectRe: 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]


#25210 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-12 22:46 -0600
SubjectRe: 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]


#25212 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-13 01:22 -0700
SubjectRe: 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]


#25215 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 07:55 -0600
SubjectRe: 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]


#25216 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 07:57 -0600
SubjectRe: 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]


#25233 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

FromAndré G. Isaak <agisaak@gm.invalid>
Date2020-11-13 09:12 -0700
SubjectRe: 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]


#25236 — Re: Refuting the halting problem proofs by deciding the previously undecidable input (V5) (verified facts)

Fromolcott <NoOne@NoWhere.com>
Date2020-11-13 10:21 -0600
SubjectRe: 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