Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.software-eng > #2669 > unrolled thread
| Started by | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| First post | 2021-05-02 14:15 +0100 |
| Last post | 2021-05-22 15:12 -0500 |
| Articles | 20 on this page of 48 — 6 participants |
Back to article view | Back to comp.software-eng
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 →
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2021-05-02 14:15 +0100 |
| Subject | Solution 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-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]
| From | Richard Harnden <richard.nospam@gmail.com> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 10:21 -0500 |
| Subject | Re: 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]
| From | Richard Harnden <richard.nospam@gmail.com> |
|---|---|
| Date | 2021-05-02 17:11 +0100 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-02 16:38 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 12:55 -0500 |
| Subject | Re: 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]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2021-05-02 19:14 +0100 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-02 13:18 -0500 |
| Subject | Re: 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]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2021-05-03 22:33 +0100 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 10:38 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 13:45 -0500 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-04 19:24 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-04 19:41 -0500 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-05 00:55 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-05 12:43 -0500 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-05 18:05 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-05 13:20 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-05 23:03 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-07 16:13 -0500 |
| Subject | Re: 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