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


Groups > comp.software-eng > #2669 > unrolled thread

Solution To The Halting Problem

Started byMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
First post2021-05-02 14:15 +0100
Last post2021-05-22 15:12 -0500
Articles 20 on this page of 48 — 6 participants

Back to article view | Back to comp.software-eng


Contents

  Solution To The Halting Problem Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-02 14:15 +0100
    Re: Solution To The Halting Problem Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-02 14:03 +0000
      Re: Solution To The Halting Problem Richard Harnden <richard.nospam@gmail.com> - 2021-05-02 15:15 +0100
        Re: Solution To The Halting Problem [ Accurate review? ] olcott <NoOne@NoWhere.com> - 2021-05-02 10:21 -0500
          Re: Solution To The Halting Problem [ Accurate review? ] Richard Harnden <richard.nospam@gmail.com> - 2021-05-02 17:11 +0100
          Re: Solution To The Halting Problem [ Accurate review? ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-02 16:38 +0000
            Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ] olcott <NoOne@NoWhere.com> - 2021-05-02 12:55 -0500
              Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-02 19:14 +0100
                Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ] olcott <NoOne@NoWhere.com> - 2021-05-02 13:18 -0500
                  Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ] Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-03 22:33 +0100
                  Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ] olcott <NoOne@NoWhere.com> - 2021-05-04 10:38 -0500
              Re: Solution To The Halting Problem [ C/x86 defines computable functions ] olcott <NoOne@NoWhere.com> - 2021-05-04 13:45 -0500
                Re: Solution To The Halting Problem [ C/x86 defines computable functions ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-04 19:24 +0000
                  Re: Solution To The Halting Problem [ C/x86 defines computable functions ] olcott <NoOne@NoWhere.com> - 2021-05-04 19:41 -0500
                    Re: Solution To The Halting Problem [ C/x86 defines computable functions ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-05 00:55 +0000
                      Re: Solution To The Halting Problem [ H based on UTM ] olcott <NoOne@NoWhere.com> - 2021-05-05 12:43 -0500
                        Re: Solution To The Halting Problem [ H based on UTM ] Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-05 18:05 +0000
                          Re: Solution To The Halting Problem [ H based on UTM ](errors?) olcott <NoOne@NoWhere.com> - 2021-05-05 13:20 -0500
                        Re: Solution To The Halting Problem [ H based on UTM ](Pattern Matching) olcott <NoOne@NoWhere.com> - 2021-05-05 23:03 -0500
                          Re: New test program (Succeeds V2) olcott <NoOne@NoWhere.com> - 2021-05-07 16:13 -0500
                            Re: New test program (Succeeds V2)(Ben contradicts himself) olcott <NoOne@NoWhere.com> - 2021-05-08 11:18 -0500
      Re: Solution To The Halting Problem Bonita Montero <Bonita.Montero@gmail.com> - 2021-05-02 16:59 +0200
      Re: Solution To The Halting Problem [ Accurate Review? ] olcott <NoOne@NoWhere.com> - 2021-05-02 10:30 -0500
    Re: Solution To The Halting Problem Real Troll <real.troll@trolls.com> - 2021-05-02 16:20 +0100
    Re: Solution To The Halting Problem [ Find an Error? ] olcott <NoOne@NoWhere.com> - 2021-05-07 18:38 -0500
    Re: New test program (Succeeds V2)[ Mike is a good technical reviewer ] olcott <NoOne@NoWhere.com> - 2021-05-10 14:36 -0500
    Re: New test program (Succeeds V2)[ counter-example in C ? ] olcott <NoOne@NoWhere.com> - 2021-05-12 15:45 -0500
      Re: New test program (Succeeds V2)[ entirely different computation ] olcott <NoOne@NoWhere.com> - 2021-05-14 11:12 -0500
    Refuting the halting theorem( three irrefutable truisms lead to one conclusion )(repeat until mutual agreement) olcott <NoOne@NoWhere.com> - 2021-05-19 22:15 -0500
    Refuting the halting theorem( three irrefutable truisms lead to one conclusion )(paraphrase (1a)(1b)) olcott <NoOne@NoWhere.com> - 2021-05-19 22:38 -0500
      Re: Refuting the halting theorem( key halt deciding principle )( helpful review ) olcott <NoOne@NoWhere.com> - 2021-05-20 22:25 -0500
      Re: Refuting the halting theorem( key halt deciding principle )( helpful review ) olcott <NoOne@NoWhere.com> - 2021-05-20 22:38 -0500
    Re: Halting theorem refutation ( halt deciding principle ) olcott <NoOne@NoWhere.com> - 2021-05-20 17:08 -0500
    Re: Re: Halting theorem refutation (V3) olcott <NoOne@NoWhere.com> - 2021-05-20 18:40 -0500
    Re: Re: Eliminating the pathological self-reference error of the halting theorem (V6) olcott <NoOne@NoWhere.com> - 2021-05-21 11:44 -0500
    Re: Refutation of the halting theorem on the basis of its pathological self-reference error (V7) olcott <NoOne@NoWhere.com> - 2021-05-21 18:10 -0500
    Re: Eliminating the pathological self-reference error of the halting theorem (V7) olcott <NoOne@NoWhere.com> - 2021-05-22 10:30 -0500
      Re: Eliminating the pathological self-reference error of the halting theorem (V9) olcott <NoOne@NoWhere.com> - 2021-05-23 13:52 -0500
      Diagonalization in the halting theorem is very easy olcott <NoOne@NoWhere.com> - 2021-05-25 19:44 -0500
      Diagonalization proof has been addressed (proxy input) olcott <NoOne@NoWhere.com> - 2021-05-27 22:43 -0500
    Re: Eliminating the pathological self-reference error of the halting theorem (V7.5) olcott <NoOne@NoWhere.com> - 2021-05-22 21:01 -0500
      Re: Eliminating the pathological self-reference error of the halting theorem (V10)(Proxy inputs) olcott <NoOne@NoWhere.com> - 2021-05-24 21:01 -0500
        Re: Eliminating the pathological self-reference error of the halting theorem (V11)(Proxy inputs) olcott <NoOne@NoWhere.com> - 2021-05-25 12:27 -0500
        Re: Eliminating the pathological self-reference error of the halting theorem (V10)(Proxy inputs) olcott <NoOne@NoWhere.com> - 2021-05-26 19:18 -0500
        Malcolm agrees that Halts((u32)H_Hat, (u32)H_Hat); is decidable olcott <NoOne@NoWhere.com> - 2021-05-27 01:42 -0500
        Re: Eliminating the pathological self-reference error of the halting theorem (V10)(Proxy inputs) olcott <NoOne@NoWhere.com> - 2021-05-26 13:38 -0500
        Re: Eliminating the pathological self-reference error of the halting theorem (V10)(Proxy inputs) olcott <NoOne@NoWhere.com> - 2021-05-27 10:47 -0500
    Re: Eliminating the pathological self-reference error of the halting theorem (V8)(Mike does not understand) olcott <NoOne@NoWhere.com> - 2021-05-22 15:12 -0500

Page 1 of 3  [1] 2 3  Next page →


#2669 — Solution To The Halting Problem

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2021-05-02 14:15 +0100
SubjectSolution To The Halting Problem
Message-ID<eCxjI.450528$AWcd.220764@fx42.ams4>
Does anyone know the solution to the problem of halting olcott's Usenet posts?

/Flibble

-- 
😎

[toc] | [next] | [standalone]


#2670

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-02 14:03 +0000
Message-ID<20210502070155.115@kylheku.com>
In reply to#2669
On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
> Does anyone know the solution to the problem of halting olcott's Usenet posts?

Everyone halts. For this case, specifically, there is an unproven
and empirically untested hypothesis about an early halt that occurs
if everyone stops responding.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#2671

FromRichard Harnden <richard.nospam@gmail.com>
Date2021-05-02 15:15 +0100
Message-ID<s6mc6o$n39$1@dont-email.me>
In reply to#2670
On 02/05/2021 15:03, Kaz Kylheku wrote:
> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>> Does anyone know the solution to the problem of halting olcott's Usenet posts?
> 
> Everyone halts. For this case, specifically, there is an unproven
> and empirically untested hypothesis about an early halt that occurs
> if everyone stops responding.
> 

We can ask him to stop.  We can't prove that he will.

[toc] | [prev] | [next] | [standalone]


#2673 — Re: Solution To The Halting Problem [ Accurate review? ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-02 10:21 -0500
SubjectRe: Solution To The Halting Problem [ Accurate review? ]
Message-ID<c_mdnSsTsd_VXhP9nZ2dnUU7-InNnZ2d@giganews.com>
In reply to#2671
On 5/2/2021 9:15 AM, Richard Harnden wrote:
> On 02/05/2021 15:03, Kaz Kylheku wrote:
>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>> Does anyone know the solution to the problem of halting olcott's 
>>> Usenet posts?
>>
>> Everyone halts. For this case, specifically, there is an unproven
>> and empirically untested hypothesis about an early halt that occurs
>> if everyone stops responding.
>>
> 
> We can ask him to stop.  We can't prove that he will.

The bigger question is when are my reviewers going to provide an 
accurate review?

It is a fact that this infinite recursion detection criteria is correct:

If the execution trace of function Y() shows:
function X() is called twice in sequence from the same machine address 
of Y()
with the same parameters to X()
with no conditional branch or indexed jump instructions in Y()
with no function call returns from X()
then the function call from Y() to X() is infinitely recursive.

It is a fact that this criteria correctly  decides all calls from 
H_Hat() to Halts() are infinitely recursive:

If the execution trace of H_Hat() by function Halts() shows:
(1) Function Halts() is called twice in sequence from the same machine 
address of H_Hat().
(2) With the same parameters to Halts().
(3) With no conditional branch or indexed jump instructions in H_Hat().
(4) With no function call returns from Halts().
then the function call from H_Hat() to Halts() is infinitely recursive.

void H_Hat(u32 P)
{
   u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Would_Halt = ", Input_Would_Halt);
}

All of the details including a fresh execution trace are provided here:

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf 




-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2676 — Re: Solution To The Halting Problem [ Accurate review? ]

FromRichard Harnden <richard.nospam@gmail.com>
Date2021-05-02 17:11 +0100
SubjectRe: Solution To The Halting Problem [ Accurate review? ]
Message-ID<s6mj0b$a22$1@dont-email.me>
In reply to#2673
On 02/05/2021 16:21, olcott wrote:
> 
> void H_Hat(u32 P)
> {
>   u32 Input_Halts = Halts(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
> 
> int main()
> {
>   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
>   Output("Input_Would_Halt = ", Input_Would_Halt);
> }
> 

You keep posting this or something very similar.

That doesn't make it correct. It doesn't matter how many times you 
repeat it.



[toc] | [prev] | [next] | [standalone]


#2677 — Re: Solution To The Halting Problem [ Accurate review? ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-02 16:38 +0000
SubjectRe: Solution To The Halting Problem [ Accurate review? ]
Message-ID<20210502092107.409@kylheku.com>
In reply to#2673
On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
> On 5/2/2021 9:15 AM, Richard Harnden wrote:
>> On 02/05/2021 15:03, Kaz Kylheku wrote:
>>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>>> Does anyone know the solution to the problem of halting olcott's 
>>>> Usenet posts?
>>>
>>> Everyone halts. For this case, specifically, there is an unproven
>>> and empirically untested hypothesis about an early halt that occurs
>>> if everyone stops responding.
>>>
>> 
>> We can ask him to stop.  We can't prove that he will.
>
> The bigger question is when are my reviewers going to provide an 
> accurate review?
>
> It is a fact that this infinite recursion detection criteria is correct:
>
> If the execution trace of function Y() shows:
> function X() is called twice in sequence from the same machine address 
> of Y()
> with the same parameters to X()
> with no conditional branch or indexed jump instructions in Y()
> with no function call returns from X()
> then the function call from Y() to X() is infinitely recursive.

This is only "right" from the perspective of an objective observation
that is not involved in the computation, and has no effect on it.

The function X() cannot itself make this observation. X has access to
only its parameters, and its parameters do not carry any information
indicating to X that it has been called twice from the same address
or any such thing. How can they; the parameters are *always the same*.
Therefore they cannot distinguish the first call from the second call
from the third call ...

A function having adcess to past execution traces is an imperative
procedure, which is completely invalid.

It may be possible to rigorously define the halting criteria using
imperative procedures, but it has to be in a completely different way.
(After all, Turing's machine is imperative: it mutates a tape.) You
cannot simply use a definition built around functions and just
substitute procedures into it.

I believe this to be an accurate review of your definition. It points to
flaws in the definition. You have done nothing to correct the definition
to fix the flaws; you simply keep re-asserting the same definition as
correct.

[toc] | [prev] | [next] | [standalone]


#2679 — Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-02 12:55 -0500
SubjectRe: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]
Message-ID<1O2dncbvMtfmehP9nZ2dnUU7-VvNnZ2d@giganews.com>
In reply to#2677
On 5/2/2021 12:50 PM, olcott wrote:
> On 5/2/2021 12:39 PM, Kaz Kylheku wrote:
>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/2/2021 11:38 AM, Kaz Kylheku wrote:
>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/2/2021 9:15 AM, Richard Harnden wrote:
>>>>>> On 02/05/2021 15:03, Kaz Kylheku wrote:
>>>>>>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>>>>>>> Does anyone know the solution to the problem of halting olcott's
>>>>>>>> Usenet posts?
>>>>>>>
>>>>>>> Everyone halts. For this case, specifically, there is an unproven
>>>>>>> and empirically untested hypothesis about an early halt that occurs
>>>>>>> if everyone stops responding.
>>>>>>>
>>>>>>
>>>>>> We can ask him to stop.  We can't prove that he will.
>>>>>
>>>>> The bigger question is when are my reviewers going to provide an
>>>>> accurate review?
>>>>>
>>>>> It is a fact that this infinite recursion detection criteria is 
>>>>> correct:
>>>>>
>>>>> If the execution trace of function Y() shows:
>>>>> function X() is called twice in sequence from the same machine address
>>>>> of Y()
>>>>> with the same parameters to X()
>>>>> with no conditional branch or indexed jump instructions in Y()
>>>>> with no function call returns from X()
>>>>> then the function call from Y() to X() is infinitely recursive.
>>>>
>>>> This is only "right" from the perspective of an objective observation
>>>> that is not involved in the computation, and has no effect on it.
>>>>
>>>> The function X() cannot itself make this observation. X has access to
>>>> only its parameters, and its parameters do not carry any information
>>>> indicating to X that it has been called twice from the same address
>>>> or any such thing. How can they; the parameters are *always the same*.
>>>> Therefore they cannot distinguish the first call from the second call
>>>> from the third call ...
>>>>
>>>> A function having adcess to past execution traces is an imperative
>>>> procedure, which is completely invalid.
>>>
>>> This is ridiculous, it is just like saying that I must be wrong on the
>>> basis that you really believe that I am wrong.
>>>
>>> You have to concretely prove these dogmatic statements. When you attempt
>>
> 
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf 
> 
> 
> 
>> 1. You're trying to refute a proof which has a similar structure to the
>>     X and Y arrangement above.
>>
>> 2. In that proof, the entities corresponding to X and Y are functions,
>>     and not imperative procedures. They have no access to some global,
>>     mutating state holding execution traces; such a situation would
>>     violate the conditions of the proof.

So you are saying that an adapted UTM that recognizes the infinite 
recursion pattern of its input, stops simulating its input on this 
basis, and decides not halting on this input,

IS SIMPLY NOT ALLOWED ?


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2680 — Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2021-05-02 19:14 +0100
SubjectRe: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]
Message-ID<XZBjI.238624$ON31.117065@fx23.ams4>
In reply to#2679
On 02/05/2021 18:55, olcott wrote:
> On 5/2/2021 12:50 PM, olcott wrote:
>> On 5/2/2021 12:39 PM, Kaz Kylheku wrote:
>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/2/2021 11:38 AM, Kaz Kylheku wrote:
>>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/2/2021 9:15 AM, Richard Harnden wrote:
>>>>>>> On 02/05/2021 15:03, Kaz Kylheku wrote:
>>>>>>>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>>>>>>>> Does anyone know the solution to the problem of halting olcott's
>>>>>>>>> Usenet posts?
>>>>>>>>
>>>>>>>> Everyone halts. For this case, specifically, there is an unproven
>>>>>>>> and empirically untested hypothesis about an early halt that occurs
>>>>>>>> if everyone stops responding.
>>>>>>>>
>>>>>>>
>>>>>>> We can ask him to stop.  We can't prove that he will.
>>>>>>
>>>>>> The bigger question is when are my reviewers going to provide an
>>>>>> accurate review?
>>>>>>
>>>>>> It is a fact that this infinite recursion detection criteria is correct:
>>>>>>
>>>>>> If the execution trace of function Y() shows:
>>>>>> function X() is called twice in sequence from the same machine address
>>>>>> of Y()
>>>>>> with the same parameters to X()
>>>>>> with no conditional branch or indexed jump instructions in Y()
>>>>>> with no function call returns from X()
>>>>>> then the function call from Y() to X() is infinitely recursive.
>>>>>
>>>>> This is only "right" from the perspective of an objective observation
>>>>> that is not involved in the computation, and has no effect on it.
>>>>>
>>>>> The function X() cannot itself make this observation. X has access to
>>>>> only its parameters, and its parameters do not carry any information
>>>>> indicating to X that it has been called twice from the same address
>>>>> or any such thing. How can they; the parameters are *always the same*.
>>>>> Therefore they cannot distinguish the first call from the second call
>>>>> from the third call ...
>>>>>
>>>>> A function having adcess to past execution traces is an imperative
>>>>> procedure, which is completely invalid.
>>>>
>>>> This is ridiculous, it is just like saying that I must be wrong on the
>>>> basis that you really believe that I am wrong.
>>>>
>>>> You have to concretely prove these dogmatic statements. When you attempt
>>>
>>
>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf 
>>
>>
>>
>>> 1. You're trying to refute a proof which has a similar structure to the
>>>     X and Y arrangement above.
>>>
>>> 2. In that proof, the entities corresponding to X and Y are functions,
>>>     and not imperative procedures. They have no access to some global,
>>>     mutating state holding execution traces; such a situation would
>>>     violate the conditions of the proof.
> 
> So you are saying that an adapted UTM that recognizes the infinite recursion 
> pattern of its input, stops simulating its input on this basis, and decides not 
> halting on this input,
> 
> IS SIMPLY NOT ALLOWED ?

Your solution cannot recognize infinite recursion because your solution 
disregards branching logic and state that branching logic is predicated on.

In general an algorithm contains LOGIC acting on STATE and the longer you 
continue to ignore this fact the more time you will waste (in addition to 
wasting the time of people reading and replying to your Usenet posts). I pity 
you and your obtuseness.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#2681 — Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-02 13:18 -0500
SubjectRe: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]
Message-ID<JfudnXsrH95scRP9nZ2dnUU7-I2dnZ2d@giganews.com>
In reply to#2680
On 5/2/2021 1:14 PM, Mr Flibble wrote:
> On 02/05/2021 18:55, olcott wrote:
>> On 5/2/2021 12:50 PM, olcott wrote:
>>> On 5/2/2021 12:39 PM, Kaz Kylheku wrote:
>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/2/2021 11:38 AM, Kaz Kylheku wrote:
>>>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 5/2/2021 9:15 AM, Richard Harnden wrote:
>>>>>>>> On 02/05/2021 15:03, Kaz Kylheku wrote:
>>>>>>>>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>>>>>>>>> Does anyone know the solution to the problem of halting olcott's
>>>>>>>>>> Usenet posts?
>>>>>>>>>
>>>>>>>>> Everyone halts. For this case, specifically, there is an unproven
>>>>>>>>> and empirically untested hypothesis about an early halt that 
>>>>>>>>> occurs
>>>>>>>>> if everyone stops responding.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We can ask him to stop.  We can't prove that he will.
>>>>>>>
>>>>>>> The bigger question is when are my reviewers going to provide an
>>>>>>> accurate review?
>>>>>>>
>>>>>>> It is a fact that this infinite recursion detection criteria is 
>>>>>>> correct:
>>>>>>>
>>>>>>> If the execution trace of function Y() shows:
>>>>>>> function X() is called twice in sequence from the same machine 
>>>>>>> address
>>>>>>> of Y()
>>>>>>> with the same parameters to X()
>>>>>>> with no conditional branch or indexed jump instructions in Y()
>>>>>>> with no function call returns from X()
>>>>>>> then the function call from Y() to X() is infinitely recursive.
>>>>>>
>>>>>> This is only "right" from the perspective of an objective observation
>>>>>> that is not involved in the computation, and has no effect on it.
>>>>>>
>>>>>> The function X() cannot itself make this observation. X has access to
>>>>>> only its parameters, and its parameters do not carry any information
>>>>>> indicating to X that it has been called twice from the same address
>>>>>> or any such thing. How can they; the parameters are *always the 
>>>>>> same*.
>>>>>> Therefore they cannot distinguish the first call from the second call
>>>>>> from the third call ...
>>>>>>
>>>>>> A function having adcess to past execution traces is an imperative
>>>>>> procedure, which is completely invalid.
>>>>>
>>>>> This is ridiculous, it is just like saying that I must be wrong on the
>>>>> basis that you really believe that I am wrong.
>>>>>
>>>>> You have to concretely prove these dogmatic statements. When you 
>>>>> attempt
>>>>
>>>
>>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf 
>>>
>>>
>>>
>>>> 1. You're trying to refute a proof which has a similar structure to the
>>>>     X and Y arrangement above.
>>>>
>>>> 2. In that proof, the entities corresponding to X and Y are functions,
>>>>     and not imperative procedures. They have no access to some global,
>>>>     mutating state holding execution traces; such a situation would
>>>>     violate the conditions of the proof.
>>
>> So you are saying that an adapted UTM that recognizes the infinite 
>> recursion pattern of its input, stops simulating its input on this 
>> basis, and decides not halting on this input,
>>
>> IS SIMPLY NOT ALLOWED ?
> 
> Your solution cannot recognize infinite recursion because your solution 
> disregards branching logic and state that branching logic is predicated on.
> 
This is provably false:

It is a fact that this infinite recursion detection criteria is correct:
If the execution trace of function Y() shows:
function X() is called twice in sequence from the same machine address 
of Y()
with the same parameters to X()
with no conditional branch or indexed jump instructions in Y()
with no function call returns from X()
then the function call from Y() to X() is infinitely recursive.


If the execution trace of H_Hat() by function Halts() shows:
(1) Function Halts() is called twice in sequence from the same machine 
address of H_Hat().
(2) With the same parameters to Halts().
(3) With no conditional branch or indexed jump instructions in H_Hat().
(4) With no function call returns from Halts().
then the function call from H_Hat() to Halts() is infinitely recursive.


> In general an algorithm contains LOGIC acting on STATE and the longer 
> you continue to ignore this fact the more time you will waste (in 
> addition to wasting the time of people reading and replying to your 
> Usenet posts). I pity you and your obtuseness.
> 
> /Flibble
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2683 — Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2021-05-03 22:33 +0100
SubjectRe: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]
Message-ID<T_ZjI.1074804$8KY1.928612@fx12.ams4>
In reply to#2681
On 02/05/2021 19:18, olcott wrote:
> On 5/2/2021 1:14 PM, Mr Flibble wrote:
>> On 02/05/2021 18:55, olcott wrote:
>>> On 5/2/2021 12:50 PM, olcott wrote:
>>>> On 5/2/2021 12:39 PM, Kaz Kylheku wrote:
>>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/2/2021 11:38 AM, Kaz Kylheku wrote:
>>>>>>> On 2021-05-02, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 5/2/2021 9:15 AM, Richard Harnden wrote:
>>>>>>>>> On 02/05/2021 15:03, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-05-02, Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> wrote:
>>>>>>>>>>> Does anyone know the solution to the problem of halting olcott's
>>>>>>>>>>> Usenet posts?
>>>>>>>>>>
>>>>>>>>>> Everyone halts. For this case, specifically, there is an unproven
>>>>>>>>>> and empirically untested hypothesis about an early halt that occurs
>>>>>>>>>> if everyone stops responding.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can ask him to stop.  We can't prove that he will.
>>>>>>>>
>>>>>>>> The bigger question is when are my reviewers going to provide an
>>>>>>>> accurate review?
>>>>>>>>
>>>>>>>> It is a fact that this infinite recursion detection criteria is correct:
>>>>>>>>
>>>>>>>> If the execution trace of function Y() shows:
>>>>>>>> function X() is called twice in sequence from the same machine address
>>>>>>>> of Y()
>>>>>>>> with the same parameters to X()
>>>>>>>> with no conditional branch or indexed jump instructions in Y()
>>>>>>>> with no function call returns from X()
>>>>>>>> then the function call from Y() to X() is infinitely recursive.
>>>>>>>
>>>>>>> This is only "right" from the perspective of an objective observation
>>>>>>> that is not involved in the computation, and has no effect on it.
>>>>>>>
>>>>>>> The function X() cannot itself make this observation. X has access to
>>>>>>> only its parameters, and its parameters do not carry any information
>>>>>>> indicating to X that it has been called twice from the same address
>>>>>>> or any such thing. How can they; the parameters are *always the same*.
>>>>>>> Therefore they cannot distinguish the first call from the second call
>>>>>>> from the third call ...
>>>>>>>
>>>>>>> A function having adcess to past execution traces is an imperative
>>>>>>> procedure, which is completely invalid.
>>>>>>
>>>>>> This is ridiculous, it is just like saying that I must be wrong on the
>>>>>> basis that you really believe that I am wrong.
>>>>>>
>>>>>> You have to concretely prove these dogmatic statements. When you attempt
>>>>>
>>>>
>>>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf 
>>>>
>>>>
>>>>
>>>>> 1. You're trying to refute a proof which has a similar structure to the
>>>>>     X and Y arrangement above.
>>>>>
>>>>> 2. In that proof, the entities corresponding to X and Y are functions,
>>>>>     and not imperative procedures. They have no access to some global,
>>>>>     mutating state holding execution traces; such a situation would
>>>>>     violate the conditions of the proof.
>>>
>>> So you are saying that an adapted UTM that recognizes the infinite recursion 
>>> pattern of its input, stops simulating its input on this basis, and decides 
>>> not halting on this input,
>>>
>>> IS SIMPLY NOT ALLOWED ?
>>
>> Your solution cannot recognize infinite recursion because your solution 
>> disregards branching logic and state that branching logic is predicated on.
>>
> This is provably false:
> 
> It is a fact that this infinite recursion detection criteria is correct:
> If the execution trace of function Y() shows:
> function X() is called twice in sequence from the same machine address of Y()
> with the same parameters to X()
> with no conditional branch or indexed jump instructions in Y()
> with no function call returns from X()
> then the function call from Y() to X() is infinitely recursive.
> 
> 
> If the execution trace of H_Hat() by function Halts() shows:
> (1) Function Halts() is called twice in sequence from the same machine address 
> of H_Hat().
> (2) With the same parameters to Halts().
> (3) With no conditional branch or indexed jump instructions in H_Hat().
> (4) With no function call returns from Halts().
> then the function call from H_Hat() to Halts() is infinitely recursive.

Provably false? You just stated twice that your "solution" only works if there 
are no conditional branch instructions as, like I asserted, you are disregarding 
a cornerstone of algorithms: branching logic and the state that logic is 
predicated on.  You've go nothing, mate.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#2685 — Re: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 10:38 -0500
SubjectRe: Solution To The Halting Problem [ SIMPLY NOT ALLOWED ? ]
Message-ID<DNWdneGLgenb9wz9nZ2dnUU7-UfNnZ2d@giganews.com>
In reply to#2681
On 5/4/2021 10:28 AM, Richard Damon wrote:
> On 5/4/21 10:36 AM, olcott wrote:
>> On 5/3/2021 12:29 PM, Kaz Kylheku wrote:
>>> On 2021-05-03, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/3/2021 10:05 AM, Kaz Kylheku wrote:
>>>>> On 2021-05-03, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/3/2021 9:29 AM, Richard Damon wrote:
>>>>>>> But you SHOULD be looking at it. The TRUE answer to the Halting
>>>>>>> Behavior
>>>>>>> of H_Hat is what it does when it is run. Any 'logic' that gets a
>>>>>>> different answer than this is by definition WRONG.
>>>>>>
>>>>>> Since we have the software engineering principle that embedded code
>>>>>> that
>>>>>> is removed and placed in a called function is computationally
>>>>>> equivalent
>>>>>> to the original compution your persistent insistence on embedding this
>>>>>> code seems to ignore basic software engineering principles and is
>>>>>> utterly invalidated on this basis.
>>>>>
>>>>> If the embedded code is imperative code that references mutating
>>>>> external, neither the original procedure nor the refactored one
>>>>> that puts the code into a subroutine, are functions.
>>>>>
>>>>
>>>> The whole point only focuses on whether or not embedded code is
>>>> computationally equivalent to placing this same code in a called
>>>> function.
>>>
>>> Although we can refactor an imperative subroutine so that it performs
>>> the same calculation under the same conditions, that doesn't help you.
>>>
>>> Though the refactored subroutine and the original are equivalent,
>>> they are not computations *of their procedure arguments* if they refer
>>> to mutating global variables.
>>>
>>> A computation is a deterministic sequence of calculation steps beginning
>>> with a clearly defined input.
>>>
>>
>> In the case where a UTM X simulates its input this whole simulation
>> process is a pure function of this input no matter how many nested
>> simulations may be involved. All of these nested simulations are merely
>> data being processed by UTM X.
>>
>>> In the proof that you are trying to refute, Halts(P, I) and other
>>> function calls are calculations based on only those inputs that appear
>>> in the function call parentheses.
>>>
>>> In the appartus you have built, this is not the case.
>>>
>>> That's one of the ways in which it doesn't meet the conditions of the
>>> proof.
>>>
>>>> It looks like you are disagreeing with this basic software engineering
>>>> principle.
>>>
>>> Everyone I've met who can be called a software engineer knows what a
>>> function is, and how that is different from a subroutine.
>>>
>>
>> Not in C, C does not have any subroutines. When I refer to a C function
>> as a function this is correct. Also as I carefully elaborated by three
>> computer science textbook quotes a computable function might have no
>> input and produce no output. The only actual requirement of a computable
>> function is that it halts.
> 
> Depends in which set of definition you use. Many Computer Scientist will
> say that MOST C 'functions' are in fact subroutine but just mislabeled
> by the langauge.
> 
> The other actual requirement (based indirectly on being able to be
> computed by a Turing Machine) is that the output must be uniquely
> determined by the input, 

Although this seems to make perfect sense none of the textbooks mention 
that.

> as in for any given input, the output will
> always be the same. Now, if the only output is whether it halts or not,
> that is its output, and if it doesn't have an input, then it must always
> generate the exact same output (even if only halting/non-halting).
> 

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
}

No matter how many nested simulations are specified by the above 
invocation all of these nested simulations are only data being processed 
by the one actual invocation, thus all of this is a pure function of 
this invocation.

>>
>> Although it is reasonable to believe that a computable function must
>> produce the same output for the same input none of the computer science
>> textbooks mentioned this requirement.
>>
> 
> I suspect because they all define it in terms of being computable by a
> Turing Machine, and in that case this requirement is FORCED by being a
> Turing Machine.
> 
>>> In a comptuer program, both functions and subroutines can be altered
>>> by code transformations which preserve their behavior.
>>>
>>> This doesn't help you in any way. Why are you even writing about it.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2687 — Re: Solution To The Halting Problem [ C/x86 defines computable functions ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 13:45 -0500
SubjectRe: Solution To The Halting Problem [ C/x86 defines computable functions ]
Message-ID<psudna66etagCwz9nZ2dnUU7-QfNnZ2d@giganews.com>
In reply to#2679
On 5/4/2021 12:06 PM, Kaz Kylheku wrote:
> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>> On 5/3/2021 6:27 PM, Ben Bacarisse wrote:
>>> Did you have a question about what I wrote?  You seem to be having
>>> trouble understanding it.
>>>
>>
>> The notion of data passed to a function in the x86 architecture has zero
> 
> There is no "function" in x86. Some assemblers for x86 in fact have
> pseudo-ops for delimiting a procedure using syntax like "PROC FAR" and
> "ENDP".
> 

Computable Functions
A Turing machine computes a function by starting with the input to the 
function on the tape and halting with the output of the function on the 
tape.  (Sipser:1997:190)

Definition 5.12
A function f: Σ* → Σ* is a computable function if some Turing machine M, 
on every input w, halts with just f(w) on its tape.  (Sipser:1997:190)

A partial function σ: Σ* → Σ* is said to be a computable function if 
σ(x) = M(x) for some Turing machine M. (Kozen:1997:347)

Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: 
PWS Publishing Company

Kozen, Dexter 1997. Automata and Computability. New York: Springer-Verlag.

When we unify on the Sipser and Kozen definitions of "computable 
function" we have the mapping from one possibly empty finite string to 
another possibly empty finite string.

It seems that we can define this in terms of a generic model of 
computation as a machine that computes the mapping from one possibly 
empty finite string input to another possibly empty finite string output 
and and then halts.

A C function that returns a 0 or 1 value on the basis of an input finite 
string pair would meet the above definition of computable function. When 
this C function is mapped to its corresponding x86 code the x86 function 
finds its input on the stack and returns its value in the EAX register.

>> vagueness. It is always a case of a sequence of "push" operations
>> preceding the "call" operation.
> 
> That is false. x86 subroutines can access global variables.
> 
> Moreover, the push instructions can pass pointers. The same pointer
> value 0xBF30D9A0 can point to completely different objects at different
> times; therefore that value *per se* does not completely specify the input.
>>


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2688 — Re: Solution To The Halting Problem [ C/x86 defines computable functions ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-04 19:24 +0000
SubjectRe: Solution To The Halting Problem [ C/x86 defines computable functions ]
Message-ID<20210504121725.713@kylheku.com>
In reply to#2687
["Followup-To:" header set to comp.theory.]
On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
> On 5/4/2021 12:06 PM, Kaz Kylheku wrote:
>> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/3/2021 6:27 PM, Ben Bacarisse wrote:
>>>> Did you have a question about what I wrote?  You seem to be having
>>>> trouble understanding it.
>>>>
>>>
>>> The notion of data passed to a function in the x86 architecture has zero
>> 
>> There is no "function" in x86. Some assemblers for x86 in fact have
>> pseudo-ops for delimiting a procedure using syntax like "PROC FAR" and
>> "ENDP".
>> 
>
> Computable Functions
> A Turing machine computes a function by starting with the input to the 
> function on the tape and halting with the output of the function on the 
> tape.  (Sipser:1997:190)

And nothing but the tape, so help you god.

Each call Halts(P, P) is a new Turing machine, where the tape contents
depend only on Halts and P, and not any global execution traces gathered
by a larger surrouding machine.

> When we unify on the Sipser and Kozen definitions of "computable 
> function" we have the mapping from one possibly empty finite string to 
> another possibly empty finite string.

Sure, and when Halts is invoked in you apparatus with apparently the
same formal arguments, it does not represent the same mapping each time,
as required.

The tape is different each time. Since the arguments are not, and
the function is the same, it means that the tape contains something
not coming from the arguments.

That arrangement cannot refute a proof in which it is critically
important that the corresponding computations are one and the same.

> It seems that we can define this in terms of a generic model of 

Well, things are not as they seem. If you were confident, you wouldn't
use weasel words like "seem", would you.

> computation as a machine that computes the mapping from one possibly 
> empty finite string input to another possibly empty finite string output 
> and and then halts.
>
> A C function that returns a 0 or 1 value on the basis of an input finite 
> string pair would meet the above definition of computable function.

It could, but not necessarily so. To write a C function that behaves
like function, in particular a function of the arguments given to its
formal parameters, we have to follow certain coding rules.

Your apparatus does not follow those rules.

(By your own admission, Halts is not even an ordinary C function
in the first place, but a special operator of the "x86 UTM".)

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

[toc] | [prev] | [next] | [standalone]


#2689 — Re: Solution To The Halting Problem [ C/x86 defines computable functions ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-04 19:41 -0500
SubjectRe: Solution To The Halting Problem [ C/x86 defines computable functions ]
Message-ID<JOKdnYcamOgidAz9nZ2dnUU7-LXNnZ2d@giganews.com>
In reply to#2688
On 5/4/2021 2:24 PM, Kaz Kylheku wrote:
> ["Followup-To:" header set to comp.theory.]
> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>> On 5/4/2021 12:06 PM, Kaz Kylheku wrote:
>>> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/3/2021 6:27 PM, Ben Bacarisse wrote:
>>>>> Did you have a question about what I wrote?  You seem to be having
>>>>> trouble understanding it.
>>>>>
>>>>
>>>> The notion of data passed to a function in the x86 architecture has zero
>>>
>>> There is no "function" in x86. Some assemblers for x86 in fact have
>>> pseudo-ops for delimiting a procedure using syntax like "PROC FAR" and
>>> "ENDP".
>>>
>>
>> Computable Functions
>> A Turing machine computes a function by starting with the input to the
>> function on the tape and halting with the output of the function on the
>> tape.  (Sipser:1997:190)
> 
> And nothing but the tape, so help you god.
> 
> Each call Halts(P, P) is a new Turing machine, where the tape contents
> depend only on Halts and P, and not any global execution traces gathered
> by a larger surrouding machine.
> 

int Halts(u32 P, u32 I)
{
   Simulate(P,I) until decided not halts or halts.
   if decided not halts return 0.
   else return 1.
}

>> When we unify on the Sipser and Kozen definitions of "computable
>> function" we have the mapping from one possibly empty finite string to
>> another possibly empty finite string.
> 
> Sure, and when Halts is invoked in you apparatus with apparently the
> same formal arguments, it does not represent the same mapping each time,
> as required.
> 
> The tape is different each time. Since the arguments are not, and
> the function is the same, it means that the tape contains something
> not coming from the arguments.
> 
> That arrangement cannot refute a proof in which it is critically
> important that the corresponding computations are one and the same.
> 
>> It seems that we can define this in terms of a generic model of
> 
> Well, things are not as they seem. If you were confident, you wouldn't
> use weasel words like "seem", would you.
> 
>> computation as a machine that computes the mapping from one possibly
>> empty finite string input to another possibly empty finite string output
>> and and then halts.
>>
>> A C function that returns a 0 or 1 value on the basis of an input finite
>> string pair would meet the above definition of computable function.
> 
> It could, but not necessarily so. To write a C function that behaves
> like function, in particular a function of the arguments given to its
> formal parameters, we have to follow certain coding rules.
> 
> Your apparatus does not follow those rules.
> 
> (By your own admission, Halts is not even an ordinary C function
> in the first place, but a special operator of the "x86 UTM".)
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2690 — Re: Solution To The Halting Problem [ C/x86 defines computable functions ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-05 00:55 +0000
SubjectRe: Solution To The Halting Problem [ C/x86 defines computable functions ]
Message-ID<20210504174836.394@kylheku.com>
In reply to#2689
["Followup-To:" header set to comp.theory.]
On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
> On 5/4/2021 2:24 PM, Kaz Kylheku wrote:
>> ["Followup-To:" header set to comp.theory.]
>> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/4/2021 12:06 PM, Kaz Kylheku wrote:
>>>> On 2021-05-04, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/3/2021 6:27 PM, Ben Bacarisse wrote:
>>>>>> Did you have a question about what I wrote?  You seem to be having
>>>>>> trouble understanding it.
>>>>>>
>>>>>
>>>>> The notion of data passed to a function in the x86 architecture has zero
>>>>
>>>> There is no "function" in x86. Some assemblers for x86 in fact have
>>>> pseudo-ops for delimiting a procedure using syntax like "PROC FAR" and
>>>> "ENDP".
>>>>
>>>
>>> Computable Functions
>>> A Turing machine computes a function by starting with the input to the
>>> function on the tape and halting with the output of the function on the
>>> tape.  (Sipser:1997:190)
>> 
>> And nothing but the tape, so help you god.
>> 
>> Each call Halts(P, P) is a new Turing machine, where the tape contents
>> depend only on Halts and P, and not any global execution traces gathered
>> by a larger surrouding machine.
>> 
>
> int Halts(u32 P, u32 I)
> {
>    Simulate(P,I) until decided not halts or halts.
>    if decided not halts return 0.
>    else return 1.
> }

All you're showing is that Halts is a wrapper for Simulate.

OK, so the problem is coming from Simulate.

Simulate does not decide the same arguments the same way each time.

It depends on existing values global variables such as buffers of
execution traces.

To meet the conditions of the halting proof, any such globals must be
reset to the same state before Simulate is called.

[toc] | [prev] | [next] | [standalone]


#2691 — Re: Solution To The Halting Problem [ H based on UTM ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-05 12:43 -0500
SubjectRe: Solution To The Halting Problem [ H based on UTM ]
Message-ID<bpWdncJ1tsHfRA_9nZ2dnUU7-ffNnZ2d@giganews.com>
In reply to#2690
On 5/5/2021 12:00 PM, Kaz Kylheku wrote:
> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>> On 5/5/2021 10:24 AM, Kaz Kylheku wrote:
>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/4/2021 9:59 PM, Kaz Kylheku wrote:
>>>>>> Halts is called only once and simulated after that.
>>>>>
>>>>> Firstly, this is incorrect language. We simulate *machines* not
>>>>> *functions*. The x86 CPU is being simulated (with troublesome
>>>>> differences from the real thing). This simulated CPU executes.
>>>>>
>>>>
>>>> I was creating a separate virtual machine process context every time
>>>> that Halts() simulates an input.
>>>
>>> I do not believe you. You are making a new /thread/ context only,
>>> attached to the same address space. This context is accessing global
>>> storage locations previously mutated by the parent context, which means
>>> that the functions it is executing become imperative procedures.
>>
>> Each simulation has its own stack-space, heap-space, and registers.
> 
> Ah, but are the execution traces stored in this heap space, or in some
> other data area hidden in the simulator?
> 
> Your simulator maintains state that is not reflected in the conventional
> x86 registers.

Try and find any error in the following specification making sure to 
only include those things explicitly stated in this specification and 
not including any details of prior attempts at implementing this 
specification.

An at least partial halt decider H can be defined on the basis of 
adaptations to a UTM. H simulates its input until the behavior of this 
input matches one of its correct non-halting dynamic behavior patterns. 
  Then H stops simulating this input and reports non-halting.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2692 — Re: Solution To The Halting Problem [ H based on UTM ]

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-05 18:05 +0000
SubjectRe: Solution To The Halting Problem [ H based on UTM ]
Message-ID<20210505110055.225@kylheku.com>
In reply to#2691
On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
> On 5/5/2021 12:00 PM, Kaz Kylheku wrote:
>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/5/2021 10:24 AM, Kaz Kylheku wrote:
>>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/4/2021 9:59 PM, Kaz Kylheku wrote:
>>>>>>> Halts is called only once and simulated after that.
>>>>>>
>>>>>> Firstly, this is incorrect language. We simulate *machines* not
>>>>>> *functions*. The x86 CPU is being simulated (with troublesome
>>>>>> differences from the real thing). This simulated CPU executes.
>>>>>>
>>>>>
>>>>> I was creating a separate virtual machine process context every time
>>>>> that Halts() simulates an input.
>>>>
>>>> I do not believe you. You are making a new /thread/ context only,
>>>> attached to the same address space. This context is accessing global
>>>> storage locations previously mutated by the parent context, which means
>>>> that the functions it is executing become imperative procedures.
>>>
>>> Each simulation has its own stack-space, heap-space, and registers.
>> 
>> Ah, but are the execution traces stored in this heap space, or in some
>> other data area hidden in the simulator?
>> 
>> Your simulator maintains state that is not reflected in the conventional
>> x86 registers.
>
> Try and find any error in the following specification making sure to 
> only include those things explicitly stated in this specification and 
> not including any details of prior attempts at implementing this 
> specification.

Why, because those attempts are starkly incorrect?

> An at least partial halt decider H can be defined on the basis of 
> adaptations to a UTM. H simulates its input until the behavior of this 
> input matches one of its correct non-halting dynamic behavior patterns. 
>   Then H stops simulating this input and reports non-halting.

This specification serves no purpose, and doesn't work toward anything
that will correctly refute any proof.

[toc] | [prev] | [next] | [standalone]


#2693 — Re: Solution To The Halting Problem [ H based on UTM ](errors?)

Fromolcott <NoOne@NoWhere.com>
Date2021-05-05 13:20 -0500
SubjectRe: Solution To The Halting Problem [ H based on UTM ](errors?)
Message-ID<U-SdndwF_5d-fA_9nZ2dnUU7-LnNnZ2d@giganews.com>
In reply to#2692
On 5/5/2021 1:05 PM, Kaz Kylheku wrote:
> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>> On 5/5/2021 12:00 PM, Kaz Kylheku wrote:
>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/5/2021 10:24 AM, Kaz Kylheku wrote:
>>>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/4/2021 9:59 PM, Kaz Kylheku wrote:
>>>>>>>> Halts is called only once and simulated after that.
>>>>>>>
>>>>>>> Firstly, this is incorrect language. We simulate *machines* not
>>>>>>> *functions*. The x86 CPU is being simulated (with troublesome
>>>>>>> differences from the real thing). This simulated CPU executes.
>>>>>>>
>>>>>>
>>>>>> I was creating a separate virtual machine process context every time
>>>>>> that Halts() simulates an input.
>>>>>
>>>>> I do not believe you. You are making a new /thread/ context only,
>>>>> attached to the same address space. This context is accessing global
>>>>> storage locations previously mutated by the parent context, which means
>>>>> that the functions it is executing become imperative procedures.
>>>>
>>>> Each simulation has its own stack-space, heap-space, and registers.
>>>
>>> Ah, but are the execution traces stored in this heap space, or in some
>>> other data area hidden in the simulator?
>>>
>>> Your simulator maintains state that is not reflected in the conventional
>>> x86 registers.
>>
>> Try and find any error in the following specification making sure to
>> only include those things explicitly stated in this specification and
>> not including any details of prior attempts at implementing this
>> specification.
> 
> Why, because those attempts are starkly incorrect?
> 
>> An at least partial halt decider H can be defined on the basis of
>> adaptations to a UTM. H simulates its input until the behavior of this
>> input matches one of its correct non-halting dynamic behavior patterns.
>>    Then H stops simulating this input and reports non-halting.
> 
> This specification serves no purpose, and doesn't work toward anything
> that will correctly refute any proof.
> 

Translation: I could find no errors but don't want to say this.

As far as your conclusion goes it is very obvious to me that you cannot 
possibly find any errors in my assessment that the Linz Ĥ does specify 
infinite execution for every at least partial halt decider H that bases 
its halting decision on simulating its input.

// see page 5
http://www.liarparadox.org 
5/Halting_problem_undecidability_and_infinite_recursion.pdf

// see page 319
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

*** NOTE to all respondents rhetoric and ad hominem do not count as any 
rebuttal what-so-ever ***

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2694 — Re: Solution To The Halting Problem [ H based on UTM ](Pattern Matching)

Fromolcott <NoOne@NoWhere.com>
Date2021-05-05 23:03 -0500
SubjectRe: Solution To The Halting Problem [ H based on UTM ](Pattern Matching)
Message-ID<0rqdnQMk6_fy9w79nZ2dnUU7-IvNnZ2d@giganews.com>
In reply to#2691
On 5/5/2021 10:45 PM, André G. Isaak wrote:
> On 2021-05-05 20:59, olcott wrote:
>> On 5/5/2021 9:48 PM, André G. Isaak wrote:
>>> On 2021-05-05 20:15, olcott wrote:
>>>> On 5/5/2021 9:08 PM, André G. Isaak wrote:
>>>>> On 2021-05-05 19:35, olcott wrote:
>>>>>> On 5/5/2021 7:41 PM, Richard Damon wrote:
>>>>>>> On 5/5/21 8:03 PM, olcott wrote:
>>>>>>>> On 5/5/2021 6:47 PM, Richard Damon wrote:
>>>>>>>>> On 5/5/21 6:19 PM, olcott wrote:
>>>>>>>>>> On 5/5/2021 4:42 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/5/21 5:19 PM, olcott wrote:
>>>>>>>>>>>> On 5/5/2021 2:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/5/21 3:20 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/5/2021 1:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/5/21 2:25 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/5/2021 1:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/5/21 1:43 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/5/2021 12:00 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 5/5/2021 10:24 AM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>> On 2021-05-05, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/4/2021 9:59 PM, Kaz Kylheku wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Halts is called only once and simulated after that.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Firstly, this is incorrect language. We simulate
>>>>>>>>>>>>>>>>>>>>>>> *machines* not
>>>>>>>>>>>>>>>>>>>>>>> *functions*. The x86 CPU is being simulated (with
>>>>>>>>>>>>>>>>>>>>>>> troublesome
>>>>>>>>>>>>>>>>>>>>>>> differences from the real thing). This simulated CPU
>>>>>>>>>>>>>>>>>>>>>>> executes.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I was creating a separate virtual machine process 
>>>>>>>>>>>>>>>>>>>>>> context
>>>>>>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>>>>>>> time
>>>>>>>>>>>>>>>>>>>>>> that Halts() simulates an input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I do not believe you. You are making a new /thread/ 
>>>>>>>>>>>>>>>>>>>>> context
>>>>>>>>>>>>>>>>>>>>> only,
>>>>>>>>>>>>>>>>>>>>> attached to the same address space. This context is 
>>>>>>>>>>>>>>>>>>>>> accessing
>>>>>>>>>>>>>>>>>>>>> global
>>>>>>>>>>>>>>>>>>>>> storage locations previously mutated by the parent 
>>>>>>>>>>>>>>>>>>>>> context,
>>>>>>>>>>>>>>>>>>>>> which
>>>>>>>>>>>>>>>>>>>>> means
>>>>>>>>>>>>>>>>>>>>> that the functions it is executing become imperative
>>>>>>>>>>>>>>>>>>>>> procedures.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Each simulation has its own stack-space, heap-space, 
>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>> registers.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ah, but are the execution traces stored in this heap 
>>>>>>>>>>>>>>>>>>> space,
>>>>>>>>>>>>>>>>>>> or in
>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>> other data area hidden in the simulator?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Your simulator maintains state that is not reflected 
>>>>>>>>>>>>>>>>>>> in the
>>>>>>>>>>>>>>>>>>> conventional
>>>>>>>>>>>>>>>>>>> x86 registers.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Try and find any error in the following specification 
>>>>>>>>>>>>>>>>>> making
>>>>>>>>>>>>>>>>>> sure to
>>>>>>>>>>>>>>>>>> only include those things explicitly stated in this
>>>>>>>>>>>>>>>>>> specification
>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>> not including any details of prior attempts at 
>>>>>>>>>>>>>>>>>> implementing this
>>>>>>>>>>>>>>>>>> specification.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> An at least partial halt decider H can be defined on the
>>>>>>>>>>>>>>>>>> basis of
>>>>>>>>>>>>>>>>>> adaptations to a UTM. H simulates its input until the
>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>> input matches one of its correct non-halting dynamic 
>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>> patterns.
>>>>>>>>>>>>>>>>>>        Then H stops simulating this input and reports
>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Without a specification of this 'correct non-halting 
>>>>>>>>>>>>>>>>> dynamic
>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>> pattern' it is impossible to know if it is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is totally irrelevant. The above hypothetical 
>>>>>>>>>>>>>>>> reasoning
>>>>>>>>>>>>>>>> must be
>>>>>>>>>>>>>>>> analyzed within its given premises. As long as no error 
>>>>>>>>>>>>>>>> is found
>>>>>>>>>>>>>>>> within
>>>>>>>>>>>>>>>> the assumption of its premises then it is valid reasoning.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A foo is a type of bar. Is that correct? Without 
>>>>>>>>>>>>>>> definition of
>>>>>>>>>>>>>>> terms,
>>>>>>>>>>>>>>> the argument is meaningless.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes if I said that the behavior of the input matches a foo 
>>>>>>>>>>>>>> having a
>>>>>>>>>>>>>> bar
>>>>>>>>>>>>>> you would be correct. {correct non-halting dynamic behavior
>>>>>>>>>>>>>> pattern} is
>>>>>>>>>>>>>> not meangingless gibberish like foo and bar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But the way you seem to use it, it seems to be. TO You 
>>>>>>>>>>>>> 'Correct' does
>>>>>>>>>>>>> NOT mean really correct, as you call a pattern that says 
>>>>>>>>>>>>> that a
>>>>>>>>>>>>> Halting
>>>>>>>>>>>>> Computation is non-halting meets your definition of 'Correct'
>>>>>>>>>>>>>
>>>>>>>>>>>>> If Correct doesn't mean Correct, can any other words be 
>>>>>>>>>>>>> trusted.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> We must break the reasoning down into its elemental parts to
>>>>>>>>>>>>>> eliminate
>>>>>>>>>>>>>> the problem of skipping over crucial reasoning steps on 
>>>>>>>>>>>>>> the basis of
>>>>>>>>>>>>>> intuition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is given that the behavior of the input matches
>>>>>>>>>>>>>> {correct non-halting dynamic behavior pattern} then we can 
>>>>>>>>>>>>>> conclude
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> a partial halt decider has decided not halting correctly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, this statement is non-sense because the essence of 
>>>>>>>>>>>>> it is
>>>>>>>>>>>>> asking
>>>>>>>>>>>>> if correct decisions are correct, which is of course a 
>>>>>>>>>>>>> tautology,
>>>>>>>>>>>>> but it
>>>>>>>>>>>>> seems to imply that there is going to be some wiggle where 
>>>>>>>>>>>>> you are
>>>>>>>>>>>>> going
>>>>>>>>>>>>> to try to redefine the meaning of correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Some people vehemently disagree with tautologies because 
>>>>>>>>>>>> their only
>>>>>>>>>>>> focus is on disagreement. That you have agreed that it is a 
>>>>>>>>>>>> tautology
>>>>>>>>>>>> allows us to move on to the next point.
>>>>>>>>>>>>
>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>> [00000aaf](01)  55                      push ebp
>>>>>>>>>>>> [00000ab0](02)  8bec                    mov ebp,esp
>>>>>>>>>>>> [00000ab2](02)  ebfe                    jmp 00000ab2
>>>>>>>>>>>> [00000ab4](01)  5d                      pop ebp
>>>>>>>>>>>> [00000ab5](01)  c3                      ret
>>>>>>>>>>>> Size in bytes:(0007) [00000ab5]
>>>>>>>>>>>>
>>>>>>>>>>>> if (current->Simplified_Opcode == JMP)                // JMP
>>>>>>>>>>>>      if (current->Decode_Target <= current->Address)     // 
>>>>>>>>>>>> upward
>>>>>>>>>>>>        if (traced->Address == current->Decode_Target)    // 
>>>>>>>>>>>> to this
>>>>>>>>>>>> address
>>>>>>>>>>>>          if (Count_Conditional_Branch_Instructions == 0) // 
>>>>>>>>>>>> no escape
>>>>>>>>>>>>          {
>>>>>>>>>>>>            OutputString("Local Halt Decider: "
>>>>>>>>>>>>                         "Infinite Loop Detected Simulation 
>>>>>>>>>>>> Stopped");
>>>>>>>>>>>>            return 1;
>>>>>>>>>>>>          }
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> s I said, the test for correctness is does it give the answer 
>>>>>>>>>>> that the
>>>>>>>>>>> operation of the machine generates.
>>>>>>>>>>>
>>>>>>>>>>> Since your trace has been shown to not be complete, this test is
>>>>>>>>>>> flawed.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I merely cut-and-pasted code to show the
>>>>>>>>>> {correct non-halting dynamic behavior pattern} for infinite 
>>>>>>>>>> loops.
>>>>>>>>>> When this criteria is applied to the above function it is 
>>>>>>>>>> verified as
>>>>>>>>>> {correct non-halting dynamic behavior pattern} for infinite 
>>>>>>>>>> loops.
>>>>>>>>>>
>>>>>>>>>> The idea is not to nit pick every tiny detail in a desperate 
>>>>>>>>>> attempt at
>>>>>>>>>> finding some minuscule thing that can be called an error.
>>>>>>>>>
>>>>>>>>> No, this isn't a 'NIT PICK', but you have shown that the way YOU
>>>>>>>>> consider generating a trace, the rule will have false positive, 
>>>>>>>>> and thus
>>>>>>>>> is false.
>>>>>>>>>
>>>>>>>>> Yes, the example you show it will work for, but to be a true 
>>>>>>>>> rule it
>>>>>>>>> must work for ALL cases. But it doesn't.
>>>>>>>>>
>>>>>>>> Try and show a case where the above behavior pattern is matched 
>>>>>>>> by an
>>>>>>>> actual execution trace and it is not an infinite loop.
>>>>>>>>
>>>>>>>
>>>>>>> First, the way 'Proofs' work is you are supposed to actual 
>>>>>>> provide some
>>>>>>> SOLID reasoning about why the rule is true. Not just one example 
>>>>>>> where
>>>>>>> it is.
>>>>>>>
>>>>>>> Second, you have a LOT of undefined terms in that code snipet. Do 
>>>>>>> I get
>>>>>>> to make my OWN assumption about what they mean? (That makes it 
>>>>>>> too eash)
>>>>>>>
>>>>>>> At a glance, It seems like there is an implied loop scaning 
>>>>>>> through a
>>>>>>> trace in that code, but that isn't shown, so the pattern isn't fully
>>>>>>> defined.
>>>>>>>
>>>>>>>
>>>>>>> A basic scetch of the plan of the problem is that if the 'loop' 
>>>>>>> includes
>>>>>>> a 'recursive' call to Halts, 
>>>>>>
>>>>>> I am merely asking the generic question how would an arbitrary 
>>>>>> program detect that a sequence of x86 code specifies an infinite 
>>>>>> loop?
>>>>>>
>>>>>> Infinite loop detection criteria simplified:
>>>>>> (a) The instruction is a JMP instruction.
>>>>>> (b) It is jumping upward or to its own address.
>>>>>> (c) There are no conditional branch instructions inbetween.
>>>>>
>>>>> According to the above, the following is an infinite loop.
>>>>>
>>>>> void foo(void) {
>>>>> goto LABEL2;
>>>>> LABEL1:
>>>>> // do some more stuff. No conditional branches
>>>>> goto LABEL3;
>>>>> LABEL2:
>>>>> // do yet more stuff. No conditional branches.
>>>>> goto LABEL1;  // JUMPS 'UPWARDS'
>>>>> LABEL3:
>>>>> }
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Good catch. See if you can find any problems with this one:
>>>>
>>>> If the execution trace of function Y() shows:
>>>> function X() is called twice in sequence from the same machine 
>>>> address of Y()
>>>> with the same parameters to X()
>>>> with no conditional branch or indexed jump instructions in Y()
>>>> with no function call returns from X()
>>>> then the function call from Y() to X() is infinitely recursive.
>>>
>>> Well, according to that, the following *isn't* infinitely recursive.
>>>
>>> void foo(void) {
>>>   int x = 5;
>>>   if x > 10 goto LABEL;
>>>   foo()
>>>   LABEL:
>>>   return;
>>> }
>>>
>>
>> I am only interested in false positives, not false negatives.
>>
>> Are there any cases that the above criteria says are infinite 
>> recursion that are not infinite recursion?
> 
> The problem here is that your Halts(H_Hat, H_Hat) doesn't meet the above 
> specification, at least not if we take your claims about how this works 
> seriously.
> 

Whether or not the current code meets the above specification (I believe 
that it does) the above specification does provide the criterion measure 
to determine infinitely nested simulation, stop this simulation on this 
basis and report non-halting.

> You have Halts() simulating H_Hat, which in turn calls Halts(), but that 
> latter halts isn't going to be at the same machine address 

As a matter of objective fact it <is> at the same address and that it is 
at the same address is the way that the same code can serve multiple 
clients. In the bad old days of the internet code was duplicated to 
serve multiple clients.

> as the outer 
> halts since it is part of the simulation. Similarly, subsequent calls to 
> halts will be to simulations of simulations of Halts(), and so forth.
> 
> You can't meaningfully compare machine addresses from an actual call and 
> a simulation of that call, or a simulation [...] of a simulation of that 
> call.
> 
> Moreover, there *are* conditional branches between calls to each 
> successive level of simulation since your 'decider' needs to determine 
> whether to abort a given simulation. That's going to involve a conditional.
> 
> André
> 

There are conditional branches in the halt decider when the halt decider 
decides that the above infinite loop would never halt, none-the-less its 
decision is correct. The key basis is whether or not the infinite 
execution pattern is matched. Once it is matched then not halting is 
correctly decided.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2695 — Re: New test program (Succeeds V2)

Fromolcott <NoOne@NoWhere.com>
Date2021-05-07 16:13 -0500
SubjectRe: New test program (Succeeds V2)
Message-ID<aeOdnQfkqKIdMAj9nZ2dnUU7-SvNnZ2d@giganews.com>
In reply to#2694
On 5/7/2021 3:37 PM, Kaz Kylheku wrote:
> On 2021-05-07, olcott <NoOne@NoWhere.com> wrote:
>> #define NRES 4
>>
>> struct HaltResult
>> {
>>      u32 P, I, H;
>> };
>>
>> struct HaltResult res[4] = {{1,1,1},{2,2,2},{3,3,3},{4,4,4}};
> 
> It would be good if you would pick up the res[NRES] fix here,
> as well as Output("H_Hat returned") in main.
> 
>>
>> void Init_res()
>> {
>>     for (u32 N = 0; N < NRES; N++)
>>     {
>>       res[N].P = 0;
>>       res[N].I = 0;
>>       res[N].H = 0;
>>     }
>> }
> 
> Yes, this initialization now meets the intent of the original code.
> 
> I think that for the longer term, it would be good to repair your COFF
> loader so that it handles the zero-initialized data which is indicated
> in the COFF file.
> 
> Then you can explore whatever C code you want without workarounds
> for zero-initialized statics.
> 

Yes as soon as my halt decider is accepted as correct this is first on 
the list of enhacements.

>>       if (i >= NRES)
>>       {
>>         // Array has filled up, what? We only call this twice.
>>         OutputString("Unexpected excess calls to HaltsProxy!");
>>         loop1: goto loop1;
>>       }
> 
> Nitpick: that should still be restored to its position outside of the
> loop. We never run into this condition either way, since we don't work
> with multiple unique P, I pairs.
> 

I only corrected syntax errors in your code.
Your code stipulates that it is inside the loop.

You probably got confused by your formatting conventions. I always match 
curly braces on a line by themselves with the same indentation level.

> Otherwise you might as well remove this code; it is unreachable.
> 
>>     }
>>     return H;
>> }
>>

It is not unreachable.

>>
>> void H_Hat4(u32 P)
> 
> Seeing you use different names for different H_Hat versions is
> encouraging.
> 

Good.

>> int TestHaltsProxy()
>> {
>>     Init_res();
>>     u32 H = HaltsProxy((u32) H_Hat4, (u32) H_Hat4);
>>     Output("Input halts = ", H);
>>     H_Hat4((u32) H_Hat4);
>>     OutputString("Halt returned");
> 
> Please correct to "H_Hat4 returned"; that was my intent.
> 

OK

> Your execution trace is essentially the same as before.
> 
> The issue is that we see these, in that order:
> 
>> Begin Local Halt Decider Simulation at Machine Address:d45
> 
> (Halts starts running a nested simulated machine executing H_Hat4(H_Hat4)).
> 
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>> ...[00000c88][0010192e][90909090](03)  83c408                  add esp,+08
>> ...[00000c8b][0010192e][00000000](03)  8945f4                  mov
> 
> (outer simulation continues)
> 
>> Input halts = 0
> 
> (Halts has returned 0 to main.)
> 
>> Begin Local Halt Decider Simulation at Machine Address:d45
> 
> (another nested simulation: this is due to H_Hat4(H_Hat4) calling Halts!)
> 
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> 
> (stops again, but surrounding simulation keeps going)
> 
>> Halt returned
> 
> Oops, H_Hat4(H_Hat4) returns due to getting getting a 0 from Halts.
> 
> So the 0 is incorrect: a direct call to H_Hat4(H_Hat4) returns.
> 

Halts(H_Hat, H_Hat) is an instance of both of these truisms:

It is true that every computation that would never halt unless its 
simulation was stopped is a non-halting computation. Some may disagree 
out of ignorance or deception none-the-less it remains a truism.

Every at least partial halt decider that decides to stop simulating its 
input on the basis that the execution trace of this input matches a 
correct non-halting behavior pattern does decide not halting correctly.

Do you understand that disagreeing with an actual truism is always 
necessarily incorrect?

> The "Input halts = 0" result has exactly the meaning that "a direct call
> to H_Hat4(H_Hat4) out of main shall not terminate". Yet that's exactly
> what that call does.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 1 of 3  [1] 2 3  Next page →

Back to top | Article view | comp.software-eng


csiph-web