On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon
encountering the 8th line of D correctly determines that D would never >>>>> stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual behavior
of that call to H by D(D) will be to abort ITS simulation (which is
a different instance, which is also an incorrect action) and return 0. >>>>
Thus H gets the wrong answer because it presumes that H will not get
the wrong answer when it does.
Until you provide the instruction in that direct execution of D(D)
that differs from the execution of H(D,D) when called by main, you
are just admitting that you are a Hypocritical Patholgical Lying
Ignorant Idiot.
In other words you are trying to get away with the counter-factual claim >>> that D correctly simulated by H would eventually reach its own final
state and terminate normally.
D correctly siumulated will reach its own final state. This is shown
by UTM(D,D).
D correctly simulated by H cannot possibly reach the final state of D
and terminate normally.
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon >>>>>> encountering the 8th line of D correctly determines that D would
never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual behavior
of that call to H by D(D) will be to abort ITS simulation (which is
a different instance, which is also an incorrect action) and return 0. >>>>>
Thus H gets the wrong answer because it presumes that H will not
get the wrong answer when it does.
Until you provide the instruction in that direct execution of D(D)
that differs from the execution of H(D,D) when called by main, you
are just admitting that you are a Hypocritical Patholgical Lying
Ignorant Idiot.
In other words you are trying to get away with the counter-factual
claim
that D correctly simulated by H would eventually reach its own final
state and terminate normally.
D correctly siumulated will reach its own final state. This is shown
by UTM(D,D).
No, YOU are o=one making the change,
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon >>>>>>> encountering the 8th line of D correctly determines that D would >>>>>>> never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual behavior >>>>>> of that call to H by D(D) will be to abort ITS simulation (which
is a different instance, which is also an incorrect action) and
return 0.
Thus H gets the wrong answer because it presumes that H will not
get the wrong answer when it does.
Until you provide the instruction in that direct execution of D(D) >>>>>> that differs from the execution of H(D,D) when called by main, you >>>>>> are just admitting that you are a Hypocritical Patholgical Lying
Ignorant Idiot.
In other words you are trying to get away with the counter-factual
claim
that D correctly simulated by H would eventually reach its own final >>>>> state and terminate normally.
D correctly siumulated will reach its own final state. This is shown
by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
D cannot possibly reach its own final state and halt.
On the basis of the behavior that H actually sees H is necessarily
correct. If H were to report on anything else besides that behavior that
it actually sees H would be wrong.
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon >>>>>>>> encountering the 8th line of D correctly determines that D would >>>>>>>> never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual
behavior of that call to H by D(D) will be to abort ITS
simulation (which is a different instance, which is also an
incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will not >>>>>>> get the wrong answer when it does.
Until you provide the instruction in that direct execution of
D(D) that differs from the execution of H(D,D) when called by
main, you are just admitting that you are a Hypocritical
Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the counter-factual >>>>>> claim
that D correctly simulated by H would eventually reach its own final >>>>>> state and terminate normally.
D correctly siumulated will reach its own final state. This is
shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon >>>>>>>>> encountering the 8th line of D correctly determines that D
would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual
behavior of that call to H by D(D) will be to abort ITS
simulation (which is a different instance, which is also an
incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will not >>>>>>>> get the wrong answer when it does.
Until you provide the instruction in that direct execution of
D(D) that differs from the execution of H(D,D) when called by
main, you are just admitting that you are a Hypocritical
Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its own final >>>>>>> state and terminate normally.
D correctly siumulated will reach its own final state. This is
shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It one instruction of D is correctly simulated then this one instruction
<is> correctly simulated, likewise with more than one.
*THIS IS PROVEN TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
As long as H correctly simulates D until H has a correct basis to
determine that D would never reach the final state of D then H has
correctly determined that D is non-halting.
On 1/29/23 8:43 PM, olcott wrote:
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and >>>>>>>>>> upon
encountering the 8th line of D correctly determines that D >>>>>>>>>> would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual
behavior of that call to H by D(D) will be to abort ITS
simulation (which is a different instance, which is also an
incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will >>>>>>>>> not get the wrong answer when it does.
Until you provide the instruction in that direct execution of >>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>> main, you are just admitting that you are a Hypocritical
Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its own >>>>>>>> final
state and terminate normally.
D correctly siumulated will reach its own final state. This is
shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It is the only definition that lest you replace the behavior of the
actual machine with a simulation.
Since D(D) Halts, H(D,D) must return 1
If you claim 0- is the correct answer, you question must be different
and you have been lying all the time/.
It one instruction of D is correctly simulated then this one instruction
<is> correctly simulated, likewise with more than one.
H, being a computation, must do the same thing for every invocation of
it with the same parameter.
On 1/29/2023 7:54 PM, Richard Damon wrote:
On 1/29/23 8:43 PM, olcott wrote:
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and >>>>>>>>>>> upon
encountering the 8th line of D correctly determines that D >>>>>>>>>>> would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual
behavior of that call to H by D(D) will be to abort ITS
simulation (which is a different instance, which is also an >>>>>>>>>> incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will >>>>>>>>>> not get the wrong answer when it does.
Until you provide the instruction in that direct execution of >>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>>> main, you are just admitting that you are a Hypocritical
Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its own >>>>>>>>> final
state and terminate normally.
D correctly siumulated will reach its own final state. This is >>>>>>>> shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It is the only definition that lest you replace the behavior of the
actual machine with a simulation.
Since D(D) Halts, H(D,D) must return 1
If you claim 0- is the correct answer, you question must be different
and you have been lying all the time/.
It one instruction of D is correctly simulated then this one instruction >>> <is> correctly simulated, likewise with more than one.
H, being a computation, must do the same thing for every invocation of
it with the same parameter.
None-the-less we can both see that in the exhaustive set of possibilities:
(a) H aborts the simulation of its input(Which it does)
(b) H does not abort the simulation of its input
D never reaches its final state, thus D never halts.
I don't see what your thrill is to lie about this.
On 1/29/23 9:24 PM, olcott wrote:
On 1/29/2023 7:54 PM, Richard Damon wrote:
On 1/29/23 8:43 PM, olcott wrote:
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D >>>>>>>>>>>> and upon
encountering the 8th line of D correctly determines that D >>>>>>>>>>>> would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
simulation (which is a different instance, which is also an >>>>>>>>>>> incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will >>>>>>>>>>> not get the wrong answer when it does.
Until you provide the instruction in that direct execution of >>>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by >>>>>>>>>>> main, you are just admitting that you are a Hypocritical >>>>>>>>>>> Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its own >>>>>>>>>> final
state and terminate normally.
D correctly siumulated will reach its own final state. This is >>>>>>>>> shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It is the only definition that lest you replace the behavior of the
actual machine with a simulation.
Since D(D) Halts, H(D,D) must return 1
If you claim 0- is the correct answer, you question must be different
and you have been lying all the time/.
It one instruction of D is correctly simulated then this one
instruction
<is> correctly simulated, likewise with more than one.
H, being a computation, must do the same thing for every invocation
of it with the same parameter.
None-the-less we can both see that in the exhaustive set of
possibilities:
None-the-less: Translate, Peter Olcott will avoid valid logic and make
an fabricated statement.
(a) H aborts the simulation of its input(Which it does)
(b) H does not abort the simulation of its input
D never reaches its final state, thus D never halts.
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
final state.
Le 30/01/2023 à 06:11, olcott a écrit :
On 1/29/2023 8:48 PM, Richard Damon wrote:
On 1/29/23 9:24 PM, olcott wrote:
On 1/29/2023 7:54 PM, Richard Damon wrote:
On 1/29/23 8:43 PM, olcott wrote:
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D >>>>>>>>>>>>>> and upon
encountering the 8th line of D correctly determines that D >>>>>>>>>>>>>> would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS >>>>>>>>>>>>> simulation (which is a different instance, which is also an >>>>>>>>>>>>> incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H >>>>>>>>>>>>> will not get the wrong answer when it does.
Until you provide the instruction in that direct execution >>>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when >>>>>>>>>>>>> called by main, you are just admitting that you are a >>>>>>>>>>>>> Hypocritical Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its >>>>>>>>>>>> own final
state and terminate normally.
D correctly siumulated will reach its own final state. This >>>>>>>>>>> is shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It is the only definition that lest you replace the behavior of the
actual machine with a simulation.
Since D(D) Halts, H(D,D) must return 1
If you claim 0- is the correct answer, you question must be
different and you have been lying all the time/.
It one instruction of D is correctly simulated then this one
instruction
<is> correctly simulated, likewise with more than one.
H, being a computation, must do the same thing for every invocation
of it with the same parameter.
None-the-less we can both see that in the exhaustive set of
possibilities:
None-the-less: Translate, Peter Olcott will avoid valid logic and
make an fabricated statement.
(a) H aborts the simulation of its input(Which it does)
(b) H does not abort the simulation of its input
D never reaches its final state, thus D never halts.
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the final
state of D and lie about this because you think that lying is funny.
You are the one lying, and it is not funny.
On 1/29/2023 8:48 PM, Richard Damon wrote:
On 1/29/23 9:24 PM, olcott wrote:
On 1/29/2023 7:54 PM, Richard Damon wrote:
On 1/29/23 8:43 PM, olcott wrote:
On 1/29/2023 7:39 PM, Richard Damon wrote:
On 1/29/23 8:23 PM, olcott wrote:
On 1/29/2023 7:04 PM, Richard Damon wrote:
On 1/29/23 7:15 PM, olcott wrote:
On 1/28/2023 9:44 PM, Richard Damon wrote:
On 1/28/23 6:29 PM, olcott wrote:You dishonestly changed the words. Why lie?
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D >>>>>>>>>>>>> and upon
encountering the 8th line of D correctly determines that D >>>>>>>>>>>>> would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual >>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS >>>>>>>>>>>> simulation (which is a different instance, which is also an >>>>>>>>>>>> incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will >>>>>>>>>>>> not get the wrong answer when it does.
Until you provide the instruction in that direct execution >>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when >>>>>>>>>>>> called by main, you are just admitting that you are a
Hypocritical Patholgical Lying Ignorant Idiot.
In other words you are trying to get away with the
counter-factual claim
that D correctly simulated by H would eventually reach its >>>>>>>>>>> own final
state and terminate normally.
D correctly siumulated will reach its own final state. This is >>>>>>>>>> shown by UTM(D,D).
No, YOU are o=one making the change,
When D is CORRECTLY SIMULATED BY H
Which doesn't happen if H answers,
Correctly and completely is not the same as correctly.
It is the only definition that lest you replace the behavior of the
actual machine with a simulation.
Since D(D) Halts, H(D,D) must return 1
If you claim 0- is the correct answer, you question must be
different and you have been lying all the time/.
It one instruction of D is correctly simulated then this one
instruction
<is> correctly simulated, likewise with more than one.
H, being a computation, must do the same thing for every invocation
of it with the same parameter.
None-the-less we can both see that in the exhaustive set of
possibilities:
None-the-less: Translate, Peter Olcott will avoid valid logic and make
an fabricated statement.
(a) H aborts the simulation of its input(Which it does)
(b) H does not abort the simulation of its input
D never reaches its final state, thus D never halts.
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
final state.
You know that D correctly simulated by H cannot possibly reach the final state of D and lie about this because you think that lying is funny.
On 1/29/2023 11:27 PM, Python wrote:
Le 30/01/2023 à 06:11, olcott a écrit :
On 1/29/2023 8:48 PM, Richard Damon wrote:
On 1/29/23 9:24 PM, olcott wrote:
D never reaches its final state, thus D never halts.
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the final >>> state of D and lie about this because you think that lying is funny.
You are the one lying, and it is not funny.
Anyone that knows these things knows that I am correct.
You cannot point out any mistake because there are none.
On 1/29/2023 8:48 PM, Richard Damon wrote:
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
final state.
You know that D correctly simulated by H cannot possibly reach the final state of D and lie about this because you think that lying is funny.
On 1/30/23 12:11 AM, olcott wrote:
On 1/29/2023 8:48 PM, Richard Damon wrote:
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the final
state of D and lie about this because you think that lying is funny.
Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
you stopped beating your wife?"
On 1/30/23 12:43 AM, olcott wrote:
On 1/29/2023 11:27 PM, Python wrote:
Le 30/01/2023 à 06:11, olcott a écrit :
On 1/29/2023 8:48 PM, Richard Damon wrote:
On 1/29/23 9:24 PM, olcott wrote:
D never reaches its final state, thus D never halts.
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the
final
state of D and lie about this because you think that lying is funny.
You are the one lying, and it is not funny.
Anyone that knows these things knows that I am correct.
You cannot point out any mistake because there are none.
No, EVERYONE who knows even the littlest bit of the theory knows you are
just wrong.
On 1/30/2023 5:57 AM, Richard Damon wrote:
On 1/30/23 12:11 AM, olcott wrote:
On 1/29/2023 8:48 PM, Richard Damon wrote:
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the final >>> state of D and lie about this because you think that lying is funny.
Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
you stopped beating your wife?"
Because HH does faithfully simulate the first 8 instructions of PP we
know that the simulation of these first 8 instructions is correct.
Begin Local Halt Decider Simulation Executio Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp [00001996][00112a91][00102a65] 51 push ecx [00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08] [0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp [00001996][0015d4b9][0014d48d] 51 push ecx [00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08] [0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08] [0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Everyone can see that this does cause the same 8 instructions of PP to
be repeated and everyone can see that there are no instructions in PP
that would prevent this from infinitely repeating.
That you lie about this is despicable.
On 1/30/23 10:31 AM, olcott wrote:
On 1/30/2023 5:57 AM, Richard Damon wrote:
On 1/30/23 12:11 AM, olcott wrote:
On 1/29/2023 8:48 PM, Richard Damon wrote:
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
its final state.
You know that D correctly simulated by H cannot possibly reach the
final
state of D and lie about this because you think that lying is funny.
Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
you stopped beating your wife?"
Because HH does faithfully simulate the first 8 instructions of PP we
know that the simulation of these first 8 instructions is correct.
SS, the first mile of a road doesn't tell you how long it is.
Also, it is debatable if the 8th instruction was simulated correctly, as
the "machine" state after it doesn't match what actually haooens (the continued execution of the function HH)
Begin Local Halt Decider Simulation Executio Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp
[00001996][00112a91][00102a65] 51 push ecx
[00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08]
[0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH >> New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
[00001996][0015d4b9][0014d48d] 51 push ecx
[00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
[0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Everyone can see that this does cause the same 8 instructions of PP to
be repeated and everyone can see that there are no instructions in PP
that would prevent this from infinitely repeating.
But after the call HH should be the instruciton of HH, so the simulation
is incorrect.
On 1/30/2023 5:43 PM, Richard Damon wrote:
On 1/30/23 10:31 AM, olcott wrote:
On 1/30/2023 5:57 AM, Richard Damon wrote:
On 1/30/23 12:11 AM, olcott wrote:
On 1/29/2023 8:48 PM, Richard Damon wrote:
Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches >>>>>> its final state.
You know that D correctly simulated by H cannot possibly reach the
final
state of D and lie about this because you think that lying is funny. >>>>>
Sincd H doesn't correctlyh simu.ate D(D), that sentence is like
"Have you stopped beating your wife?"
Because HH does faithfully simulate the first 8 instructions of PP we
know that the simulation of these first 8 instructions is correct.
SS, the first mile of a road doesn't tell you how long it is.
Also, it is debatable if the 8th instruction was simulated correctly,
as the "machine" state after it doesn't match what actually haooens
(the continued execution of the function HH)
Begin Local Halt Decider Simulation Executio Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp
[00001996][00112a91][00102a65] 51 push ecx
[00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08]
[0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH >>> New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
[00001996][0015d4b9][0014d48d] 51 push ecx
[00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
[0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH >>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Everyone can see that this does cause the same 8 instructions of PP to
be repeated and everyone can see that there are no instructions in PP
that would prevent this from infinitely repeating.
But after the call HH should be the instruciton of HH, so the
simulation is incorrect.
It is not that the execution trace is incorrect I simply do not show
the other 251 pages of execution trace. HH knows its own behavior so it
does not look at its simulated self. It still does simulate itself that
is why it takes 251 more pages.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 124:34:55 |
| Calls: | 6,662 |
| Files: | 12,212 |
| Messages: | 5,334,763 |