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

Groups > comp.theory > #58791 > unrolled thread

MIT Professor Michael Sipser validates the notion of a simulating halt decider V2

Back to article view | Back to comp.theory

Contents

  MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 olcott <polcott2@gmail.com> - 2022-10-16 10:16 -0500
    Re: MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-10-16 16:37 +0100
      Re: MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 olcott <none-ya@beez-waxes.com> - 2022-10-16 10:44 -0500
    Re: MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 Richard Damon <Richard@Damon-Family.org> - 2022-10-16 12:58 -0400
      Re: MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 olcott <polcott2@gmail.com> - 2022-10-16 12:15 -0500
        Re: MIT Professor Michael Sipser validates the notion of a simulating halt decider V2 Richard Damon <Richard@Damon-Family.org> - 2022-10-16 13:54 -0400
    Re: Richard does not have a clue olcott <polcott2@gmail.com> - 2022-10-16 20:29 -0500
      Re: Richard does not have a clue olcott <none-ya@beez-waxes.com> - 2022-10-16 20:36 -0500
        Re: No one is dumber than Richard olcott <polcott2@gmail.com> - 2022-10-16 20:37 -0500
        Re: Peter Olcott does not have a clue Richard Damon <Richard@Damon-Family.org> - 2022-10-16 21:50 -0400
          Re: Richard is as dumb as dumb gets olcott <polcott2@gmail.com> - 2022-10-16 20:53 -0500
            Re: Peter Olcot is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-16 22:13 -0400
      Re: Peter Olcott does not have a clue Richard Damon <Richard@Damon-Family.org> - 2022-10-16 21:48 -0400
    Re: Richard is as dumb as dumb gets olcott <polcott2@gmail.com> - 2022-10-16 20:41 -0500
      Re: Richard is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-16 21:51 -0400
        Re: Richard is as dumb as dumb gets olcott <polcott2@gmail.com> - 2022-10-16 20:55 -0500
          Re: Peter Olcott is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-16 22:11 -0400
            Re: Richard is as dumb as dumb gets olcott <polcott2@gmail.com> - 2022-10-16 21:31 -0500
              Re: Richard is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-16 22:50 -0400
                Re: Richard is as dumb as dumb gets olcott <polcott2@gmail.com> - 2022-10-16 22:18 -0500
                  Re: Richard is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-17 07:02 -0400
                    Re: Richard is as dumb as dumb gets olcott <none-ya@beez-waxes.com> - 2022-10-17 09:50 -0500
                      Re: Richard is as dumb as dumb gets Richard Damon <Richard@Damon-Family.org> - 2022-10-17 18:39 -0400

Page 1 of 2  [1] 2  Next page →

#58791 — MIT Professor Michael Sipser validates the notion of a simulating halt decider V2

<Sipser approved abstract>
MIT Professor Michael Sipser has agreed that the following verbatim 
paragraph is correct (he has not agreed to anything else in this paper):

If simulating halt decider H correctly simulates its input D until H 
correctly determines that its simulated D would never stop running 
unless aborted then H can abort its simulation of D and correctly report 
that D specifies a non-halting sequence of configurations.
</Sipser approved abstract>

to this paper:

*Rebutting the Sipser Halting Problem Proof*
https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof

The proof that the simulation of D by H is correct and that this 
correctly simulated D would never stop running unless aborted is on page 
3 of the above paper. People that fail to comprehend the technical 
details of page 3 are unqualified to assess the correctness of page 3.

The technical prerequisites for page 3 are expert knowledge of the C 
programming language, knowledge of x86 assembly language and how the C 
calling conventions are implemented in x86 assembly language.

Page 4 shows the application of a simulating halt decider to the Peter 
Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
copy of Linz H contained within Linz Ĥ is correctly construed as 
specifying non-halting sequence of configurations.

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

[toc] | [next] | [standalone]

#58794

On Sun, 16 Oct 2022 10:16:48 -0500
olcott <polcott2@gmail.com> wrote:

> <Sipser approved abstract>
> MIT Professor Michael Sipser has agreed that the following verbatim 
> paragraph is correct (he has not agreed to anything else in this
> paper):
> 
> If simulating halt decider H correctly simulates its input D until H 
> correctly determines that its simulated D would never stop running 
> unless aborted then H can abort its simulation of D and correctly
> report that D specifies a non-halting sequence of configurations.
> </Sipser approved abstract>
> 
> to this paper:
> 
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
> 
> The proof that the simulation of D by H is correct and that this 
> correctly simulated D would never stop running unless aborted is on
> page 3 of the above paper. People that fail to comprehend the
> technical details of page 3 are unqualified to assess the correctness
> of page 3.
> 
> The technical prerequisites for page 3 are expert knowledge of the C 
> programming language, knowledge of x86 assembly language and how the
> C calling conventions are implemented in x86 assembly language.
> 
> Page 4 shows the application of a simulating halt decider to the
> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the
> embedded copy of Linz H contained within Linz Ĥ is correctly
> construed as specifying non-halting sequence of configurations.

You have been told multiple times now that you are not doing a correct
simulation of D so it doesn't matter what Sipser says.

The correct simulation of D by H is D behaving as if there was a
direction execution of D(D).

/Flibble 

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

#58795

On 10/16/2022 10:37 AM, Mr Flibble wrote:
> On Sun, 16 Oct 2022 10:16:48 -0500
> olcott <polcott2@gmail.com> wrote:
> 
>> <Sipser approved abstract>
>> MIT Professor Michael Sipser has agreed that the following verbatim
>> paragraph is correct (he has not agreed to anything else in this
>> paper):
>>
>> If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D would never stop running
>> unless aborted then H can abort its simulation of D and correctly
>> report that D specifies a non-halting sequence of configurations.
>> </Sipser approved abstract>
>>
>> to this paper:
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>> The proof that the simulation of D by H is correct and that this
>> correctly simulated D would never stop running unless aborted is on
>> page 3 of the above paper. People that fail to comprehend the
>> technical details of page 3 are unqualified to assess the correctness
>> of page 3.
>>
>> The technical prerequisites for page 3 are expert knowledge of the C
>> programming language, knowledge of x86 assembly language and how the
>> C calling conventions are implemented in x86 assembly language.
>>
>> Page 4 shows the application of a simulating halt decider to the
>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the
>> embedded copy of Linz H contained within Linz Ĥ is correctly
>> construed as specifying non-halting sequence of configurations.
> 
> You have been told multiple times now that you are not doing a correct
> simulation of D 

By people not having the technical competence (see above technical 
prerequisites) to verify that this simulation is correct.

-- 
Copyright 2022 Pete 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]

#58804

On 10/16/22 11:16 AM, olcott wrote:
> <Sipser approved abstract>
> MIT Professor Michael Sipser has agreed that the following verbatim 
> paragraph is correct (he has not agreed to anything else in this paper):
> 
> If simulating halt decider H correctly simulates its input D until H 
> correctly determines that its simulated D would never stop running 
> unless aborted then H can abort its simulation of D and correctly report 
> that D specifies a non-halting sequence of configurations.
> </Sipser approved abstract>
> 
> to this paper:
> 
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
> 
> The proof that the simulation of D by H is correct and that this 
> correctly simulated D would never stop running unless aborted is on page 
> 3 of the above paper. People that fail to comprehend the technical 
> details of page 3 are unqualified to assess the correctness of page 3.
> 
> The technical prerequisites for page 3 are expert knowledge of the C 
> programming language, knowledge of x86 assembly language and how the C 
> calling conventions are implemented in x86 assembly language.
> 
> Page 4 shows the application of a simulating halt decider to the Peter 
> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
> copy of Linz H contained within Linz Ĥ is correctly construed as 
> specifying non-halting sequence of configurations.
> 

You logic is incorrect as heen pointed out many times.

Your "Simulaiton" never actually simulates the whole program, but stops 
as soon as D calls H, and then you apply a wrong definition of H to 
reach an invalid conclusion.

The prerequisits to understand that page are NOT and expert knowlede for 
the C programing languge, x86 assembly, and ho C calling conventison are 
implemented (of which I have all), but a basic understanding of how 
computaters work, which it seems you lack.

Since we KNOW at the end of the analysis that your H WILL abort it 
simulation nd return 0, since that is what it has been programmed to do, 
we know that this call to H WILL return 0 and thus D will get that value 
and return 1.

I is clear that you don't understand that computers always do what they 
have been instructed to do (unless there is a hardware failuer) and 
programs are sequences of machine instructions that define what the 
program will do as definitive steps.

Programs do not operate on the concept of "Would Have" but only what is. 
To figure out "Would Have" need skill by the programmer to correctly 
predict what would have happened.

Since D is built on the H that does abort and return 0, since that is 
the program that is claimed to be right, we KNOW that is the behavior of 
a correct simulation of D. You logic replaces looking at this actual 
input with the non-input of a H that doesn't abort at all and the D 
built on it, a program that isn't in existance in the case that we are 
actually looking at.

It is clear from you arguments that UNO was correct to not give you a CS 
degree, as you clearly don't have the basic knowledge of Computer Science.

You do seem very much like the Buisness Major that THINKS they know 
something about computers, but don't.

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

#58806

On 10/16/2022 11:58 AM, Richard Damon wrote:
> On 10/16/22 11:16 AM, olcott wrote:
>> <Sipser approved abstract>
>> MIT Professor Michael Sipser has agreed that the following verbatim 
>> paragraph is correct (he has not agreed to anything else in this paper):
>>
>> If simulating halt decider H correctly simulates its input D until H 
>> correctly determines that its simulated D would never stop running 
>> unless aborted then H can abort its simulation of D and correctly 
>> report that D specifies a non-halting sequence of configurations.
>> </Sipser approved abstract>
>>
>> to this paper:
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>> The proof that the simulation of D by H is correct and that this 
>> correctly simulated D would never stop running unless aborted is on 
>> page 3 of the above paper. People that fail to comprehend the 
>> technical details of page 3 are unqualified to assess the correctness 
>> of page 3.
>>
>> The technical prerequisites for page 3 are expert knowledge of the C 
>> programming language, knowledge of x86 assembly language and how the C 
>> calling conventions are implemented in x86 assembly language.
>>
>> Page 4 shows the application of a simulating halt decider to the Peter 
>> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
>> copy of Linz H contained within Linz Ĥ is correctly construed as 
>> specifying non-halting sequence of configurations.
>>
> 
> You logic is incorrect as heen pointed out many times.
> 
Like I said my reasoning on page 3 only applies to people having 
sufficient technical competence (apparently not you).

Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[000012ae][00111f94][00111f98] 55         push ebp      // Begin Sipser_D
[000012af][00111f94][00111f98] 8bec       mov ebp,esp
[000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
[000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
[000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
[000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
[000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped

We can see that the first seven instructions of Sipser_D simulated by 
Sipser_H precisely match the first seven instructions of the x86 
source-code of Sipser_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 Sipser_D simulated 
by Sipser_H shows that Sipser_D will never stop running unless Sipser_H 
aborts its simulation of Sipser_D.




-- 
Copyright 2022 Pete 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]

#58814

On 10/16/22 1:15 PM, olcott wrote:
> On 10/16/2022 11:58 AM, Richard Damon wrote:
>> On 10/16/22 11:16 AM, olcott wrote:
>>> <Sipser approved abstract>
>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>> paragraph is correct (he has not agreed to anything else in this paper):
>>>
>>> If simulating halt decider H correctly simulates its input D until H 
>>> correctly determines that its simulated D would never stop running 
>>> unless aborted then H can abort its simulation of D and correctly 
>>> report that D specifies a non-halting sequence of configurations.
>>> </Sipser approved abstract>
>>>
>>> to this paper:
>>>
>>> *Rebutting the Sipser Halting Problem Proof*
>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>
>>> The proof that the simulation of D by H is correct and that this 
>>> correctly simulated D would never stop running unless aborted is on 
>>> page 3 of the above paper. People that fail to comprehend the 
>>> technical details of page 3 are unqualified to assess the correctness 
>>> of page 3.
>>>
>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>> programming language, knowledge of x86 assembly language and how the 
>>> C calling conventions are implemented in x86 assembly language.
>>>
>>> Page 4 shows the application of a simulating halt decider to the 
>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>> construed as specifying non-halting sequence of configurations.
>>>
>>
>> You logic is incorrect as heen pointed out many times.
>>
> Like I said my reasoning on page 3 only applies to people having 
> sufficient technical competence (apparently not you).

WHich is a false claim.

There is nothing in the arguement that actually requires that.

The fact that you mention it almost implies that you don't really have 
the expertise to understand what you are talking about.

> 
> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [000012ae][00111f94][00111f98] 55         push ebp      // Begin Sipser_D
> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
> 
> We can see that the first seven instructions of Sipser_D simulated by 
> Sipser_H precisely match the first seven instructions of the x86 
> source-code of Sipser_D. This conclusively proves that these 
> instructions were simulated correctly.

Right, so it is a correct PARTIAL simulation.

> 
> Anyone sufficiently technically competent in the x86 programming 
> language will agree that the above execution trace of Sipser_D simulated 
> by Sipser_H shows that Sipser_D will never stop running unless Sipser_H 
> aborts its simulation of Sipser_D.
> 
> 

Not in the sense required by the problem.

Since the Sipser_H being called WILL abort it simulation of the next 
level of procesing of simulating another copy of Sipser_D, and return 0, 
it is clear that the current simulating Sipser_H doesn't NEED to abort 
the simulation to keep if from being non-halting, it only needs to abort 
is as that is the code it contains.

By your logic EVERY loop is non-halting, because it only stops because 
it decides to stop.

You are just showing your total lack of understanding of the topic.

The fact that you only "rebuttal" is to just repeat your falsehood and 
claim that I "obviously" don't understand what you are saying, is 
showing that what you are saying doesn't actually have a factual basis 
to work on.

Factual statements generally can be reduced to simpler more basic terms 
until you reach things so elementary they are of the form that are 
generally accepted as true by the wide audience.

FALSEHOOD resist this treatment, as breaking them down to simpler terms 
just reveals the falsehood more directly.

You inability to reduce your arguement a level says that it isn't based 
on real truth, but lies. (Or at least you don't understand the truth 
behind it, but since it is shown wrong, that isn't the case).

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

#58838 — Re: Richard does not have a clue

On 10/16/2022 10:16 AM, olcott wrote:
> <Sipser approved abstract>
> MIT Professor Michael Sipser has agreed that the following verbatim 
> paragraph is correct (he has not agreed to anything else in this paper):
> 
> If simulating halt decider H correctly simulates its input D until H 
> correctly determines that its simulated D would never stop running 
> unless aborted then H can abort its simulation of D and correctly report 
> that D specifies a non-halting sequence of configurations.
> </Sipser approved abstract>
> 
> to this paper:
> 
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
> 
> The proof that the simulation of D by H is correct and that this 
> correctly simulated D would never stop running unless aborted is on page 
> 3 of the above paper. People that fail to comprehend the technical 
> details of page 3 are unqualified to assess the correctness of page 3.
> 
> The technical prerequisites for page 3 are expert knowledge of the C 
> programming language, knowledge of x86 assembly language and how the C 
> calling conventions are implemented in x86 assembly language.
> 
> Page 4 shows the application of a simulating halt decider to the Peter 
> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
> copy of Linz H contained within Linz Ĥ is correctly construed as 
> specifying non-halting sequence of configurations.
> 


The D called "independently" (from main) is dependent on the return 
value from H.

The D called "dependently" (from H) is NOT dependent on the return value 
from H.

*Anyone that is not dumber than a box of rocks can see D would*
*call H to simulate itself again and not stop until H stopped it*

Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
[000012af][00111f94][00111f98] 8bec       mov ebp,esp
[000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
[000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
[000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
[000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
[000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped


-- 
Copyright 2022 Pete 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]

#58840 — Re: Richard does not have a clue

On 10/16/2022 8:29 PM, olcott wrote:
> On 10/16/2022 10:16 AM, olcott wrote:
>> <Sipser approved abstract>
>> MIT Professor Michael Sipser has agreed that the following verbatim 
>> paragraph is correct (he has not agreed to anything else in this paper):
>>
>> If simulating halt decider H correctly simulates its input D until H 
>> correctly determines that its simulated D would never stop running 
>> unless aborted then H can abort its simulation of D and correctly 
>> report that D specifies a non-halting sequence of configurations.
>> </Sipser approved abstract>
>>
>> to this paper:
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>> The proof that the simulation of D by H is correct and that this 
>> correctly simulated D would never stop running unless aborted is on 
>> page 3 of the above paper. People that fail to comprehend the 
>> technical details of page 3 are unqualified to assess the correctness 
>> of page 3.
>>
>> The technical prerequisites for page 3 are expert knowledge of the C 
>> programming language, knowledge of x86 assembly language and how the C 
>> calling conventions are implemented in x86 assembly language.
>>
>> Page 4 shows the application of a simulating halt decider to the Peter 
>> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
>> copy of Linz H contained within Linz Ĥ is correctly construed as 
>> specifying non-halting sequence of configurations.
>>
> 
> 
> The D called "independently" (from main) is dependent on the return 
> value from H.
> 
> The D called "dependently" (from H) is NOT dependent on the return value 
> from H.
> 
> *Anyone that is not dumber than a box of rocks can see D would*
> *call H to simulate itself again and not stop until H stopped it*
> 
> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped

// Richard is too dumb to see this
If (H never stops D)
   D keeps repeating


-- 
Copyright 2022 Pete 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]

#58841 — Re: No one is dumber than Richard

On 10/16/2022 8:36 PM, olcott wrote:
> On 10/16/2022 8:29 PM, olcott wrote:
>> On 10/16/2022 10:16 AM, olcott wrote:
>>> <Sipser approved abstract>
>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>> paragraph is correct (he has not agreed to anything else in this paper):
>>>
>>> If simulating halt decider H correctly simulates its input D until H 
>>> correctly determines that its simulated D would never stop running 
>>> unless aborted then H can abort its simulation of D and correctly 
>>> report that D specifies a non-halting sequence of configurations.
>>> </Sipser approved abstract>
>>>
>>> to this paper:
>>>
>>> *Rebutting the Sipser Halting Problem Proof*
>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>
>>> The proof that the simulation of D by H is correct and that this 
>>> correctly simulated D would never stop running unless aborted is on 
>>> page 3 of the above paper. People that fail to comprehend the 
>>> technical details of page 3 are unqualified to assess the correctness 
>>> of page 3.
>>>
>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>> programming language, knowledge of x86 assembly language and how the 
>>> C calling conventions are implemented in x86 assembly language.
>>>
>>> Page 4 shows the application of a simulating halt decider to the 
>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>> construed as specifying non-halting sequence of configurations.
>>>
>>
>>
>> The D called "independently" (from main) is dependent on the return 
>> value from H.
>>
>> The D called "dependently" (from H) is NOT dependent on the return 
>> value from H.
>>
>> *Anyone that is not dumber than a box of rocks can see D would*
>> *call H to simulate itself again and not stop until H stopped it*
>>
>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
> 
> // Richard is too dumb to see this
> If (H never stops D)
>    D keeps repeating
> 
> 

-- 
Copyright 2022 Pete 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]

#58844 — Re: Peter Olcott does not have a clue

On 10/16/22 9:36 PM, olcott wrote:
> On 10/16/2022 8:29 PM, olcott wrote:
>> On 10/16/2022 10:16 AM, olcott wrote:
>>> <Sipser approved abstract>
>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>> paragraph is correct (he has not agreed to anything else in this paper):
>>>
>>> If simulating halt decider H correctly simulates its input D until H 
>>> correctly determines that its simulated D would never stop running 
>>> unless aborted then H can abort its simulation of D and correctly 
>>> report that D specifies a non-halting sequence of configurations.
>>> </Sipser approved abstract>
>>>
>>> to this paper:
>>>
>>> *Rebutting the Sipser Halting Problem Proof*
>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>
>>> The proof that the simulation of D by H is correct and that this 
>>> correctly simulated D would never stop running unless aborted is on 
>>> page 3 of the above paper. People that fail to comprehend the 
>>> technical details of page 3 are unqualified to assess the correctness 
>>> of page 3.
>>>
>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>> programming language, knowledge of x86 assembly language and how the 
>>> C calling conventions are implemented in x86 assembly language.
>>>
>>> Page 4 shows the application of a simulating halt decider to the 
>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>> construed as specifying non-halting sequence of configurations.
>>>
>>
>>
>> The D called "independently" (from main) is dependent on the return 
>> value from H.
>>
>> The D called "dependently" (from H) is NOT dependent on the return 
>> value from H.
>>
>> *Anyone that is not dumber than a box of rocks can see D would*
>> *call H to simulate itself again and not stop until H stopped it*
>>
>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
> 
> // Richard is too dumb to see this
> If (H never stops D)
>    D keeps repeating
> 
> 

But that isn't the question, and H DOES stop, so it doesn't matter.

You are just proving your stupidity.

Please show a credible reference for you criteria, failure is evidence 
that you are just making it up.

YOU HAVE FAILED.

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

#58848 — Re: Richard is as dumb as dumb gets

On 10/16/2022 8:50 PM, Richard Damon wrote:
> On 10/16/22 9:36 PM, olcott wrote:
>> On 10/16/2022 8:29 PM, olcott wrote:
>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>> <Sipser approved abstract>
>>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>>> paragraph is correct (he has not agreed to anything else in this 
>>>> paper):
>>>>
>>>> If simulating halt decider H correctly simulates its input D until H 
>>>> correctly determines that its simulated D would never stop running 
>>>> unless aborted then H can abort its simulation of D and correctly 
>>>> report that D specifies a non-halting sequence of configurations.
>>>> </Sipser approved abstract>
>>>>
>>>> to this paper:
>>>>
>>>> *Rebutting the Sipser Halting Problem Proof*
>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>
>>>> The proof that the simulation of D by H is correct and that this 
>>>> correctly simulated D would never stop running unless aborted is on 
>>>> page 3 of the above paper. People that fail to comprehend the 
>>>> technical details of page 3 are unqualified to assess the 
>>>> correctness of page 3.
>>>>
>>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>>> programming language, knowledge of x86 assembly language and how the 
>>>> C calling conventions are implemented in x86 assembly language.
>>>>
>>>> Page 4 shows the application of a simulating halt decider to the 
>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>> construed as specifying non-halting sequence of configurations.
>>>>
>>>
>>>
>>> The D called "independently" (from main) is dependent on the return 
>>> value from H.
>>>
>>> The D called "dependently" (from H) is NOT dependent on the return 
>>> value from H.
>>>
>>> *Anyone that is not dumber than a box of rocks can see D would*
>>> *call H to simulate itself again and not stop until H stopped it*
>>>
>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> // Richard is too dumb to see this
>> If (H never stops D)
>>    D keeps repeating
>>
>>
> 
> But that isn't the question, and H DOES stop, so it doesn't matter.
> 

It is the question that H is correctly answering and you are just too 
dumb to see this.


-- 
Copyright 2022 Pete 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]

#58852 — Re: Peter Olcot is as dumb as dumb gets

On 10/16/22 9:53 PM, olcott wrote:
> On 10/16/2022 8:50 PM, Richard Damon wrote:
>> On 10/16/22 9:36 PM, olcott wrote:
>>> On 10/16/2022 8:29 PM, olcott wrote:
>>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>>> <Sipser approved abstract>
>>>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>>>> paragraph is correct (he has not agreed to anything else in this 
>>>>> paper):
>>>>>
>>>>> If simulating halt decider H correctly simulates its input D until 
>>>>> H correctly determines that its simulated D would never stop 
>>>>> running unless aborted then H can abort its simulation of D and 
>>>>> correctly report that D specifies a non-halting sequence of 
>>>>> configurations.
>>>>> </Sipser approved abstract>
>>>>>
>>>>> to this paper:
>>>>>
>>>>> *Rebutting the Sipser Halting Problem Proof*
>>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>>
>>>>> The proof that the simulation of D by H is correct and that this 
>>>>> correctly simulated D would never stop running unless aborted is on 
>>>>> page 3 of the above paper. People that fail to comprehend the 
>>>>> technical details of page 3 are unqualified to assess the 
>>>>> correctness of page 3.
>>>>>
>>>>> The technical prerequisites for page 3 are expert knowledge of the 
>>>>> C programming language, knowledge of x86 assembly language and how 
>>>>> the C calling conventions are implemented in x86 assembly language.
>>>>>
>>>>> Page 4 shows the application of a simulating halt decider to the 
>>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>>> construed as specifying non-halting sequence of configurations.
>>>>>
>>>>
>>>>
>>>> The D called "independently" (from main) is dependent on the return 
>>>> value from H.
>>>>
>>>> The D called "dependently" (from H) is NOT dependent on the return 
>>>> value from H.
>>>>
>>>> *Anyone that is not dumber than a box of rocks can see D would*
>>>> *call H to simulate itself again and not stop until H stopped it*
>>>>
>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin 
>>>> Sipser_D
>>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>>> [000012b4][00111f90][000012ae] 50         push eax      // push 
>>>> Sipser_D
>>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push 
>>>> Sipser_D
>>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call 
>>>> Sipser_H
>>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> // Richard is too dumb to see this
>>> If (H never stops D)
>>>    D keeps repeating
>>>
>>>
>>
>> But that isn't the question, and H DOES stop, so it doesn't matter.
>>
> 
> It is the question that H is correctly answering and you are just too 
> dumb to see this.
> 
> 

So you are admitting that you have been lying about working on the 
halting problem.

Since that isn't the question of the Halting problem, looks like you 
have wasted you last 18 years of life working on the wrong problem.

Shame to have wasted all that time due to ignorance.

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

#58843 — Re: Peter Olcott does not have a clue

On 10/16/22 9:29 PM, olcott wrote:
> On 10/16/2022 10:16 AM, olcott wrote:
>> <Sipser approved abstract>
>> MIT Professor Michael Sipser has agreed that the following verbatim 
>> paragraph is correct (he has not agreed to anything else in this paper):
>>
>> If simulating halt decider H correctly simulates its input D until H 
>> correctly determines that its simulated D would never stop running 
>> unless aborted then H can abort its simulation of D and correctly 
>> report that D specifies a non-halting sequence of configurations.
>> </Sipser approved abstract>
>>
>> to this paper:
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>> The proof that the simulation of D by H is correct and that this 
>> correctly simulated D would never stop running unless aborted is on 
>> page 3 of the above paper. People that fail to comprehend the 
>> technical details of page 3 are unqualified to assess the correctness 
>> of page 3.
>>
>> The technical prerequisites for page 3 are expert knowledge of the C 
>> programming language, knowledge of x86 assembly language and how the C 
>> calling conventions are implemented in x86 assembly language.
>>
>> Page 4 shows the application of a simulating halt decider to the Peter 
>> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
>> copy of Linz H contained within Linz Ĥ is correctly construed as 
>> specifying non-halting sequence of configurations.
>>
> 
> 
> The D called "independently" (from main) is dependent on the return 
> value from H.
> 
> The D called "dependently" (from H) is NOT dependent on the return value 
> from H.

Why?

What instruction causees this difference.

Your failure to point that out indicates that you are just lying about it.

> 
> *Anyone that is not dumber than a box of rocks can see D would*
> *call H to simulate itself again and not stop until H stopped it*

But isn't H supposed to be a DECIDER? not an unconditional simulator.

I guess you have been lying all these years that you H is what it claims 
to be.

> 
> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
> 
> 

You are showing your self to be just a idiotic pathological liar.

You have destroyed any reputation you might have and buried it under 
your lies.

If you ever try to publish any of these papers, you better hope that 
they don't find these threads, or they will likely just trash can your 
submission and put you on the ignore list, as you have proved yourself 
to be so stupid.

You better find answers for these questions, as they WILL ask you about 
them, and citations for your sources for your claims, which you won't be 
able to get.

You have failed.

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

#58842 — Re: Richard is as dumb as dumb gets

On 10/16/2022 10:16 AM, olcott wrote:
> <Sipser approved abstract>
> MIT Professor Michael Sipser has agreed that the following verbatim 
> paragraph is correct (he has not agreed to anything else in this paper):
> 
> If simulating halt decider H correctly simulates its input D until H 
> correctly determines that its simulated D would never stop running 
> unless aborted then H can abort its simulation of D and correctly report 
> that D specifies a non-halting sequence of configurations.
> </Sipser approved abstract>
> 
> to this paper:
> 
> *Rebutting the Sipser Halting Problem Proof*
> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
> 
> The proof that the simulation of D by H is correct and that this 
> correctly simulated D would never stop running unless aborted is on page 
> 3 of the above paper. People that fail to comprehend the technical 
> details of page 3 are unqualified to assess the correctness of page 3.
> 
> The technical prerequisites for page 3 are expert knowledge of the C 
> programming language, knowledge of x86 assembly language and how the C 
> calling conventions are implemented in x86 assembly language.
> 
> Page 4 shows the application of a simulating halt decider to the Peter 
> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
> copy of Linz H contained within Linz Ĥ is correctly construed as 
> specifying non-halting sequence of configurations.
> 

Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
[000012af][00111f94][00111f98] 8bec       mov ebp,esp
[000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
[000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
[000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
[000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
[000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped

// Richard is too dumb to see this
If (H never stops D)
    D keeps repeating



-- 
Copyright 2022 Pete 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]

#58845 — Re: Richard is as dumb as dumb gets

On 10/16/22 9:41 PM, olcott wrote:
> On 10/16/2022 10:16 AM, olcott wrote:
>> <Sipser approved abstract>
>> MIT Professor Michael Sipser has agreed that the following verbatim 
>> paragraph is correct (he has not agreed to anything else in this paper):
>>
>> If simulating halt decider H correctly simulates its input D until H 
>> correctly determines that its simulated D would never stop running 
>> unless aborted then H can abort its simulation of D and correctly 
>> report that D specifies a non-halting sequence of configurations.
>> </Sipser approved abstract>
>>
>> to this paper:
>>
>> *Rebutting the Sipser Halting Problem Proof*
>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>
>> The proof that the simulation of D by H is correct and that this 
>> correctly simulated D would never stop running unless aborted is on 
>> page 3 of the above paper. People that fail to comprehend the 
>> technical details of page 3 are unqualified to assess the correctness 
>> of page 3.
>>
>> The technical prerequisites for page 3 are expert knowledge of the C 
>> programming language, knowledge of x86 assembly language and how the C 
>> calling conventions are implemented in x86 assembly language.
>>
>> Page 4 shows the application of a simulating halt decider to the Peter 
>> Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the embedded 
>> copy of Linz H contained within Linz Ĥ is correctly construed as 
>> specifying non-halting sequence of configurations.
>>
> 
> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>   machine   stack     stack     machine    assembly
>   address   address   data      code       language
>   ========  ========  ========  =========  =============
> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
> 
> // Richard is too dumb to see this
> If (H never stops D)
>     D keeps repeating
> 
> 
> 
But that isn't the question, and H DOES stop, so it doesn't matter.

Just proves you have been lying about actually working on the Halting 
Problem.

You are just proving your stupidity.

Please show a credible reference for you criteria, failure is evidence 
that you are just making it up.

YOU HAVE FAILED.

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

#58850 — Re: Richard is as dumb as dumb gets

On 10/16/2022 8:51 PM, Richard Damon wrote:
> On 10/16/22 9:41 PM, olcott wrote:
>> On 10/16/2022 10:16 AM, olcott wrote:
>>> <Sipser approved abstract>
>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>> paragraph is correct (he has not agreed to anything else in this paper):
>>>
>>> If simulating halt decider H correctly simulates its input D until H 
>>> correctly determines that its simulated D would never stop running 
>>> unless aborted then H can abort its simulation of D and correctly 
>>> report that D specifies a non-halting sequence of configurations.
>>> </Sipser approved abstract>
>>>
>>> to this paper:
>>>
>>> *Rebutting the Sipser Halting Problem Proof*
>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>
>>> The proof that the simulation of D by H is correct and that this 
>>> correctly simulated D would never stop running unless aborted is on 
>>> page 3 of the above paper. People that fail to comprehend the 
>>> technical details of page 3 are unqualified to assess the correctness 
>>> of page 3.
>>>
>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>> programming language, knowledge of x86 assembly language and how the 
>>> C calling conventions are implemented in x86 assembly language.
>>>
>>> Page 4 shows the application of a simulating halt decider to the 
>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>> construed as specifying non-halting sequence of configurations.
>>>
>>
>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> // Richard is too dumb to see this
>> If (H never stops D)
>>     D keeps repeating
>>
>>
>>
> But that isn't the question, and H DOES stop, so it doesn't matter.
> 
It is the question that H is correctly answering and you are just too 
dumb to see this.

-- 
Copyright 2022 Pete 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]

#58851 — Re: Peter Olcott is as dumb as dumb gets

On 10/16/22 9:55 PM, olcott wrote:
> On 10/16/2022 8:51 PM, Richard Damon wrote:
>> On 10/16/22 9:41 PM, olcott wrote:
>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>> <Sipser approved abstract>
>>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>>> paragraph is correct (he has not agreed to anything else in this 
>>>> paper):
>>>>
>>>> If simulating halt decider H correctly simulates its input D until H 
>>>> correctly determines that its simulated D would never stop running 
>>>> unless aborted then H can abort its simulation of D and correctly 
>>>> report that D specifies a non-halting sequence of configurations.
>>>> </Sipser approved abstract>
>>>>
>>>> to this paper:
>>>>
>>>> *Rebutting the Sipser Halting Problem Proof*
>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>
>>>> The proof that the simulation of D by H is correct and that this 
>>>> correctly simulated D would never stop running unless aborted is on 
>>>> page 3 of the above paper. People that fail to comprehend the 
>>>> technical details of page 3 are unqualified to assess the 
>>>> correctness of page 3.
>>>>
>>>> The technical prerequisites for page 3 are expert knowledge of the C 
>>>> programming language, knowledge of x86 assembly language and how the 
>>>> C calling conventions are implemented in x86 assembly language.
>>>>
>>>> Page 4 shows the application of a simulating halt decider to the 
>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>> construed as specifying non-halting sequence of configurations.
>>>>
>>>
>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin Sipser_D
>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>> [000012b4][00111f90][000012ae] 50         push eax      // push Sipser_D
>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push Sipser_D
>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call Sipser_H
>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> // Richard is too dumb to see this
>>> If (H never stops D)
>>>     D keeps repeating
>>>
>>>
>>>
>> But that isn't the question, and H DOES stop, so it doesn't matter.
>>
> It is the question that H is correctly answering and you are just too 
> dumb to see this.
> 

So you admit you aren't doing the Halting Problem  Because that isn't 
the question of the Halting Problem.

Or are you too ignorant of the problem you have been working on for 18 
years.

Lots of time to waste by not knowing the question you are supposed to be 
answering.

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

#58853 — Re: Richard is as dumb as dumb gets

On 10/16/2022 9:11 PM, Richard Damon wrote:
> On 10/16/22 9:55 PM, olcott wrote:
>> On 10/16/2022 8:51 PM, Richard Damon wrote:
>>> On 10/16/22 9:41 PM, olcott wrote:
>>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>>> <Sipser approved abstract>
>>>>> MIT Professor Michael Sipser has agreed that the following verbatim 
>>>>> paragraph is correct (he has not agreed to anything else in this 
>>>>> paper):
>>>>>
>>>>> If simulating halt decider H correctly simulates its input D until 
>>>>> H correctly determines that its simulated D would never stop 
>>>>> running unless aborted then H can abort its simulation of D and 
>>>>> correctly report that D specifies a non-halting sequence of 
>>>>> configurations.
>>>>> </Sipser approved abstract>
>>>>>
>>>>> to this paper:
>>>>>
>>>>> *Rebutting the Sipser Halting Problem Proof*
>>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>>
>>>>> The proof that the simulation of D by H is correct and that this 
>>>>> correctly simulated D would never stop running unless aborted is on 
>>>>> page 3 of the above paper. People that fail to comprehend the 
>>>>> technical details of page 3 are unqualified to assess the 
>>>>> correctness of page 3.
>>>>>
>>>>> The technical prerequisites for page 3 are expert knowledge of the 
>>>>> C programming language, knowledge of x86 assembly language and how 
>>>>> the C calling conventions are implemented in x86 assembly language.
>>>>>
>>>>> Page 4 shows the application of a simulating halt decider to the 
>>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to the 
>>>>> embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>>> construed as specifying non-halting sequence of configurations.
>>>>>
>>>>
>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin 
>>>> Sipser_D
>>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>>> [000012b4][00111f90][000012ae] 50         push eax      // push 
>>>> Sipser_D
>>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push 
>>>> Sipser_D
>>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call 
>>>> Sipser_H
>>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> // Richard is too dumb to see this
>>>> If (H never stops D)
>>>>     D keeps repeating
>>>>
>>>>
>>>>
>>> But that isn't the question, and H DOES stop, so it doesn't matter.
>>>
>> It is the question that H is correctly answering and you are just too 
>> dumb to see this.
>>
> 
> So you admit you aren't doing the Halting Problem  Because that isn't 
> the question of the Halting Problem.

As Professor Sipser agrees the halt status of D is correctly determined 
by the behavior of D simulated by H, and this D never halts even if it 
does stop running because its simulation was aborted.

-- 
Copyright 2022 Pete 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]

#58854 — Re: Richard is as dumb as dumb gets

On 10/16/22 10:31 PM, olcott wrote:
> On 10/16/2022 9:11 PM, Richard Damon wrote:
>> On 10/16/22 9:55 PM, olcott wrote:
>>> On 10/16/2022 8:51 PM, Richard Damon wrote:
>>>> On 10/16/22 9:41 PM, olcott wrote:
>>>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>>>> <Sipser approved abstract>
>>>>>> MIT Professor Michael Sipser has agreed that the following 
>>>>>> verbatim paragraph is correct (he has not agreed to anything else 
>>>>>> in this paper):
>>>>>>
>>>>>> If simulating halt decider H correctly simulates its input D until 
>>>>>> H correctly determines that its simulated D would never stop 
>>>>>> running unless aborted then H can abort its simulation of D and 
>>>>>> correctly report that D specifies a non-halting sequence of 
>>>>>> configurations.
>>>>>> </Sipser approved abstract>
>>>>>>
>>>>>> to this paper:
>>>>>>
>>>>>> *Rebutting the Sipser Halting Problem Proof*
>>>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>>>
>>>>>> The proof that the simulation of D by H is correct and that this 
>>>>>> correctly simulated D would never stop running unless aborted is 
>>>>>> on page 3 of the above paper. People that fail to comprehend the 
>>>>>> technical details of page 3 are unqualified to assess the 
>>>>>> correctness of page 3.
>>>>>>
>>>>>> The technical prerequisites for page 3 are expert knowledge of the 
>>>>>> C programming language, knowledge of x86 assembly language and how 
>>>>>> the C calling conventions are implemented in x86 assembly language.
>>>>>>
>>>>>> Page 4 shows the application of a simulating halt decider to the 
>>>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to 
>>>>>> the embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>>>> construed as specifying non-halting sequence of configurations.
>>>>>>
>>>>>
>>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin 
>>>>> Sipser_D
>>>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>>>> [000012b4][00111f90][000012ae] 50         push eax      // push 
>>>>> Sipser_D
>>>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push 
>>>>> Sipser_D
>>>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call 
>>>>> Sipser_H
>>>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>
>>>>> // Richard is too dumb to see this
>>>>> If (H never stops D)
>>>>>     D keeps repeating
>>>>>
>>>>>
>>>>>
>>>> But that isn't the question, and H DOES stop, so it doesn't matter.
>>>>
>>> It is the question that H is correctly answering and you are just too 
>>> dumb to see this.
>>>
>>
>> So you admit you aren't doing the Halting Problem  Because that isn't 
>> the question of the Halting Problem.
> 
> As Professor Sipser agrees the halt status of D is correctly determined 
> by the behavior of D simulated by H, and this D never halts even if it 
> does stop running because its simulation was aborted.
> 

No, he said that *IF* H did a correct simulation, and was able to 
*CORRECTLY* determine that the simulation would not stop, it can abort 
its simulation and return the non-halting value.

That means that the CORRECT simulation of THIS input must be non-halting.

The only machine that the correcrt simulation are non-halting are based 
on the H the DO NOT ABORT. A machie that does not abort, can not abort.

All the machine that are based on H's that DO abort, have CORRECT (and 
complete) simulations that reach a final state.

Thus, none of your H's are able to show that their correct simulation 
would never halt and be able to abort their simulation, because if H 
does abort, then the correct simulation of their input is Halting.

There is no looking at some other machine that doesn't abort like you 
are trying to do.

You are just showing that you don't understand what you are talking about.

H is a SPECIFIC machine with a SPECIFIC algorithm coded in it.

That algorithm will either abort is simulation of D, or it won't.

If it doesn't, then if fails by not answering. PERIOD.

If it does, if fails by giving the wrong answer, because the CORRECT 
SIMULATION of the input will halt. Since H DOES abort, it doesn't do a 
correct simulation, nor can it show that the correct simulation will not 
end, so it can not CORRECTLY abort its simulation, but it does anyway, 
as that is what it was programmed to do.

The is no "program step" that indicates "get the right answer", you need 
to develope an algorithm based on computable steps, that gets that answer.

The problem is that Halting isn't a computable function, so there is not 
sequence of computable steps to compute it.

YOU FAIL.

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

#58855 — Re: Richard is as dumb as dumb gets

On 10/16/2022 9:50 PM, Richard Damon wrote:
> On 10/16/22 10:31 PM, olcott wrote:
>> On 10/16/2022 9:11 PM, Richard Damon wrote:
>>> On 10/16/22 9:55 PM, olcott wrote:
>>>> On 10/16/2022 8:51 PM, Richard Damon wrote:
>>>>> On 10/16/22 9:41 PM, olcott wrote:
>>>>>> On 10/16/2022 10:16 AM, olcott wrote:
>>>>>>> <Sipser approved abstract>
>>>>>>> MIT Professor Michael Sipser has agreed that the following 
>>>>>>> verbatim paragraph is correct (he has not agreed to anything else 
>>>>>>> in this paper):
>>>>>>>
>>>>>>> If simulating halt decider H correctly simulates its input D 
>>>>>>> until H correctly determines that its simulated D would never 
>>>>>>> stop running unless aborted then H can abort its simulation of D 
>>>>>>> and correctly report that D specifies a non-halting sequence of 
>>>>>>> configurations.
>>>>>>> </Sipser approved abstract>
>>>>>>>
>>>>>>> to this paper:
>>>>>>>
>>>>>>> *Rebutting the Sipser Halting Problem Proof*
>>>>>>> https://www.researchgate.net/publication/364302709_Rebutting_the_Sipser_Halting_Problem_Proof
>>>>>>>
>>>>>>> The proof that the simulation of D by H is correct and that this 
>>>>>>> correctly simulated D would never stop running unless aborted is 
>>>>>>> on page 3 of the above paper. People that fail to comprehend the 
>>>>>>> technical details of page 3 are unqualified to assess the 
>>>>>>> correctness of page 3.
>>>>>>>
>>>>>>> The technical prerequisites for page 3 are expert knowledge of 
>>>>>>> the C programming language, knowledge of x86 assembly language 
>>>>>>> and how the C calling conventions are implemented in x86 assembly 
>>>>>>> language.
>>>>>>>
>>>>>>> Page 4 shows the application of a simulating halt decider to the 
>>>>>>> Peter Linz proof proving that the "impossible" input ⟨Ĥ⟩ ⟨Ĥ⟩ to 
>>>>>>> the embedded copy of Linz H contained within Linz Ĥ is correctly 
>>>>>>> construed as specifying non-halting sequence of configurations.
>>>>>>>
>>>>>>
>>>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:111fa8
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [000012ae][00111f94][00111f98] 55         push ebp     // Begin 
>>>>>> Sipser_D
>>>>>> [000012af][00111f94][00111f98] 8bec       mov ebp,esp
>>>>>> [000012b1][00111f94][00111f98] 8b4508     mov eax,[ebp+08]
>>>>>> [000012b4][00111f90][000012ae] 50         push eax      // push 
>>>>>> Sipser_D
>>>>>> [000012b5][00111f90][000012ae] 8b4d08     mov ecx,[ebp+08]
>>>>>> [000012b8][00111f8c][000012ae] 51         push ecx      // push 
>>>>>> Sipser_D
>>>>>> [000012b9][00111f88][000012be] e880fdffff call 0000103e // call 
>>>>>> Sipser_H
>>>>>> Sipser_H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>>
>>>>>> // Richard is too dumb to see this
>>>>>> If (H never stops D)
>>>>>>     D keeps repeating
>>>>>>
>>>>>>
>>>>>>
>>>>> But that isn't the question, and H DOES stop, so it doesn't matter.
>>>>>
>>>> It is the question that H is correctly answering and you are just 
>>>> too dumb to see this.
>>>>
>>>
>>> So you admit you aren't doing the Halting Problem  Because that isn't 
>>> the question of the Halting Problem.
>>
>> As Professor Sipser agrees the halt status of D is correctly 
>> determined by the behavior of D simulated by H, and this D never halts 
>> even if it does stop running because its simulation was aborted.
>>
> 
> No, he said that *IF* H did a correct simulation, and was able to 
> *CORRECTLY* determine that the simulation would not stop, 

unless aborted // you can't skip this

> it can abort 
> its simulation and return the non-halting value.
> 

-- 
Copyright 2022 Pete 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]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.theory

csiph-web