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

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

Simulating halt deciders defeat the halting theorem

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

Contents

  Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-14 18:57 -0600
    Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-14 21:03 -0500
    Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-15 08:57 -0600
      Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-15 18:57 -0500
    Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-15 20:22 -0600
      Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-15 21:36 -0500
      Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-15 20:39 -0600
        Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-15 21:55 -0500
        Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-15 21:15 -0600
          Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-15 22:20 -0500
          Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-15 21:28 -0600
            Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-15 22:42 -0500
              Re: Simulating halt deciders defeat the halting theorem olcott <polcott2@gmail.com> - 2023-02-16 10:59 -0600
                Re: Simulating halt deciders defeat the halting theorem Richard Damon <Richard@Damon-Family.org> - 2023-02-16 18:43 -0500

#3637 — Simulating halt deciders defeat the halting theorem

(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D could not possibly reach its
own "return" statement in a finite number of simulated steps then:

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

When it is understood that (b) is a necessary consequence of (a) and we
can see that (a) has been met then we understand that H(D,D) has
correctly determined the halt state of its input.

001 int D(int (*x)())
002 {
003   int Halt_Status = H(x, x);
004   if (Halt_Status)
005     HERE: goto HERE;
006   return Halt_Status;
007 }
008
009 int main()
010 {
011   Output("Input_Halts = ", H(D,D));
012   Output("Input_Halts = ", D(D));
013 }

*Simulating halt deciders applied to the halting theorem*
The above is fully operational code in the x86utm operating system.

Because H correctly detects that D correctly simulated by H would
continue to call H(D,D) never reaching its own "return" statement H
aborts it simulation of D and returns 0 to main() on line 011.

Because H correctly detects that D correctly simulated by H would
continue to call H(D,D) never reaching its own "return" statement H
aborts it simulation of D and returns 0 to the executed D on line 003.

straw man
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument. 
https://www.lexico.com/en/definition/straw_man

Every recent rebuttal uses the strawman deception to change the subject
away from: { D correctly simulated by H } or denies that (b) is a
necessary consequence of (a).



*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem 



-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [next] | [standalone]

#3638

On 2/14/23 7:57 PM, olcott wrote:
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D could not possibly reach its
> own "return" statement in a finite number of simulated steps then:

Eccept that H can never correctly determine this of D, since if the H 
that is called by D does ever abort its simulation and returns 0, then D 
will halt, thus, since BY DEFINITION, the H we are talking about must be 
the same decider, unless you can show that a "Turing Equivalent Program" 
can act differently in two call sites, this can't happen.

You have been asked for this evidence, and failed to provide it, thus 
you have effectively admitted it is FALSE.

> 
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.


> 
> When it is understood that (b) is a necessary consequence of (a) and we
> can see that (a) has been met then we understand that H(D,D) has
> correctly determined the halt state of its input.

but (a) is never true for D

> 
> 001 int D(int (*x)())
> 002 {
> 003   int Halt_Status = H(x, x);
> 004   if (Halt_Status)
> 005     HERE: goto HERE;
> 006   return Halt_Status;
> 007 }
> 008
> 009 int main()
> 010 {
> 011   Output("Input_Halts = ", H(D,D));
> 012   Output("Input_Halts = ", D(D));
> 013 }
> 
> *Simulating halt deciders applied to the halting theorem*
> The above is fully operational code in the x86utm operating system.
> 
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to main() on line 011.

Execpt it doesn't, because H will always abort its simulation too soon, 
and an actual correct simulation will reach the return statement, 
showing H is incorrect.

> 
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to the executed D on line 003.

Except it doesnt.

> 
> straw man
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument. 
> https://www.lexico.com/en/definition/straw_man

Right, and since the DEFINITION of Halting is about the ACTUAL BEHAVIOR 
of the machine, or equivalently the simulation of it by a ACTUAL UTM, 
you arguements about simution by the decider (which isn't a UTM) is just 
shwon to be a STRAWMAN, and your entire arguement a big fat LIE.

> 
> Every recent rebuttal uses the strawman deception to change the subject
> away from: { D correctly simulated by H } or denies that (b) is a
> necessary consequence of (a).
> 
> 

Nope, all YOUR arguement are strawman because you don't use the ACTUAL 
definiton of Halting.

> 
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> 
> 

Just a load of garbage, as proven.

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

#3639

On 2/14/2023 6:57 PM, olcott wrote:
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D could not possibly reach its
> own "return" statement in a finite number of simulated steps then:
> 
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> 
> When it is understood that (b) is a necessary consequence of (a) and we
> can see that (a) has been met then we understand that H(D,D) has
> correctly determined the halt state of its input.
> 
> 001 int D(int (*x)())
> 002 {
> 003   int Halt_Status = H(x, x);
> 004   if (Halt_Status)
> 005     HERE: goto HERE;
> 006   return Halt_Status;
> 007 }
> 008
> 009 int main()
> 010 {
> 011   Output("Input_Halts = ", H(D,D));
> 012   Output("Input_Halts = ", D(D));
> 013 }
> 
> *Simulating halt deciders applied to the halting theorem*
> The above is fully operational code in the x86utm operating system.
> 
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to main() on line 011.
> 
> Because H correctly detects that D correctly simulated by H would
> continue to call H(D,D) never reaching its own "return" statement H
> aborts it simulation of D and returns 0 to the executed D on line 003.
> 
> straw man
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument. 
> https://www.lexico.com/en/definition/straw_man
> 
> Every recent rebuttal uses the strawman deception to change the subject
> away from: { D correctly simulated by H } or denies that (b) is a
> necessary consequence of (a).
> 

Simulating Halt decider H(D,D) computes the mapping from its inputs to
an accept or reject state based on the behavior of D correctly simulated
by H. H simulates D until H determines that D would never reach its own
"return" statement in any finite number of simulated steps.

All halt deciders are intended to correctly predict the behavior of non-
terminating inputs. No halt decider ever continues to simulate its
input after it has correctly detected a repeating state.

Halfwit morons can't seem to understand this. These incredibly stupid
people seem to believe that the only way to detect infinite behavior is
to continue to simulate the non-halting input forever.

People with a modicum of technical competence will understand that when
D calls H(D,D) to simulate itself again that this simulated D cannot
possibly reach its own "return" statement in any finite number of steps.

I have shown this in x86 assembly language so that it is perfectly
unambiguously clear yet even highly skilled people seemed to have
totally forgotten this lost art.

H: Begin Simulation   Execution Trace Stored at:113109
Address_of_H:1562
[00001d12][001130f5][001130f9] 55         push ebp       ; begin D
[00001d13][001130f5][001130f9] 8bec       mov ebp,esp
[00001d15][001130f1][001030c5] 51         push ecx
[00001d16][001130f1][001030c5] 8b4508     mov eax,[ebp+08]
[00001d19][001130ed][00001d12] 50         push eax       ; push address of D
[00001d1a][001130ed][00001d12] 8b4d08     mov ecx,[ebp+08]
[00001d1d][001130e9][00001d12] 51         push ecx       ; push address of D
[00001d1e][001130e5][00001d23] e83ff8ffff call 00001562  ; call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

We can see that the first seven instructions of D simulated by H 
precisely match the first seven instructions of the x86 source-code of 
D. This conclusively proves that these instructions were simulated 
correctly.

Anyone sufficiently technically competent in the x86 programming 
language will agree that the above execution trace of D simulated by H 
shows that D will never reach its own "return" statement.

H detects that D is calling itself with the exact same arguments that H 
was called with and there are no conditional branch instructions from 
the beginning of D to its call to H that can possibly escape the 
repetition of this recursive simulation.


> 
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
> 
> 

-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3642

On 2/15/23 9:57 AM, olcott wrote:
> On 2/14/2023 6:57 PM, olcott wrote:
>> (a) If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D could not possibly reach its
>> own "return" statement in a finite number of simulated steps then:
>>
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> When it is understood that (b) is a necessary consequence of (a) and we
>> can see that (a) has been met then we understand that H(D,D) has
>> correctly determined the halt state of its input.
>>
>> 001 int D(int (*x)())
>> 002 {
>> 003   int Halt_Status = H(x, x);
>> 004   if (Halt_Status)
>> 005     HERE: goto HERE;
>> 006   return Halt_Status;
>> 007 }
>> 008
>> 009 int main()
>> 010 {
>> 011   Output("Input_Halts = ", H(D,D));
>> 012   Output("Input_Halts = ", D(D));
>> 013 }
>>
>> *Simulating halt deciders applied to the halting theorem*
>> The above is fully operational code in the x86utm operating system.
>>
>> Because H correctly detects that D correctly simulated by H would
>> continue to call H(D,D) never reaching its own "return" statement H
>> aborts it simulation of D and returns 0 to main() on line 011.
>>
>> Because H correctly detects that D correctly simulated by H would
>> continue to call H(D,D) never reaching its own "return" statement H
>> aborts it simulation of D and returns 0 to the executed D on line 003.
>>
>> straw man
>> An intentionally misrepresented proposition that is set up because it is
>> easier to defeat than an opponent's real argument. 
>> https://www.lexico.com/en/definition/straw_man
>>
>> Every recent rebuttal uses the strawman deception to change the subject
>> away from: { D correctly simulated by H } or denies that (b) is a
>> necessary consequence of (a).
>>
> 
> Simulating Halt decider H(D,D) computes the mapping from its inputs to
> an accept or reject state based on the behavior of D correctly simulated
> by H. H simulates D until H determines that D would never reach its own
> "return" statement in any finite number of simulated steps.

And if that doesn't match the Halting Behavior of the actual function 
then it isn't computing that Halting Function so it isn't a "Halt Decider.

D(D) Halts since H(D,D) returns 0, thus Halting(D,D) is True, thus the 
CORRECT answer from H if it is an actual Halt Decider is 1, so H is 
INCORRECT in its decision of H(D,D).

> 
> All halt deciders are intended to correctly predict the behavior of non-
> terminating inputs. No halt decider ever continues to simulate its
> input after it has correctly detected a repeating state.
> 

Right, but it needs to CORRECTLY determine the answer, which if H(D,D) 
returns 0, and thus D(D) will halt, means H(D,D) SHOULD have returned 1.


> Halfwit morons can't seem to understand this. These incredibly stupid
> people seem to believe that the only way to detect infinite behavior is
> to continue to simulate the non-halting input forever.
> 

And NO-WIT OLCOTTS don't understand that the decider needs to answer 
Halting if the input would Halt when run or correctly simulated by an 
actual UTM.

D(D) Halts since H(D,D) Returns 0, thus the CORRECT answer for H(D,D) is 
1, and H was incorrect.

To claim 0 is the correct answer is to show that the claimant is a liar.

> People with a modicum of technical competence will understand that when
> D calls H(D,D) to simulate itself again that this simulated D cannot
> possibly reach its own "return" statement in any finite number of steps.
> 

Right, because H aborrs its simulation before the CORRECT simulation 
reaches that final state, which is what actually matters.

It is only your strawman that tries to refer to the PARTIAL simulation 
done by H as the bases that even comes close to your claims

> I have shown this in x86 assembly language so that it is perfectly
> unambiguously clear yet even highly skilled people seemed to have
> totally forgotten this lost art.



> 
> H: Begin Simulation   Execution Trace Stored at:113109
> Address_of_H:1562
> [00001d12][001130f5][001130f9] 55         push ebp       ; begin D
> [00001d13][001130f5][001130f9] 8bec       mov ebp,esp
> [00001d15][001130f1][001030c5] 51         push ecx
> [00001d16][001130f1][001030c5] 8b4508     mov eax,[ebp+08]
> [00001d19][001130ed][00001d12] 50         push eax       ; push address 
> of D
> [00001d1a][001130ed][00001d12] 8b4d08     mov ecx,[ebp+08]
> [00001d1d][001130e9][00001d12] 51         push ecx       ; push address 
> of D
> [00001d1e][001130e5][00001d23] e83ff8ffff call 00001562  ; call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped

And if H is correct about that, then H can never abort its simulation, 
so H lies.

If H does abort its simulation, it is incorrect about its conclusion 
that this is an infinitely recursive simulation.

H just doesn't understand the behavior of the H that it is simulating.

> 
> We can see that the first seven instructions of D simulated by H 
> precisely match the first seven instructions of the x86 source-code of 
> D. This conclusively proves that these instructions were simulated 
> correctly.
> 

So, we see that D will call an H that will simulate D again, and since 
we now know that H WILL abort its simulation when it gets to the call to 
H, we know that there is no infinite simulation loop, but that it will 
be aborted by H.

Until you can show that the two identical H's will actually behave 
differently, you are just claiming a lie.

This has been asked before, and you have failed to answer, thus showing 
that you admit you can't prove your claim, and it is just a fabricaiton 
and a lie

> Anyone sufficiently technically competent in the x86 programming 
> language will agree that the above execution trace of D simulated by H 
> shows that D will never reach its own "return" statement.

Which just proves that it is impossible for H to correct simulate this 
input to prove that it is Halting.

Your proof is just that the whole category of such deciders can never be 
correct.

> 
> H detects that D is calling itself with the exact same arguments that H 
> was called with and there are no conditional branch instructions from 
> the beginning of D to its call to H that can possibly escape the 
> repetition of this recursive simulation.

No, we KNOW that a CORRECT AND COMPLETE simulation of the input. not 
able to be done by H, will see the excape if H gives the answer 0, thus 
H is incorrect for the ACTUAL requriement.

It is only "correct" for your "strawman" requirement, which proves that 
that your claimed equivalent requirement is not actually equivalent by 
is just a strawman.

You are just proving your stupidity.
> 
> 
>>
>> *Simulating Halt Decider Applied to the Halting Theorem*
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>>
> 

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

#3645

On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
> 
>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse wrote:
>>
>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>> even though P(P) halts?
>>>
>>> PO: Yes that is the correct answer even though P(P) halts.
>>
>> Wow!
>>
>> So for PO H is a "correct halt decider" even if it states that a
>> program P with input P _doesn't halt_, though it _halts_.
>>
>> Well, what can I say?
> 
> What indeed.  I think this is pretty much the only reply that should be
> made to PO.  He may, one day, admit that that was wrong and start to
> build a new waffle mountain, but until then, its game over.
> 
>> Seems that all cranks are more or less "the same" (in a certain
>> sense): WM, PO, JG, AP, etc.
> 
> In some way yes, but they all disagree with each other when the surface
> is scratched because they all want to be the unique individual who as
> seen clearly where everyone else was blind.  I would not be surprised if
> they all had NPD.
> 
>> See:
>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
> 
> Possibly literally!
> 

int D(int (*x)())
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

int main()
{
   Output("Input_Halts = ", H(D,D));
   Output("Input_Halts = ", D(D));
}

None-the-less Ben will not lie about:
*H correctly predicts that D correctly simulated by H would never halt*
*H correctly predicts that D correctly simulated by H would never halt*
*H correctly predicts that D correctly simulated by H would never halt*

-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3646

On 2/15/23 9:22 PM, olcott wrote:
> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>
>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>> wrote:
>>>
>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>> even though P(P) halts?
>>>>
>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>
>>> Wow!
>>>
>>> So for PO H is a "correct halt decider" even if it states that a
>>> program P with input P _doesn't halt_, though it _halts_.
>>>
>>> Well, what can I say?
>>
>> What indeed.  I think this is pretty much the only reply that should be
>> made to PO.  He may, one day, admit that that was wrong and start to
>> build a new waffle mountain, but until then, its game over.
>>
>>> Seems that all cranks are more or less "the same" (in a certain
>>> sense): WM, PO, JG, AP, etc.
>>
>> In some way yes, but they all disagree with each other when the surface
>> is scratched because they all want to be the unique individual who as
>> seen clearly where everyone else was blind.  I would not be surprised if
>> they all had NPD.
>>
>>> See:
>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>
>> Possibly literally!
>>
> 
> int D(int (*x)())
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> int main()
> {
>    Output("Input_Halts = ", H(D,D));
>    Output("Input_Halts = ", D(D));
> }
> 
> None-the-less Ben will not lie about:
> *H correctly predicts that D correctly simulated by H would never halt*
> *H correctly predicts that D correctly simulated by H would never halt*
> *H correctly predicts that D correctly simulated by H would never halt*
> 

So, you aren't working on the Halting Problem so your HH isn't actually 
a Halting Decider.

Remember:

In computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run forever.


**WHETHER THE PROGRAM WILL FINISH RUNNING**

Note if some sort of somulation by H would never halt, which can't be 
"correct" since a "correct simulation" show the actual behavior of the 
thing simulated, and it has been shown that D(D) will Halt since H(D,D) 
returns 0.

You are just proving you are ignorant of what you are talking about and 
are just a patholgocial liar not caring if your words are accurate.

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

#3647

On 2/15/2023 8:22 PM, olcott wrote:
> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>
>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>> wrote:
>>>
>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>> even though P(P) halts?
>>>>
>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>
>>> Wow!
>>>
>>> So for PO H is a "correct halt decider" even if it states that a
>>> program P with input P _doesn't halt_, though it _halts_.
>>>
>>> Well, what can I say?
>>
>> What indeed.  I think this is pretty much the only reply that should be
>> made to PO.  He may, one day, admit that that was wrong and start to
>> build a new waffle mountain, but until then, its game over.
>>
>>> Seems that all cranks are more or less "the same" (in a certain
>>> sense): WM, PO, JG, AP, etc.
>>
>> In some way yes, but they all disagree with each other when the surface
>> is scratched because they all want to be the unique individual who as
>> seen clearly where everyone else was blind.  I would not be surprised if
>> they all had NPD.
>>
>>> See:
>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>
>> Possibly literally!
>>
> 
> int D(int (*x)())
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> int main()
> {
>    Output("Input_Halts = ", H(D,D));
>    Output("Input_Halts = ", D(D));
> }
> 
> None-the-less Ben will not lie about:
> *H correctly predicts that D correctly simulated by H would never halt*
> *H correctly predicts that D correctly simulated by H would never halt*
> *H correctly predicts that D correctly simulated by H would never halt*

In other words because Ben is not a liar he implicitly affirms that
H(D,D) does correctly compute the mapping from its input to its reject
state on the above basis.

-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3648

On 2/15/23 9:39 PM, olcott wrote:
> On 2/15/2023 8:22 PM, olcott wrote:
>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>
>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>>> wrote:
>>>>
>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>> even though P(P) halts?
>>>>>
>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>
>>>> Wow!
>>>>
>>>> So for PO H is a "correct halt decider" even if it states that a
>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>
>>>> Well, what can I say?
>>>
>>> What indeed.  I think this is pretty much the only reply that should be
>>> made to PO.  He may, one day, admit that that was wrong and start to
>>> build a new waffle mountain, but until then, its game over.
>>>
>>>> Seems that all cranks are more or less "the same" (in a certain
>>>> sense): WM, PO, JG, AP, etc.
>>>
>>> In some way yes, but they all disagree with each other when the surface
>>> is scratched because they all want to be the unique individual who as
>>> seen clearly where everyone else was blind.  I would not be surprised if
>>> they all had NPD.
>>>
>>>> See:
>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>
>>> Possibly literally!
>>>
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>>    Output("Input_Halts = ", D(D));
>> }
>>
>> None-the-less Ben will not lie about:
>> *H correctly predicts that D correctly simulated by H would never halt*
>> *H correctly predicts that D correctly simulated by H would never halt*
>> *H correctly predicts that D correctly simulated by H would never halt*
> 
> In other words because Ben is not a liar he implicitly affirms that
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the above basis.
> 

No, he says you THINK "A Correct Halt Decider" can say what you say it 
does, even if that isn't the actual definition of a corect halt decider.


Read what he asy again

He says that for YOU, H is correct, ... even if it states that a program 
doesn't halt when it halts.

You are just showing you don't understand English.

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

#3649

On 2/15/2023 8:39 PM, olcott wrote:
> On 2/15/2023 8:22 PM, olcott wrote:
>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>
>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>>> wrote:
>>>>
>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>> even though P(P) halts?
>>>>>
>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>
>>>> Wow!
>>>>
>>>> So for PO H is a "correct halt decider" even if it states that a
>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>
>>>> Well, what can I say?
>>>
>>> What indeed.  I think this is pretty much the only reply that should be
>>> made to PO.  He may, one day, admit that that was wrong and start to
>>> build a new waffle mountain, but until then, its game over.
>>>
>>>> Seems that all cranks are more or less "the same" (in a certain
>>>> sense): WM, PO, JG, AP, etc.
>>>
>>> In some way yes, but they all disagree with each other when the surface
>>> is scratched because they all want to be the unique individual who as
>>> seen clearly where everyone else was blind.  I would not be surprised if
>>> they all had NPD.
>>>
>>>> See:
>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>
>>> Possibly literally!
>>>
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>>    Output("Input_Halts = ", D(D));
>> }
>>
>> None-the-less Ben will not lie about:
>> *H correctly predicts that D correctly simulated by H would never halt*
>> *H correctly predicts that D correctly simulated by H would never halt*
>> *H correctly predicts that D correctly simulated by H would never halt*
> 
> In other words because Ben is not a liar he implicitly affirms that
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the above basis.
> 

There are all kinds of way to weasel word around the above two verified
facts that will fool the gullible.

*None-the-less this verified fact remains irrefutable*

H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt.


-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3650

On 2/15/23 10:15 PM, olcott wrote:
> On 2/15/2023 8:39 PM, olcott wrote:
>> On 2/15/2023 8:22 PM, olcott wrote:
>>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>
>>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>>>> wrote:
>>>>>
>>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>>> even though P(P) halts?
>>>>>>
>>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>>
>>>>> Wow!
>>>>>
>>>>> So for PO H is a "correct halt decider" even if it states that a
>>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>>
>>>>> Well, what can I say?
>>>>
>>>> What indeed.  I think this is pretty much the only reply that should be
>>>> made to PO.  He may, one day, admit that that was wrong and start to
>>>> build a new waffle mountain, but until then, its game over.
>>>>
>>>>> Seems that all cranks are more or less "the same" (in a certain
>>>>> sense): WM, PO, JG, AP, etc.
>>>>
>>>> In some way yes, but they all disagree with each other when the surface
>>>> is scratched because they all want to be the unique individual who as
>>>> seen clearly where everyone else was blind.  I would not be 
>>>> surprised if
>>>> they all had NPD.
>>>>
>>>>> See:
>>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>>
>>>> Possibly literally!
>>>>
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>>    Output("Input_Halts = ", D(D));
>>> }
>>>
>>> None-the-less Ben will not lie about:
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>
>> In other words because Ben is not a liar he implicitly affirms that
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the above basis.
>>
> 
> There are all kinds of way to weasel word around the above two verified
> facts that will fool the gullible.
> 
> *None-the-less this verified fact remains irrefutable*
> 
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt.
> 
> 

Which isn't Halt Deciding but just Peter Olcott's Other Problem (POOP) 
deciding.

In computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run forever.

Thus a HALT DECIDER must report on the behavior of whether the ACTUAL 
PROGRAM (described by the input) would Halt or not.

D(D) Halts, since H(D,D) returns 0.

THus, for an actual Halt Decider, the correct answer is Halting.

Since you say the "Correct Answer" in Not Halting, the question CAN'T be 
the Halting Problem, or you are just proving you are a LIAR.

You H may in fact be a correct POOP decider, which you THINK is a Halt 
Decider, but it isn't one.

PERIOD.

All your weasle words to claim otherwise are just revealed to be what 
they are, and you are proved to be an idiot as you can't tell the 
difference between POOP and Halting.

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

#3651

On 2/15/2023 9:15 PM, olcott wrote:
> On 2/15/2023 8:39 PM, olcott wrote:
>> On 2/15/2023 8:22 PM, olcott wrote:
>>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>
>>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben Bacarisse 
>>>>> wrote:
>>>>>
>>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>>> even though P(P) halts?
>>>>>>
>>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>>
>>>>> Wow!
>>>>>
>>>>> So for PO H is a "correct halt decider" even if it states that a
>>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>>
>>>>> Well, what can I say?
>>>>
>>>> What indeed.  I think this is pretty much the only reply that should be
>>>> made to PO.  He may, one day, admit that that was wrong and start to
>>>> build a new waffle mountain, but until then, its game over.
>>>>
>>>>> Seems that all cranks are more or less "the same" (in a certain
>>>>> sense): WM, PO, JG, AP, etc.
>>>>
>>>> In some way yes, but they all disagree with each other when the surface
>>>> is scratched because they all want to be the unique individual who as
>>>> seen clearly where everyone else was blind.  I would not be 
>>>> surprised if
>>>> they all had NPD.
>>>>
>>>>> See:
>>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>>
>>>> Possibly literally!
>>>>
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>>    Output("Input_Halts = ", D(D));
>>> }
>>>
>>> None-the-less Ben will not lie about:
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>> *H correctly predicts that D correctly simulated by H would never halt*
>>
>> In other words because Ben is not a liar he implicitly affirms that
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the above basis.
>>
> 
> There are all kinds of way to weasel word around the above two verified
> facts that will fool the gullible.
> 
> *None-the-less this verified fact remains irrefutable*
> 
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt.

*Finally a most important key point of agreement*

Now we are at the point where I said that I painted my house white and
people disagree on the basis that the can of paint said that the color
was eggshell.

-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3652

On 2/15/23 10:28 PM, olcott wrote:
> On 2/15/2023 9:15 PM, olcott wrote:
>> On 2/15/2023 8:39 PM, olcott wrote:
>>> On 2/15/2023 8:22 PM, olcott wrote:
>>>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>
>>>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben 
>>>>>> Bacarisse wrote:
>>>>>>
>>>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>>>> even though P(P) halts?
>>>>>>>
>>>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>>>
>>>>>> Wow!
>>>>>>
>>>>>> So for PO H is a "correct halt decider" even if it states that a
>>>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>>>
>>>>>> Well, what can I say?
>>>>>
>>>>> What indeed.  I think this is pretty much the only reply that 
>>>>> should be
>>>>> made to PO.  He may, one day, admit that that was wrong and start to
>>>>> build a new waffle mountain, but until then, its game over.
>>>>>
>>>>>> Seems that all cranks are more or less "the same" (in a certain
>>>>>> sense): WM, PO, JG, AP, etc.
>>>>>
>>>>> In some way yes, but they all disagree with each other when the 
>>>>> surface
>>>>> is scratched because they all want to be the unique individual who as
>>>>> seen clearly where everyone else was blind.  I would not be 
>>>>> surprised if
>>>>> they all had NPD.
>>>>>
>>>>>> See:
>>>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>>>
>>>>> Possibly literally!
>>>>>
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>>    Output("Input_Halts = ", D(D));
>>>> }
>>>>
>>>> None-the-less Ben will not lie about:
>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>
>>> In other words because Ben is not a liar he implicitly affirms that
>>> H(D,D) does correctly compute the mapping from its input to its reject
>>> state on the above basis.
>>>
>>
>> There are all kinds of way to weasel word around the above two verified
>> facts that will fool the gullible.
>>
>> *None-the-less this verified fact remains irrefutable*
>>
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the basis that H correctly predicts that D correctly simulated
>> by H would never halt.
> 
> *Finally a most important key point of agreement*
> 
> Now we are at the point where I said that I painted my house white and
> people disagree on the basis that the can of paint said that the color
> was eggshell.
> 

So, you still think that your POOP is halting, because you don't know 
the difference.

In computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run forever.

This says NOTHING about the decider being able to argue about it being 
unable to simulate to a final state.

The ONLY thing that matters is the behavior of the actual machine. PERIOD.

Anything else either must be actually equivalent, so the answer is the 
same, or it isn't a correct interpreation.

This is like you saying you painted the house white, but the color is 
actually purple.

Your idea of what "Halting" means isn't compatible with the actual 
definition in all cases, and H^/P/D is one of the cases it differs. You 
are just too blind to be able to tell the difference.

You may THINK its just like White vs Eggshell, but that just shows you 
don't actually understand what you are talking about.

Ultimately, you have made the explicit claim that even though D(D) 
Halts, that Non-Halting is the correct answer for H to give as a Halt 
Decider.

THAT IS WRONG. PERIOD.

Your claim just proves you are either totally ignorant, or a 
pathological liar, or most likely BOTH.

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

#3655

On 2/16/2023 8:44 AM, Don Stockbauer wrote:
> On Wednesday, February 15, 2023 at 9:42:17 PM UTC-6, Richard Damon wrote:
>> On 2/15/23 10:28 PM, olcott wrote:
>>> On 2/15/2023 9:15 PM, olcott wrote:
>>>> On 2/15/2023 8:39 PM, olcott wrote:
>>>>> On 2/15/2023 8:22 PM, olcott wrote:
>>>>>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>>>>>> Fritz Feldhase <franz.fri...@gmail.com> writes:
>>>>>>>
>>>>>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben
>>>>>>>> Bacarisse wrote:
>>>>>>>>
>>>>>>>>> Me: do you still assert that H(P,P) == false is the "correct" answer
>>>>>>>>> even though P(P) halts?
>>>>>>>>>
>>>>>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>>>>>
>>>>>>>> Wow!
>>>>>>>>
>>>>>>>> So for PO H is a "correct halt decider" even if it states that a
>>>>>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>>>>>
>>>>>>>> Well, what can I say?
>>>>>>>
>>>>>>> What indeed.  I think this is pretty much the only reply that
>>>>>>> should be
>>>>>>> made to PO.  He may, one day, admit that that was wrong and start to
>>>>>>> build a new waffle mountain, but until then, its game over.
>>>>>>>
>>>>>>>> Seems that all cranks are more or less "the same" (in a certain
>>>>>>>> sense): WM, PO, JG, AP, etc.
>>>>>>>
>>>>>>> In some way yes, but they all disagree with each other when the
>>>>>>> surface
>>>>>>> is scratched because they all want to be the unique individual who as
>>>>>>> seen clearly where everyone else was blind.  I would not be
>>>>>>> surprised if
>>>>>>> they all had NPD.
>>>>>>>
>>>>>>>> See:
>>>>>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>>>>>
>>>>>>> Possibly literally!
>>>>>>>
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>     int Halt_Status = H(x, x);
>>>>>>     if (Halt_Status)
>>>>>>       HERE: goto HERE;
>>>>>>     return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     Output("Input_Halts = ", H(D,D));
>>>>>>     Output("Input_Halts = ", D(D));
>>>>>> }
>>>>>>
>>>>>> None-the-less Ben will not lie about:
>>>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>>>> *H correctly predicts that D correctly simulated by H would never halt*
>>>>>
>>>>> In other words because Ben is not a liar he implicitly affirms that
>>>>> H(D,D) does correctly compute the mapping from its input to its reject
>>>>> state on the above basis.
>>>>>
>>>>
>>>> There are all kinds of way to weasel word around the above two verified
>>>> facts that will fool the gullible.
>>>>
>>>> *None-the-less this verified fact remains irrefutable*
>>>>
>>>> H(D,D) does correctly compute the mapping from its input to its reject
>>>> state on the basis that H correctly predicts that D correctly simulated
>>>> by H would never halt.
>>>
>>> *Finally a most important key point of agreement*
*Now that I have agreement that the following is a verified fact it*
*becomes much more efficient for others to accurately evaluate my work*

*It is a verified fact that* H(D,D) does correctly compute the mapping
from its input to its reject state on the basis that H correctly
predicts that D correctly simulated by H would never halt (reach its own
"return" statement and terminate normally).

The above paragraph sums up the entire essence the many thousands of
hours of work since 2004. I also show how to apply this to the Peter
Linz (Turing machine based proof in this paper.

*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem 



-- 
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

#3657

On 2/16/23 11:59 AM, olcott wrote:
> On 2/16/2023 8:44 AM, Don Stockbauer wrote:
>> On Wednesday, February 15, 2023 at 9:42:17 PM UTC-6, Richard Damon wrote:
>>> On 2/15/23 10:28 PM, olcott wrote:
>>>> On 2/15/2023 9:15 PM, olcott wrote:
>>>>> On 2/15/2023 8:39 PM, olcott wrote:
>>>>>> On 2/15/2023 8:22 PM, olcott wrote:
>>>>>>> On 2/15/2023 7:47 PM, Ben Bacarisse wrote:
>>>>>>>> Fritz Feldhase <franz.fri...@gmail.com> writes:
>>>>>>>>
>>>>>>>>> On Wednesday, February 15, 2023 at 10:32:19 PM UTC+1, Ben
>>>>>>>>> Bacarisse wrote:
>>>>>>>>>
>>>>>>>>>> Me: do you still assert that H(P,P) == false is the "correct" 
>>>>>>>>>> answer
>>>>>>>>>> even though P(P) halts?
>>>>>>>>>>
>>>>>>>>>> PO: Yes that is the correct answer even though P(P) halts.
>>>>>>>>>
>>>>>>>>> Wow!
>>>>>>>>>
>>>>>>>>> So for PO H is a "correct halt decider" even if it states that a
>>>>>>>>> program P with input P _doesn't halt_, though it _halts_.
>>>>>>>>>
>>>>>>>>> Well, what can I say?
>>>>>>>>
>>>>>>>> What indeed.  I think this is pretty much the only reply that
>>>>>>>> should be
>>>>>>>> made to PO.  He may, one day, admit that that was wrong and 
>>>>>>>> start to
>>>>>>>> build a new waffle mountain, but until then, its game over.
>>>>>>>>
>>>>>>>>> Seems that all cranks are more or less "the same" (in a certain
>>>>>>>>> sense): WM, PO, JG, AP, etc.
>>>>>>>>
>>>>>>>> In some way yes, but they all disagree with each other when the
>>>>>>>> surface
>>>>>>>> is scratched because they all want to be the unique individual 
>>>>>>>> who as
>>>>>>>> seen clearly where everyone else was blind.  I would not be
>>>>>>>> surprised if
>>>>>>>> they all had NPD.
>>>>>>>>
>>>>>>>>> See:
>>>>>>>>> https://context.reverso.net/%C3%BCbersetzung/spanisch-englisch/loco%2C+loco
>>>>>>>>
>>>>>>>> Possibly literally!
>>>>>>>>
>>>>>>>
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>     int Halt_Status = H(x, x);
>>>>>>>     if (Halt_Status)
>>>>>>>       HERE: goto HERE;
>>>>>>>     return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>     Output("Input_Halts = ", H(D,D));
>>>>>>>     Output("Input_Halts = ", D(D));
>>>>>>> }
>>>>>>>
>>>>>>> None-the-less Ben will not lie about:
>>>>>>> *H correctly predicts that D correctly simulated by H would never 
>>>>>>> halt*
>>>>>>> *H correctly predicts that D correctly simulated by H would never 
>>>>>>> halt*
>>>>>>> *H correctly predicts that D correctly simulated by H would never 
>>>>>>> halt*
>>>>>>
>>>>>> In other words because Ben is not a liar he implicitly affirms that
>>>>>> H(D,D) does correctly compute the mapping from its input to its 
>>>>>> reject
>>>>>> state on the above basis.
>>>>>>
>>>>>
>>>>> There are all kinds of way to weasel word around the above two 
>>>>> verified
>>>>> facts that will fool the gullible.
>>>>>
>>>>> *None-the-less this verified fact remains irrefutable*
>>>>>
>>>>> H(D,D) does correctly compute the mapping from its input to its reject
>>>>> state on the basis that H correctly predicts that D correctly 
>>>>> simulated
>>>>> by H would never halt.
>>>>
>>>> *Finally a most important key point of agreement*
> *Now that I have agreement that the following is a verified fact it*
> *becomes much more efficient for others to accurately evaluate my work*
> 
> *It is a verified fact that* H(D,D) does correctly compute the mapping
> from its input to its reject state on the basis that H correctly
> predicts that D correctly simulated by H would never halt (reach its own
> "return" statement and terminate normally).
> 
> The above paragraph sums up the entire essence the many thousands of
> hours of work since 2004. I also show how to apply this to the Peter
> Linz (Turing machine based proof in this paper.
> 
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
> 
> 

So, all you have done is proved that you aren't actualy working on a 
Halt Decider, as the definiton of a Halt decider is "In computability 
theory, the halting problem is the problem of determining, from a 
description of an arbitrary computer program and an input, whether the 
program will finish running, or continue to run forever. "


Since that isn't the problem you are working on. you are just shown to 
be LYING about working on it.

It is clear that you aren't working on the Halting Problem because you 
have ADMITTED that even though P(P) will Halt, H(P,P) is correct to say 
its input is non-halting, thus it can't be the halt decider of 
computability theory.

PERIOD.

Thus, all your words are show to just be LIES.

[toc] | [prev] | [standalone]

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

csiph-web