On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then when
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the
Best selling author of Theory of Computation textbooks:
*Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph >>>>>>>>>>> is correct*
(He has neither reviewed nor agreed to anything else in this >>>>>>>>>>> paper)
(a) 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
(b) H can abort its simulation of D and correctly report that >>>>>>>>>>> D specifies a non-halting sequence of configurations.
*When we apply the abort criteria* (elaborated above)
Will you halt if you never abort your simulation?
*Then H(D,D) is proven to meet this criteria*
*Proof that H(D,D) meets its abort criteria*
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));
}
machine stack stack machine assembly >>>>>>>>>>> address address data code language
======== ======== ======== ========= ============= >>>>>>>>>>> [00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>> push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D >>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; >>>>>>>>>>> call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ;
enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08] >>>>>>>>>>> [00001cf9][00113059][00001cf2] 50 push eax ;
push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>> [00001cfd][00113055][00001cf2] 51 push ecx ;
push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; >>>>>>>>>>> call H(D,D)
H: Recursive Simulation Detected Simulation Stopped
H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria*
H(D,D) correctly determines that itself is being called with >>>>>>>>>>> its same inputs and there are no conditional branch
instructions between the invocation of D(D) and its call to >>>>>>>>>>> H(D,D).
Except that D calling H(D,D) does NOT prove the required (a), >>>>>>>>>> since the simulated D WILL stop running because *ITS* H will >>>>>>>>>> abort *ITS* simulation and returm 0 so that simulated D will >>>>>>>>>> halt.
simulation of its input because after H(D,D) has aborted the >>>>>>>>> simulation of this input it no longer needs to be aborted.
it's convenient for you you think there is only one H(D,D). Why >>>>>>>> is that?
The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.
But since it does, which is your definition of H, the others
never begin to be simulated.
But D(D) started to be simulated, and we can know what D(D) actually
does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
On 3/15/2024 3:43 PM, Richard Damon wrote:
On 3/15/24 1:37 PM, olcott wrote:
It is a fact that the behavior of D(D) after it aborts
its simulation cannot be used as abort status criteria or
no H(D,D) would ever abort its simulation.
Yes, that is a correct computational argument, but doesn't prove the criteria used is correct.
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then when >>>>>>>>>> it's convenient for you you think there is only one H(D,D). >>>>>>>>>> Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim
paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>> this paper)
(a) 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
(b) H can abort its simulation of D and correctly report >>>>>>>>>>>>> that D specifies a non-halting sequence of configurations. >>>>>>>>>>>>>
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>> Will you halt if you never abort your simulation?
*Then H(D,D) is proven to meet this criteria*
*Proof that H(D,D) meets its abort criteria*
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= >>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>> push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>> push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; >>>>>>>>>>>>> call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ;
enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50 push eax ;
push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51 push ecx ;
push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; >>>>>>>>>>>>> call H(D,D)
H: Recursive Simulation Detected Simulation Stopped
H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>> with its same inputs and there are no conditional branch >>>>>>>>>>>>> instructions between the invocation of D(D) and its call to >>>>>>>>>>>>> H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>> (a), since the simulated D WILL stop running because *ITS* H >>>>>>>>>>>> will abort *ITS* simulation and returm 0 so that simulated D >>>>>>>>>>>> will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others
never begin to be simulated.
But D(D) started to be simulated, and we can know what D(D)
actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for the
purposes of that criteria are the complete not-aborted simulation done
by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>> H(D,D). Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>>>> this paper)
(a) 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
(b) H can abort its simulation of D and correctly report >>>>>>>>>>>>>>> that D specifies a non-halting sequence of configurations. >>>>>>>>>>>>>>>
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
*Proof that H(D,D) meets its abort criteria*
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= >>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>>>> push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>>>> push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; >>>>>>>>>>>>>>> call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp >>>>>>>>>>>>>>> ; enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50 push eax >>>>>>>>>>>>>>> ; push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51 push ecx >>>>>>>>>>>>>>> ; push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 >>>>>>>>>>>>>>> ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>>>> with its same inputs and there are no conditional branch >>>>>>>>>>>>>>> instructions between the invocation of D(D) and its call >>>>>>>>>>>>>>> to H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>>>> (a), since the simulated D WILL stop running because *ITS* >>>>>>>>>>>>>> H will abort *ITS* simulation and returm 0 so that >>>>>>>>>>>>>> simulated D will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>
But D(D) started to be simulated, and we can know what D(D)
actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for
the purposes of that criteria are the complete not-aborted
simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation,
even past where H simulated. Thus, is based on things H might not know.
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
I would estimate that an actual proof fully anchored in actual
mathematical induction can be derived. I do remember from my
independent studies course on proof of program correctness that
this does typically anchor in actual mathematical induction.
I still have two textbooks on this.
You don't seem to understand the meaning of CORRECT.
I guess you are just showing you think it is ok to LIE to make it look
like you have done something.
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>> H(D,D). Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>>>> this paper)
(a) 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
(b) H can abort its simulation of D and correctly report >>>>>>>>>>>>>>> that D specifies a non-halting sequence of configurations. >>>>>>>>>>>>>>>
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
*Proof that H(D,D) meets its abort criteria*
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= >>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>>>> push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; >>>>>>>>>>>>>>> push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; >>>>>>>>>>>>>>> call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp >>>>>>>>>>>>>>> ; enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08] >>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50 push eax >>>>>>>>>>>>>>> ; push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08] >>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51 push ecx >>>>>>>>>>>>>>> ; push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 >>>>>>>>>>>>>>> ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>>>> with its same inputs and there are no conditional branch >>>>>>>>>>>>>>> instructions between the invocation of D(D) and its call >>>>>>>>>>>>>>> to H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>>>> (a), since the simulated D WILL stop running because *ITS* >>>>>>>>>>>>>> H will abort *ITS* simulation and returm 0 so that >>>>>>>>>>>>>> simulated D will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>
But D(D) started to be simulated, and we can know what D(D)
actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D)
has already aborted the simulation of its input at the point
in time before H(D,D) aborts its input as any criterion measure
for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for
the purposes of that criteria are the complete not-aborted
simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation,
even past where H simulated. Thus, is based on things H might not know.
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
On 3/15/2024 10:55 PM, immibis wrote:
On 16/03/24 04:14, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>> H(D,D). Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>>>>>> this paper)
(a) 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 >>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ; >>>>>>>>>>>>>>>>> begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ; >>>>>>>>>>>>>>>>> enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ; >>>>>>>>>>>>>>>>> push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ; >>>>>>>>>>>>>>>>> push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>>>>>> with its same inputs and there are no conditional >>>>>>>>>>>>>>>>> branch instructions between the invocation of D(D) and >>>>>>>>>>>>>>>>> its call to H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>>>>>> (a), since the simulated D WILL stop running because >>>>>>>>>>>>>>>> *ITS* H will abort *ITS* simulation and returm 0 so that >>>>>>>>>>>>>>>> simulated D will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>> actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for >>>>>> the purposes of that criteria are the complete not-aborted
simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation,
even past where H simulated. Thus, is based on things H might not know. >>>>
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or not.
A termination analyzer must have some way to predicate this.
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
On 3/15/2024 10:28 PM, Richard Damon wrote:
On 3/15/24 8:14 PM, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>> H(D,D). Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>>>>>> this paper)
(a) 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 >>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ; >>>>>>>>>>>>>>>>> begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ; >>>>>>>>>>>>>>>>> enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ; >>>>>>>>>>>>>>>>> push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ; >>>>>>>>>>>>>>>>> push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>>>>>> with its same inputs and there are no conditional >>>>>>>>>>>>>>>>> branch instructions between the invocation of D(D) and >>>>>>>>>>>>>>>>> its call to H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>>>>>> (a), since the simulated D WILL stop running because >>>>>>>>>>>>>>>> *ITS* H will abort *ITS* simulation and returm 0 so that >>>>>>>>>>>>>>>> simulated D will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>> actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for >>>>>> the purposes of that criteria are the complete not-aborted
simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation,
even past where H simulated. Thus, is based on things H might not know. >>>>
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
But, since the Execution DOES end, so will a correct simulation.
*YOU KEEP FORGETTING THIS*
There cannot possibly exist any H(D,D) that is called by
D where H(D,D) simulates its input and D(D) stops running
and H never aborts its simulation.
You seem to think that it is possible to prove a false statement.
I would estimate that an actual proof fully anchored in actual
mathematical induction can be derived. I do remember from my
independent studies course on proof of program correctness that
this does typically anchor in actual mathematical induction.
So, you REALLY beleive that you can prove that the correct simulation
of a halting computation can go on forever.
There cannot possibly exist any H(D,D) that is called by
D where H(D,D) simulates its input and D(D) stops running
and H never aborts its simulation.
You think you can prove an INCORRECT program as correct.
(Since D(D) Halts, H(D,D) returning 0 is just WRONG for a Halt Decider).
H(D,D) fails to make the required mistake of reporting on what it does
not see.
I still have two textbooks on this.
Really? do you read and understand them?
"Something like mathematical induction" sounds dubious for you really
understanding it.
Try to define the induction (if you understand what to do).
You don't seem to understand the meaning of CORRECT.
I guess you are just showing you think it is ok to LIE to make it
look like you have done something.
On 3/15/2024 10:55 PM, immibis wrote:
On 16/03/24 04:14, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>> H(D,D). Why is that?
On 3/15/24 9:20 AM, olcott wrote:You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else in >>>>>>>>>>>>>>>>> this paper)
(a) 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 >>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ; >>>>>>>>>>>>>>>>> begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 >>>>>>>>>>>>>>>>> ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ; >>>>>>>>>>>>>>>>> enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ; >>>>>>>>>>>>>>>>> push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ; >>>>>>>>>>>>>>>>> push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 >>>>>>>>>>>>>>>>> ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called >>>>>>>>>>>>>>>>> with its same inputs and there are no conditional >>>>>>>>>>>>>>>>> branch instructions between the invocation of D(D) and >>>>>>>>>>>>>>>>> its call to H(D,D).
Except that D calling H(D,D) does NOT prove the required >>>>>>>>>>>>>>>> (a), since the simulated D WILL stop running because >>>>>>>>>>>>>>>> *ITS* H will abort *ITS* simulation and returm 0 so that >>>>>>>>>>>>>>>> simulated D will halt.
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>> actually does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for >>>>>> the purposes of that criteria are the complete not-aborted
simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation,
even past where H simulated. Thus, is based on things H might not know. >>>>
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or not.
A termination analyzer must have some way to predicate this.
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
On 3/16/2024 11:32 AM, immibis wrote:
On 16/03/24 05:23, olcott wrote:
On 3/15/2024 10:55 PM, immibis wrote:A termination analyzer cannot always correctly predict this. Every
On 16/03/24 04:14, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>>>> H(D,D). Why is that?
You keep saying that H(D,D) never really needs to abort >>>>>>>>>>>>>>>>> theBest selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by >>>>>>>>>>>>>>>>>>> sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else >>>>>>>>>>>>>>>>>>> in this paper)
(a) 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 >>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ;
enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ;
push D
[00001cfa][00113059][00001cf2] 8b4d08 mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ;
push D
[00001cfe][00113051][00001d03] e81ff8ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being >>>>>>>>>>>>>>>>>>> called with its same inputs and there are no >>>>>>>>>>>>>>>>>>> conditional branch instructions between the >>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D). >>>>>>>>>>>>>>>>>>>
Except that D calling H(D,D) does NOT prove the >>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop running >>>>>>>>>>>>>>>>>> because *ITS* H will abort *ITS* simulation and returm >>>>>>>>>>>>>>>>>> 0 so that simulated D will halt.
simulation of its input because after H(D,D) has >>>>>>>>>>>>>>>>> aborted the
simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>>>
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its >>>>>>>>>>>>>>> input or
none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>>>> actually does, which includes it using its version of H. >>>>>>>>>>>>
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" >>>>>>>> for the purposes of that criteria are the complete not-aborted >>>>>>>> simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full
simulation, even past where H simulated. Thus, is based on things
H might not know.
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or
not.
A termination analyzer must have some way to predicate this.
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
time you make a termination analyzer it is easy to demonstrate one
program which it predicts incorrectly.
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
To the best of my knowledge no one here has ever shown that
the above criteria is impossible to always meet.
On 3/15/2024 11:29 PM, Richard Damon wrote:
On 3/15/24 8:45 PM, olcott wrote:
H(D,D) fails to make the required mistake of reporting on what it
does not see.
But it DOES make a mistake, because it does answer the question
correctly.
You are just PROVING you think lying is ok.
You TOTALLY don't understand the meaning of truth.
You are REALLY just a Pathological Liar, as you have no concept of
real truth,
The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*
(a) 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 correctly simulates its input D until*
Means H does a correct partial simulation of D until H correctly
matches the recursive simulation non-halting behavior pattern.
On 3/15/2024 11:43 PM, Richard Damon wrote:
On 3/15/24 9:23 PM, olcott wrote:We could say that a termination analyzer only needs to be able
On 3/15/2024 10:55 PM, immibis wrote:
On 16/03/24 04:14, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>>>> H(D,D). Why is that?
You keep saying that H(D,D) never really needs to abort >>>>>>>>>>>>>>>>> theBest selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by >>>>>>>>>>>>>>>>>>> sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else >>>>>>>>>>>>>>>>>>> in this paper)
(a) 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 >>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ;
enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ;
push D
[00001cfa][00113059][00001cf2] 8b4d08 mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ;
push D
[00001cfe][00113051][00001d03] e81ff8ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being >>>>>>>>>>>>>>>>>>> called with its same inputs and there are no >>>>>>>>>>>>>>>>>>> conditional branch instructions between the >>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D). >>>>>>>>>>>>>>>>>>>
Except that D calling H(D,D) does NOT prove the >>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop running >>>>>>>>>>>>>>>>>> because *ITS* H will abort *ITS* simulation and returm >>>>>>>>>>>>>>>>>> 0 so that simulated D will halt.
simulation of its input because after H(D,D) has >>>>>>>>>>>>>>>>> aborted the
simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>>>
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its >>>>>>>>>>>>>>> input or
none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>>>> actually does, which includes it using its version of H. >>>>>>>>>>>>
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" >>>>>>>> for the purposes of that criteria are the complete not-aborted >>>>>>>> simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full
simulation, even past where H simulated. Thus, is based on things
H might not know.
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or
not.
A termination analyzer must have some way to predicate this.
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
WHY must it?
to play tic-tac-toe badly.
You are assuming the problem is computable.I am stipulating the requirements for a solution.
That has been your fundamental problem, you ASSUME an answer must exist.Assume a correct answer exists and the rebut every rebuttal.
The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*
(a) 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 correctly simulates its input D until*
Means H does a correct partial simulation of D until H correctly
matches the recursive simulation non-halting behavior pattern.
The QUESTION (at least if the input is a Computation) mst have an answer.
But the problem of making a machine to compute that does not.
On 3/16/2024 11:32 AM, immibis wrote:
On 16/03/24 05:23, olcott wrote:
On 3/15/2024 10:55 PM, immibis wrote:A termination analyzer cannot always correctly predict this. Every
On 16/03/24 04:14, olcott wrote:
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:You keep thinking there is more than one H(D,D) and then >>>>>>>>>>>>>>>> when it's convenient for you you think there is only one >>>>>>>>>>>>>>>> H(D,D). Why is that?
You keep saying that H(D,D) never really needs to abort >>>>>>>>>>>>>>>>> theBest selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by >>>>>>>>>>>>>>>>>>> sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim >>>>>>>>>>>>>>>>>>> paragraph is correct*
(He has neither reviewed nor agreed to anything else >>>>>>>>>>>>>>>>>>> in this paper)
(a) 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 >>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly >>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of >>>>>>>>>>>>>>>>>>> configurations.
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ;
begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push >>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ;
enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov >>>>>>>>>>>>>>>>>>> eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ;
push D
[00001cfa][00113059][00001cf2] 8b4d08 mov >>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ;
push D
[00001cfe][00113051][00001d03] e81ff8ffff call >>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being >>>>>>>>>>>>>>>>>>> called with its same inputs and there are no >>>>>>>>>>>>>>>>>>> conditional branch instructions between the >>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D). >>>>>>>>>>>>>>>>>>>
Except that D calling H(D,D) does NOT prove the >>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop running >>>>>>>>>>>>>>>>>> because *ITS* H will abort *ITS* simulation and returm >>>>>>>>>>>>>>>>>> 0 so that simulated D will halt.
simulation of its input because after H(D,D) has >>>>>>>>>>>>>>>>> aborted the
simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>>>
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its >>>>>>>>>>>>>>> input or
none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) >>>>>>>>>>>> actually does, which includes it using its version of H. >>>>>>>>>>>>
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" >>>>>>>> for the purposes of that criteria are the complete not-aborted >>>>>>>> simulation done by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full
simulation, even past where H simulated. Thus, is based on things
H might not know.
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or
not.
A termination analyzer must have some way to predicate this.
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
time you make a termination analyzer it is easy to demonstrate one
program which it predicts incorrectly.
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
To the best of my knowledge no one here has ever shown that
the above criteria is impossible to always meet.
On 3/16/2024 11:32 AM, immibis wrote:
On 16/03/24 05:23, olcott wrote:
On 3/15/2024 10:55 PM, immibis wrote:A termination analyzer cannot always correctly predict this. Every time
On 16/03/24 04:14, olcott wrote:A termination analyzer must have some way to predicate this.
On 3/15/2024 6:26 PM, Richard Damon wrote:
On 3/15/24 3:41 PM, olcott wrote:
On 3/15/2024 5:10 PM, Richard Damon wrote:
On 3/15/24 2:13 PM, olcott wrote:
On 3/15/2024 3:27 PM, Richard Damon wrote:
On 3/15/24 12:38 PM, olcott wrote:
On 3/15/2024 2:30 PM, Richard Damon wrote:
On 3/15/24 12:14 PM, olcott wrote:
On 3/15/2024 2:06 PM, Richard Damon wrote:
On 3/15/24 11:39 AM, olcott wrote:never begin to be simulated.
On 3/15/2024 1:38 PM, immibis wrote:
On 15/03/24 18:52, olcott wrote:
On 3/15/2024 12:36 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:You keep thinking there is more than one H(D,D) and then when it's
Best selling author of Theory of Computation textbooks: >>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser* >>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations. >>>>>>>>>>>>>>>>>>>
*When we apply the abort criteria* (elaborated above) >>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation? >>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria* >>>>>>>>>>>>>>>>>>>
*Proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>>
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));
}
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp ; begin main()
[00001d23][00102fc9][00000000] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
H: Begin Simulation Execution Trace Stored at:113075 >>>>>>>>>>>>>>>>>>> Address_of_H:1522
[00001cf2][00113061][00113065] 55 push ebp ; enter D(D)
[00001cf3][00113061][00113065] 8bec mov ebp,esp >>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51 push ecx >>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508 mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50 push eax ; push D
[00001cfa][00113059][00001cf2] 8b4d08 mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51 push ecx ; push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped >>>>>>>>>>>>>>>>>>> H(D,D) returns 0 to main()
*That was proof that H(D,D) meets its abort criteria* >>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
inputs and there are no conditional branch instructions between the
invocation of D(D) and its call to H(D,D). >>>>>>>>>>>>>>>>>>>
Except that D calling H(D,D) does NOT prove the required (a), since the
simulated D WILL stop running because *ITS* H will abort *ITS*
simulation and returm 0 so that simulated D will halt. >>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the >>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the >>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted. >>>>>>>>>>>>>>>>>
convenient for you you think there is only one H(D,D). Why is that?
The first H(D,D) to see that the abort criteria has been met >>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or >>>>>>>>>>>>>>> none of them ever abort.
But since it does, which is your definition of H, the others >>>>>>>>>>>>>
But D(D) started to be simulated, and we can know what D(D) actually
does, which includes it using its version of H.
We cannot reference the behavior of what D(D) does after H(D,D) >>>>>>>>>>> has already aborted the simulation of its input at the point >>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure >>>>>>>>>>> for this H(D,D).
WHy not?
That is what Correct Simulation refers to.
I guess you are just admiting to being a LIAR (or stupid).
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
So, do you admit that the definition of a "Correct Simulation" for the >>>>>>>> purposes of that criteria are the complete not-aborted simulation done >>>>>>>> by possibly some other simulator?
(a) 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
Not at all the words don't say anything like that.
"H correctly simulates its input D until"
specifically means a partial simulation.
Means H uses a partial simulation to make its decision.
Finally you get this.
The correctness of the decision is measured by the full simulation, >>>>>> even past where H simulated. Thus, is based on things H might not know. >>>>>>
No. the correctness of the decision is essentially anchored
in something like mathematical induction that correctly
predicts that complete simulation would never end.
The correctness of the decision is anchored in whether D(D) halts or not. >>>
H(D,D) can only predict what it actually sees and H(D,D)
sees that it must abort the simulation of its input.
you make a termination analyzer it is easy to demonstrate one program
which it predicts incorrectly.
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
To the best of my knowledge no one here has ever shown that
the above criteria is impossible to always meet.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 300 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 01:59:41 |
| Calls: | 6,706 |
| Calls today: | 6 |
| Files: | 12,235 |
| Messages: | 5,350,059 |