On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the
5th instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention
HHHn below, so that changes, but DDD, so the input doesn't and
thus is CAN'T be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 >>>>>>> language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input,
that input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is
available to HHHn when it emulates its input, that DDD must
actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 >>>>>> language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y
so you don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have
DDDn but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the
memory, if that differs, it is a DIFFERENT input, and needs to be so
marked.
You are just admittig that you are just stupid and think two things
that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since
the 5th instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention >>>>>>>> HHHn below, so that changes, but DDD, so the input doesn't and >>>>>>>> thus is CAN'T be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 >>>>>>>>> language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, >>>>>>>> that input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>> available to HHHn when it emulates its input, that DDD must
actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 >>>>>>>> language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y >>>>>>>> so you don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer
have DDDn but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the
memory, if that differs, it is a DIFFERENT input, and needs to be
so marked.
You are just admittig that you are just stupid and think two
things that are different are the same.
*attempts to use misdirection to weasel word around this are
dismissed*
*attempts to use misdirection to weasel word around this are
dismissed*
*attempts to use misdirection to weasel word around this are
dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> 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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Of course it means that, because Professoer Sipser would have presumed
that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the
final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Professor Sipser would not have construed that I am referring
to self-modifying code.
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
You continue to use the screwy reasoning that because
you are no longer hungry after you have eaten this
proves that you never had to eat.
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since >>>>>>>>>> the 5th instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you
mention HHHn below, so that changes, but DDD, so the input >>>>>>>>>> doesn't and thus is CAN'T be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the >>>>>>>>>>> x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to >>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, >>>>>>>>>> that input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>>>> available to HHHn when it emulates its input, that DDD must >>>>>>>>>> actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the >>>>>>>>>> x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is
non-halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have >>>>>>>>>> Y so you don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer >>>>>>>>>> have DDDn but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the >>>>>>>> memory, if that differs, it is a DIFFERENT input, and needs to >>>>>>>> be so marked.
You are just admittig that you are just stupid and think two
things that are different are the same.
*attempts to use misdirection to weasel word around this are
dismissed*
*attempts to use misdirection to weasel word around this are
dismissed*
*attempts to use misdirection to weasel word around this are
dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
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
Right, so the decider needs top be able to show that its exact
input will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
Of course it means that, because Professoer Sipser would have
presumed that you built the machines PROPERLY, so that you COULD
think of changing THIS H to be non-aborting, while the input still
used the final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it will
act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of the
decider, the one that doesn't abort as the hypothetical, and the one
that does as the actual (if the hypothical one doesn't halt).
The key is that both get the EXACT SAME input, the DDD that calls the
HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs to be
solved by correct LOGIC, thus the "hypothetical" machine never
actaully needs to exist, but the actual machine needs to be able to
prove what it would do with the EXACT input that was given, and not
just the matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH.
The test case is giving HHH∞ the input DDD that calls the HHH that you
want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort its
simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Your weasel words around this may simply be your ADD.
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the 5th >>>>>> instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn >>>>>> below, so that changes, but DDD, so the input doesn't and thus is CAN'T >>>>>> be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that >>>>>> input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is
available to HHHn when it emulates its input, that DDD must actually be >>>>>> DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you >>>>>> don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn >>>>>> but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory, >>>> if that differs, it is a DIFFERENT input, and needs to be so marked.
You are just admittig that you are just stupid and think two things
that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the 5th >>>>>>>> instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn >>>>>>>> below, so that changes, but DDD, so the input doesn't and thus is CAN'T
be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that >>>>>>>> input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>> available to HHHn when it emulates its input, that DDD must actually be
DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you
don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn >>>>>>>> but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory, >>>>>> if that differs, it is a DIFFERENT input, and needs to be so marked. >>>>>>
You are just admittig that you are just stupid and think two things >>>>>> that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed* >>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> 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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Of course it means that, because Professoer Sipser would have presumed
that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the
final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Professor Sipser would not have construed that I am referring
to self-modifying code.
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
You continue to use the screwy reasoning that because
you are no longer hungry after you have eaten this
proves that you never had to eat.
On 8/20/2024 9:53 PM, Richard Damon wrote:
On 8/20/24 10:44 PM, olcott wrote:
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
But it can't emulate DDD correctly past 4 instructions, since the 5th
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>
instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn
below, so that changes, but DDD, so the input doesn't and thus is CAN'T
be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>> Thus making all of the code of HHH directly available to >>>>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that
input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>>>>>> available to HHHn when it emulates its input, that DDD must actually be
DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non- halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you
don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same >>>>>>>>>>>>> way that HHHn correctly predicts the behavior of EEE. >>>>>>>>>>>>>
Nope, HHHn can form a valid inductive proof of the input. >>>>>>>>>>>>
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn
but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory,
if that differs, it is a DIFFERENT input, and needs to be so marked. >>>>>>>>>>
You are just admittig that you are just stupid and think two things >>>>>>>>>> that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> 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
Right, so the decider needs top be able to show that its exact input >>>>>>>> will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>
Of course it means that, because Professoer Sipser would have presumed >>>>>> that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the >>>>>> final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it will >>>> act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of the >>>> decider, the one that doesn't abort as the hypothetical, and the one
that does as the actual (if the hypothical one doesn't halt).
The key is that both get the EXACT SAME input, the DDD that calls the
HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs to be >>>> solved by correct LOGIC, thus the "hypothetical" machine never actaully >>>> needs to exist, but the actual machine needs to be able to prove what
it would do with the EXACT input that was given, and not just the
matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH.
The test case is giving HHH∞ the input DDD that calls the HHH that you >>>> want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort its
simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
Nope. It is factual. That you can't understand it shows your stupidity.
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Nope. That is just illogical, and your claims make you just a liar.
Your weasel words around this may simply be your ADD.
You are just IGNORANT of what the words mean, which you prove by saying
they can;t mean what they do means just because you dont want them to
mean it.
First, your HHH/DDD setup is INVALID in computatio theory, The *PROGRAM*
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
On 8/20/2024 9:53 PM, Richard Damon wrote:
On 8/20/24 10:44 PM, olcott wrote:
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
But it can't emulate DDD correctly past 4 instructions, >>>>>>>>>>>> since the 5th instruciton to emulate doesn't exist.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>
And, you can't include the memory that holds HHH, as you >>>>>>>>>>>> mention HHHn below, so that changes, but DDD, so the input >>>>>>>>>>>> doesn't and thus is CAN'T be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the >>>>>>>>>>>>> x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>> Thus making all of the code of HHH directly available to >>>>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the >>>>>>>>>>>> input, that input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn >>>>>>>>>>>> is available to HHHn when it emulates its input, that DDD >>>>>>>>>>>> must actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the >>>>>>>>>>>> x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non- >>>>>>>>>> halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't >>>>>>>>>>>> have Y so you don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same >>>>>>>>>>>>> way that HHHn correctly predicts the behavior of EEE. >>>>>>>>>>>>>
Nope, HHHn can form a valid inductive proof of the input. >>>>>>>>>>>>
It can't for DDDn, since when we move to HHHn+1 we no longer >>>>>>>>>>>> have DDDn but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the >>>>>>>>>> memory, if that differs, it is a DIFFERENT input, and needs to >>>>>>>>>> be so marked.
You are just admittig that you are just stupid and think two >>>>>>>>>> things that are different are the same.
*attempts to use misdirection to weasel word around this are >>>>>>>>> dismissed*
*attempts to use misdirection to weasel word around this are >>>>>>>>> dismissed*
*attempts to use misdirection to weasel word around this are >>>>>>>>> dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
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
Right, so the decider needs top be able to show that its exact >>>>>>>> input will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Of course it means that, because Professoer Sipser would have
presumed that you built the machines PROPERLY, so that you COULD
think of changing THIS H to be non-aborting, while the input still >>>>>> used the final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it
will act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of
the decider, the one that doesn't abort as the hypothetical, and the
one that does as the actual (if the hypothical one doesn't halt).
The key is that both get the EXACT SAME input, the DDD that calls
the HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs to
be solved by correct LOGIC, thus the "hypothetical" machine never
actaully needs to exist, but the actual machine needs to be able to
prove what it would do with the EXACT input that was given, and not
just the matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH.
The test case is giving HHH∞ the input DDD that calls the HHH that
you want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort its
simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
Nope. It is factual. That you can't understand it shows your stupidity.
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Nope. That is just illogical, and your claims make you just a liar.
Your weasel words around this may simply be your ADD.
You are just IGNORANT of what the words mean, which you prove by
saying they can;t mean what they do means just because you dont want
them to mean it.
First, your HHH/DDD setup is INVALID in computatio theory, The *PROGRAM*
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
That you can't even stick to that point may be an ADD issue.
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
(b) As measured by the correct partial simulation of D by H
(c) When H would never abort its simulation of F
(d) This includes H simulating itself simulating D
On 8/21/2024 6:11 AM, Richard Damon wrote:
On 8/20/24 11:01 PM, olcott wrote:
On 8/20/2024 9:53 PM, Richard Damon wrote:
On 8/20/24 10:44 PM, olcott wrote:
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is* >>>>>>>>>>>>>>> *specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
But it can't emulate DDD correctly past 4 instructions, >>>>>>>>>>>>>> since the 5th instruciton to emulate doesn't exist. >>>>>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>>>
And, you can't include the memory that holds HHH, as you >>>>>>>>>>>>>> mention HHHn below, so that changes, but DDD, so the input >>>>>>>>>>>>>> doesn't and thus is CAN'T be part of the input.
And neither X or Y are possible.
X = DDD emulated by HHH∞ according to the semantics of >>>>>>>>>>>>>>> the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z >>>>>>>>>>>>>>
Which is irrelevent and a LIE as if HHHn is part of the >>>>>>>>>>>>>> input, that input needs to be DDDn
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>> Thus making all of the code of HHH directly available to >>>>>>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD. >>>>>>>>>>>>>>
And, in fact,
Since, you have just explicitly introduced that all of >>>>>>>>>>>>>> HHHn is available to HHHn when it emulates its input, that >>>>>>>>>>>>>> DDD must actually be DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of >>>>>>>>>>>>>> the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z >>>>>>>>>>>>>>
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non- >>>>>>>>>>>> halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't >>>>>>>>>>>>>> have Y so you don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same >>>>>>>>>>>>>>> way that HHHn correctly predicts the behavior of EEE. >>>>>>>>>>>>>>>
Nope, HHHn can form a valid inductive proof of the input. >>>>>>>>>>>>>>
It can't for DDDn, since when we move to HHHn+1 we no >>>>>>>>>>>>>> longer have DDDn but DDDn+1, which is a different input. >>>>>>>>>>>>>>
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all >>>>>>>>>>>> the memory, if that differs, it is a DIFFERENT input, and >>>>>>>>>>>> needs to be so marked.
You are just admittig that you are just stupid and think two >>>>>>>>>>>> things that are different are the same.
*attempts to use misdirection to weasel word around this are >>>>>>>>>>> dismissed*
*attempts to use misdirection to weasel word around this are >>>>>>>>>>> dismissed*
*attempts to use misdirection to weasel word around this are >>>>>>>>>>> dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
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
Right, so the decider needs top be able to show that its exact >>>>>>>>>> input will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>>>>>> specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Of course it means that, because Professoer Sipser would have
presumed that you built the machines PROPERLY, so that you COULD >>>>>>>> think of changing THIS H to be non-aborting, while the input
still used the final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it
will act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of >>>>>> the decider, the one that doesn't abort as the hypothetical, and
the one that does as the actual (if the hypothical one doesn't halt). >>>>>>
The key is that both get the EXACT SAME input, the DDD that calls
the HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs
to be solved by correct LOGIC, thus the "hypothetical" machine
never actaully needs to exist, but the actual machine needs to be
able to prove what it would do with the EXACT input that was
given, and not just the matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH. >>>>>>
The test case is giving HHH∞ the input DDD that calls the HHH that >>>>>> you want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort
its simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
Nope. It is factual. That you can't understand it shows your stupidity. >>>>
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Nope. That is just illogical, and your claims make you just a liar.
Your weasel words around this may simply be your ADD.
You are just IGNORANT of what the words mean, which you prove by
saying they can;t mean what they do means just because you dont want
them to mean it.
First, your HHH/DDD setup is INVALID in computatio theory, The
*PROGRAM*
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
That you can't even stick to that point may be an ADD issue.
Of course he did. But for D that calls H that means what a simulation
of THAT EXACT input would do if not aborted, including the behavior of
the H that will possibly eventually abort (since that IS what the
input would do).
No. This is your lack of software engineering skill.
Mike understands this:
Each HHH has seen one more execution trace than the next inner HHH.
Thus when the outermost one waits for its inner on to abort this
forms an infinite chain or waiting with none of them ever aborting.
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
(b) As measured by the correct partial simulation of D by H
(c) When H would never abort its simulation of F
(d) This includes H simulating itself simulating D
Your words are so obviously crooked that only fool can be fooled.
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which includes
ALL the code of everything it calls, which includes H, so with your
system, changing H gives a DIFFERENT input, which is not comparable in
behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by H
if possible, if the COMPLETE simulaiton by a "hypothetical H"
replacing H but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED emulation
of its input, and if, and only if, it can determine that such an
emulation would never halt, then it can abort its emulation.
Note, that is the emulation of this exact input, including D calling
the ORIGINAL H, not changing to the Hypothetical, since by the rules
of the field, the input is a fixed string, and fully defines the
behavior of the input.
Your ADD prevents you from paying enough attention to see
that you are contradicting yourself.
Mike seems to do the same thing yet not because of ADD
it seems to be out of pure disrespect for me.
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which includes
ALL the code of everything it calls, which includes H, so with your
system, changing H gives a DIFFERENT input, which is not comparable in
behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by H
if possible, if the COMPLETE simulaiton by a "hypothetical H"
replacing H but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED emulation
of its input, and if, and only if, it can determine that such an
emulation would never halt, then it can abort its emulation.
Note, that is the emulation of this exact input, including D calling
the ORIGINAL H, not changing to the Hypothetical, since by the rules
of the field, the input is a fixed string, and fully defines the
behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> If simulating halt decider H correctly simulates its input D >>>>> until H correctly determines that its simulated D would never >>>>> stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which
includes ALL the code of everything it calls, which includes H, so
with your system, changing H gives a DIFFERENT input, which is not
comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by H
if possible, if the COMPLETE simulaiton by a "hypothetical H"
replacing H but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED
emulation of its input, and if, and only if, it can determine that
such an emulation would never halt, then it can abort its emulation.
Note, that is the emulation of this exact input, including D calling
the ORIGINAL H, not changing to the Hypothetical, since by the rules
of the field, the input is a fixed string, and fully defines the
behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that you
are a liar trying to create an ad hominem attack that failed.
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Ben saw this right away and it seems that most everyone
else simply lied about it.
Your problem is you don't know what the words mean, and when someone
uses something that confuses you because you don't understand the
words, rathrer than try to find out what it is you don't understand,
you try to put the other person down.
Sorry, that just proves you are a stupid idiot that doesn't know what
you are talking about.
That means your chance of actually doing what you claim you want to do
is about that of a snowflake in Hell, which you just might get the
chance to see if it can happen.
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text >>>>>>>> is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous >>>>>>>> word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
If simulating halt decider H correctly simulates its input D >>>>>>> until H correctly determines that its simulated D would never >>>>>>> stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which
includes ALL the code of everything it calls, which includes H, so >>>>>> with your system, changing H gives a DIFFERENT input, which is not >>>>>> comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by >>>>>> H if possible, if the COMPLETE simulaiton by a "hypothetical H"
replacing H but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy. >>>>>>
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED
emulation of its input, and if, and only if, it can determine that >>>>>> such an emulation would never halt, then it can abort its emulation. >>>>>>
Note, that is the emulation of this exact input, including D
calling the ORIGINAL H, not changing to the Hypothetical, since by >>>>>> the rules of the field, the input is a fixed string, and fully
defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that you
are a liar trying to create an ad hominem attack that failed.
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
What "change of subject", I just point out what the words you try to
use actually mean, and why your claims are wrong by the rules of the
system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't say
you are wrong because you are stupid, you are wrong because the words
you use don't mean what you think they do, and thus your conclusions
are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an
unlimited simulation of this EXACT input, which means that it must
call the H that you claim to be getting the right answer, which is the
H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
On 8/21/2024 1:21 PM, Fred. Zwarts wrote:
Op 21.aug.2024 om 14:35 schreef olcott:
No. This is your lack of software engineering skill.
Mike understands this:
Each HHH has seen one more execution trace than the next inner HHH.
Thus when the outermost one waits for its inner on to abort this
forms an infinite chain or waiting with none of them ever aborting.
Yes, HHH cannot possibly simulate itself correctly. If it aborts, it
aborts too soon, one cycle before the simulated HHH would abort and
halt. But if it waits for completion, it waits forever. There is no
correct way for a simulator to simulate itself correctly.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH only needs to simulate itself simulating DDD once to
correctly determine that its simulated DDD would
never stop running unless aborted...
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text >>>>>>>>>> is not a part of the agreement. What H is required to predict >>>>>>>>>> is fully determined by the words "halt decider H". The previous >>>>>>>>>> word "simulating" refers to an implementation detail and does >>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
If simulating halt decider H correctly simulates its input D >>>>>>>>> until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>>>> specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which
includes ALL the code of everything it calls, which includes H, >>>>>>>> so with your system, changing H gives a DIFFERENT input, which >>>>>>>> is not comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D >>>>>>>> by H if possible, if the COMPLETE simulaiton by a "hypothetical >>>>>>>> H" replacing H but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of
fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED
emulation of its input, and if, and only if, it can determine
that such an emulation would never halt, then it can abort its >>>>>>>> emulation.
Note, that is the emulation of this exact input, including D
calling the ORIGINAL H, not changing to the Hypothetical, since >>>>>>>> by the rules of the field, the input is a fixed string, and
fully defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that
you are a liar trying to create an ad hominem attack that failed.
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
What "change of subject", I just point out what the words you try to
use actually mean, and why your claims are wrong by the rules of the
system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't say
you are wrong because you are stupid, you are wrong because the
words you use don't mean what you think they do, and thus your
conclusions are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an
unlimited simulation of this EXACT input, which means that it must
call the H that you claim to be getting the right answer, which is
the H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why the
Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
On 8/21/2024 1:30 PM, Fred. Zwarts wrote:
Op 21.aug.2024 om 14:30 schreef olcott:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which is only complete if it includes all functions called by D.
Including the H that has the same behaviour as the simulating H.
(b) As measured by the correct partial simulation of D by H
Which does not really give a clue, because either a full simulation is
needed, or an algorithm that detects non-halting.
(c) When H would never abort its simulation of F
No, it must predict the behaviour of the input, including the H that
makes a partial simulation, not the behaviour of a hypothetical non-
input that does not abort. This means to predict the behaviour of the
D with the H that is called by D with the same behaviour as the
simulating H. No cheating with a Root variable to give the simulated H
a behaviour different from the simulating H.
(d) This includes H simulating itself simulating D
Itself, means the H with the same behaviour as the simulating H, i.e.
doing a partial simulation.
Anything else is cheating and making a prediction for a non-input.
You keep missing the idea that HHH does a partial
simulation of DDD to predict what would happen if
this HHH never aborted its simulation of DDD.
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:
Op 22.aug.2024 om 06:22 schreef olcott:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
We swap the word "determines" for "predicts"
On 8/22/2024 3:21 AM, Fred. Zwarts wrote:
Op 21.Aug.2024 OM 20:52 olcott:
You keep missing the idea that HHH must predict the behaviour of its
You keep missing the idea that HHH does a partial
simulation of DDD to predict what would happen if
this HHH never aborted its simulation of DDD.
input (the HHH that does a partial simulation), not the behaviour of a
different hypothetical non-input (the HHH that never aborted).
The would be stupid. If that was the case then HHH could ignore
its input and accept every input as halting including this one:
void Infinite_Loop()
{
HERE: goto HERE;
}
There is a reason why HHH has an input. If it were correct to predict
the behaviour of a hypothetical non-input, then HHH would not need an
input.
That is stupid
Are you still cheating with the Root variable to change the behaviour
of HHH from an input to a non-input?
On 8/22/2024 3:21 AM, Fred. Zwarts wrote:
Op 21.Aug.2024 OM 20:52 olcott:
You keep missing the idea that HHH must predict the behaviour of its
You keep missing the idea that HHH does a partial
simulation of DDD to predict what would happen if
this HHH never aborted its simulation of DDD.
input (the HHH that does a partial simulation), not the behaviour of a
different hypothetical non-input (the HHH that never aborted).
The would be stupid.
If that was the case then HHH could ignore> its input and acceptevery input as halting including this one:
void Infinite_Loop()
{
HERE: goto HERE;
}
There is a reason why HHH has an input. If it were correct to predict
the behaviour of a hypothetical non-input, then HHH would not need an
input.
That is stupid
Are you still cheating with the Root variable to change the behaviour
of HHH from an input to a non-input?
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:
Op 22.aug.2024 om 06:22 schreef olcott:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
We swap the word "determines" for "predicts"
When we swap thew word "halt decider" for
"termination analyzer" the above is translated
from computer science into software engineering.
The second half proves that this is the H that aborts
that is making the prediction of the behavior of D when
emulated by a hypothetical version of itself then never
aborts.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
But that different hypothetical HHH is a non-input.
HHH is supposed to predict what the behavior of DDD would be
if it did not abort its emulation of DDD that is what the
words that Professor agreed to mean.
Do you still not understand that HHH should predict the behaviour of
its input? Why does the HHH have an input, if it is correct to predict
the behaviour of a non-input?
Are you still cheating with the Root variable to change the input in a
non-input?
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the 5th >>>>>> instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn >>>>>> below, so that changes, but DDD, so the input doesn't and thus is CAN'T >>>>>> be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that >>>>>> input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is
available to HHHn when it emulates its input, that DDD must actually be >>>>>> DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you >>>>>> don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn >>>>>> but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory, >>>> if that differs, it is a DIFFERENT input, and needs to be so marked.
You are just admittig that you are just stupid and think two things
that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the 5th >>>>>>>> instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn >>>>>>>> below, so that changes, but DDD, so the input doesn't and thus is CAN'T
be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that >>>>>>>> input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>> available to HHHn when it emulates its input, that DDD must actually be
DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting. >>>>>>
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you
don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn >>>>>>>> but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter.
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory, >>>>>> if that differs, it is a DIFFERENT input, and needs to be so marked. >>>>>>
You are just admittig that you are just stupid and think two things >>>>>> that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed* >>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> 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
Right, so the decider needs top be able to show that its exact input
will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Of course it means that, because Professoer Sipser would have presumed
that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the
final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Professor Sipser would not have construed that I am referring
to self-modifying code.
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
(b) As measured by the correct partial simulation of D by H
(c) When H would never abort its simulation of F
(d) This includes H simulating itself simulating D
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
But it can't emulate DDD correctly past 4 instructions, since the 5th
instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn
below, so that changes, but DDD, so the input doesn't and thus is CAN'T
be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to >>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that >>>>>>>>>> input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>>>> available to HHHn when it emulates its input, that DDD must actually be
DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non-halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you
don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same
way that HHHn correctly predicts the behavior of EEE.
Nope, HHHn can form a valid inductive proof of the input.
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn
but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory, >>>>>>>> if that differs, it is a DIFFERENT input, and needs to be so marked. >>>>>>>>
You are just admittig that you are just stupid and think two things >>>>>>>> that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed* >>>>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>>>> *attempts to use misdirection to weasel word around this are dismissed* >>>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>> 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
Right, so the decider needs top be able to show that its exact input >>>>>> will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
Of course it means that, because Professoer Sipser would have presumed >>>> that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the
final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it will
act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of the
decider, the one that doesn't abort as the hypothetical, and the one
that does as the actual (if the hypothical one doesn't halt).
The key is that both get the EXACT SAME input, the DDD that calls the
HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs to be
solved by correct LOGIC, thus the "hypothetical" machine never actaully
needs to exist, but the actual machine needs to be able to prove what
it would do with the EXACT input that was given, and not just the
matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH.
The test case is giving HHH∞ the input DDD that calls the HHH that you
want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort its
simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Your weasel words around this may simply be your ADD.
On 8/20/2024 9:53 PM, Richard Damon wrote:
On 8/20/24 10:44 PM, olcott wrote:
On 8/20/2024 8:56 PM, Richard Damon wrote:
On 8/20/24 9:17 PM, olcott wrote:
On 8/20/2024 7:50 PM, Richard Damon wrote:
On 8/20/24 7:28 PM, olcott wrote:
On 8/20/2024 6:18 PM, Richard Damon wrote:
On 8/20/24 9:09 AM, olcott wrote:
On 8/19/2024 11:02 PM, Richard Damon wrote:
On 8/19/24 11:50 PM, olcott wrote:
On 8/19/2024 10:32 PM, Richard Damon wrote:
On 8/19/24 10:47 PM, olcott wrote:
*Everything that is not expressly stated below is*
*specified as unspecified*
Looks like you still have this same condition.
I thought you said you removed it.
But it can't emulate DDD correctly past 4 instructions, since the 5th
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>
instruciton to emulate doesn't exist.
And, you can't include the memory that holds HHH, as you mention HHHn
below, so that changes, but DDD, so the input doesn't and thus is CAN'T
be part of the input.
X = DDD emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD
Z = DDD never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
And neither X or Y are possible.
x86utm takes the compiled Halt7.obj file of this c program >>>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>> Thus making all of the code of HHH directly available to >>>>>>>>>>>>> DDD and itself. HHH emulates itself emulating DDD.
Which is irrelevent and a LIE as if HHHn is part of the input, that
input needs to be DDDn
And, in fact,
Since, you have just explicitly introduced that all of HHHn is >>>>>>>>>>>> available to HHHn when it emulates its input, that DDD must actually be
DDDn as it changes.
Thus, your ACTUAL claim needs to be more like:
X = DDD∞ emulated by HHH∞ according to the semantics of the x86 language
Y = HHH∞ never aborts its emulation of DDD∞
Z = DDD∞ never stops running
The above claim boils down to this: (X ∧ Y) ↔ Z
Yes that is correct.
So, you only prove that the DDD∞ that calls the HHH∞ is non- halting.
Not any of the other DDDn
Your problem is that for any other DDDn / HHHn, you don't have Y so you
don't have Z.
void EEE()
{
HERE: goto HERE;
}
HHHn correctly predicts the behavior of DDD the same >>>>>>>>>>>>> way that HHHn correctly predicts the behavior of EEE. >>>>>>>>>>>>>
Nope, HHHn can form a valid inductive proof of the input. >>>>>>>>>>>>
It can't for DDDn, since when we move to HHHn+1 we no longer have DDDn
but DDDn+1, which is a different input.
You already agreed that (X ∧ Y) ↔ Z is correct.
Did you do an infinite trace in your mind?
But only for DDD∞, not any of the other ones.
If you can do it and I can do it then HHH can
do this same sort of thing. Computations are
not inherently dumber than human minds.
But HHHn isn't given DDD∞ as its input, so that doesn't matter. >>>>>>>>>>
HHHn is given DDDn as its input,
Remeber, since you said that the input to HHH includes all the memory,
if that differs, it is a DIFFERENT input, and needs to be so marked. >>>>>>>>>>
You are just admittig that you are just stupid and think two things >>>>>>>>>> that are different are the same.
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
*attempts to use misdirection to weasel word around this are dismissed*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> 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
Right, so the decider needs top be able to show that its exact input >>>>>>>> will not halt.
No it cannot possibly mean that or professor Sipser
would not agreed to the second half:
H can abort its simulation of D and correctly report that D >>>>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>
Of course it means that, because Professoer Sipser would have presumed >>>>>> that you built the machines PROPERLY, so that you COULD think of
changing THIS H to be non-aborting, while the input still used the >>>>>> final version that it always uses,
A machine cannot both abort and fail to abort an input
unless it modifies its own code dynamically.
Right, so HHH must do just one of them, and the DDD that calls it will >>>> act differently based on which one it is.
Professor Sipser would not have construed that I am referring
to self-modifying code.
Nope, just giving the exact same input to two different version of the >>>> decider, the one that doesn't abort as the hypothetical, and the one
that does as the actual (if the hypothical one doesn't halt).
The key is that both get the EXACT SAME input, the DDD that calls the
HHH that does abort.
The point is that your "reasoning" can't actually be done just by
experimentation, (as to experimentally show that the input when
correctly simulated will not halt take infinite time), but needs to be >>>> solved by correct LOGIC, thus the "hypothetical" machine never actaully >>>> needs to exist, but the actual machine needs to be able to prove what
it would do with the EXACT input that was given, and not just the
matching imput from the "template".
This means that he must have understood that HHHn(DDD)
is predicting the behavior of HHH∞.
Nope. That is just your stupidity.
In his case, there really IS just one DDD, and that DDD calls HHH.
The test case is giving HHH∞ the input DDD that calls the HHH that you >>>> want to call correct, which is the aborting one.
ANd then HHH∞ shows that HHH isn't actually authorixed to abort its
simulation, so was programmed incorrectly.
(1) That is mostly incoherent.
Nope. It is factual. That you can't understand it shows your stupidity.
(2) When you pay complete attention (if you can even do that)
You will see the Professor Sipser could have only been
referring to HHHn(DDD) predicting the behavior of HHH∞(DDD)
Nope. That is just illogical, and your claims make you just a liar.
Your weasel words around this may simply be your ADD.
You are just IGNORANT of what the words mean, which you prove by saying
they can;t mean what they do means just because you dont want them to
mean it.
First, your HHH/DDD setup is INVALID in computatio theory, The *PROGRAM*
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text
is not a part of the agreement. What H is required to predict
is fully determined by the words "halt decider H". The previous
word "simulating" refers to an implementation detail and does
not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which includes
ALL the code of everything it calls, which includes H, so with your
system, changing H gives a DIFFERENT input, which is not comparable in
behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by H if
possible, if the COMPLETE simulaiton by a "hypothetical H" replacing H
but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED emulation
of its input, and if, and only if, it can determine that such an
emulation would never halt, then it can abort its emulation.
Note, that is the emulation of this exact input, including D calling
the ORIGINAL H, not changing to the Hypothetical, since by the rules of
the field, the input is a fixed string, and fully defines the behavior
of the input.
Your ADD prevents you from paying enough attention to see
that you are contradicting yourself.
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen
if it never aborted.
Professor Sipser understood that what is not a part of the text >>>>>>>>>> is not a part of the agreement. What H is required to predict >>>>>>>>>> is fully determined by the words "halt decider H". The previous >>>>>>>>>> word "simulating" refers to an implementation detail and does >>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>>> If simulating halt decider H correctly simulates its input D >>>>>>>>> until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>>>>>> specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is crucial to the requirements in that it specifies that
H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which includes >>>>>>>> ALL the code of everything it calls, which includes H, so with your >>>>>>>> system, changing H gives a DIFFERENT input, which is not comparable in >>>>>>>> behavior to this input.
(b) As measured by the correct partial simulation of D by H
Nope, by H correctly predicting, with a partial simulation of D by H if
possible, if the COMPLETE simulaiton by a "hypothetical H" replacing H >>>>>>>> but not changing the input, would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of fantasy. >>>>>>>>
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED emulation >>>>>>>> of its input, and if, and only if, it can determine that such an >>>>>>>> emulation would never halt, then it can abort its emulation.
Note, that is the emulation of this exact input, including D calling >>>>>>>> the ORIGINAL H, not changing to the Hypothetical, since by the rules of
the field, the input is a fixed string, and fully defines the behavior >>>>>>>> of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that you are >>>>>> a liar trying to create an ad hominem attack that failed.
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
What "change of subject", I just point out what the words you try to
use actually mean, and why your claims are wrong by the rules of the
system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't say
you are wrong because you are stupid, you are wrong because the words
you use don't mean what you think they do, and thus your conclusions
are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an
unlimited simulation of this EXACT input, which means that it must call >>>> the H that you claim to be getting the right answer, which is the H
that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why the
Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:You are the only one to suppose that and you are twisting the words of
Op 22.aug.2024 om 06:22 schreef olcott:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
We swap the word "determines" for "predicts"
When we swap thew word "halt decider" for
"termination analyzer" the above is translated
from computer science into software engineering.
The second half proves that this is the H that aborts
that is making the prediction of the behavior of D when
emulated by a hypothetical version of itself then never
aborts.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
But that different hypothetical HHH is a non-input.
HHH is supposed to predict what the behavior of DDD would be
if it did not abort its emulation of DDD that is what the
words that Professor agreed to mean.
On 8/27/2024 3:23 AM, Mikko wrote:
On 2024-08-22 04:22:11 +0000, olcott said:
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD) >>>>>>>>>>>>> that does abort is supposed predict what would happen >>>>>>>>>>>>> if it never aborted.
Professor Sipser understood that what is not a part of the text >>>>>>>>>>>> is not a part of the agreement. What H is required to predict >>>>>>>>>>>> is fully determined by the words "halt decider H". The previous >>>>>>>>>>>> word "simulating" refers to an implementation detail and does >>>>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
If simulating halt decider H correctly simulates its >>>>>>>>>>> input D
until H correctly determines that its simulated D would >>>>>>>>>>> never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
It is crucial to the requirements in that it specifies that >>>>>>>>>>> H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which >>>>>>>>>> includes ALL the code of everything it calls, which includes >>>>>>>>>> H, so with your system, changing H gives a DIFFERENT input, >>>>>>>>>> which is not comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H >>>>>>>>>>Nope, by H correctly predicting, with a partial simulation of >>>>>>>>>> D by H if possible, if the COMPLETE simulaiton by a
"hypothetical H" replacing H but not changing the input, would >>>>>>>>>> never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of >>>>>>>>>> fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED >>>>>>>>>> emulation of its input, and if, and only if, it can determine >>>>>>>>>> that such an emulation would never halt, then it can abort its >>>>>>>>>> emulation.
Note, that is the emulation of this exact input, including D >>>>>>>>>> calling the ORIGINAL H, not changing to the Hypothetical,
since by the rules of the field, the input is a fixed string, >>>>>>>>>> and fully defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that >>>>>>>> you are a liar trying to create an ad hominem attack that failed. >>>>>>>>
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
What "change of subject", I just point out what the words you try
to use actually mean, and why your claims are wrong by the rules
of the system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't
say you are wrong because you are stupid, you are wrong because
the words you use don't mean what you think they do, and thus your >>>>>> conclusions are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an
unlimited simulation of this EXACT input, which means that it must >>>>>> call the H that you claim to be getting the right answer, which is >>>>>> the H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why the
Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
That is relevant only if the input specifies that the behaviour
of that different HHH is a part of the behaviour of DDD.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
_DDD()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] 6862210000 push 00002162
[0000216a] e853f4ffff call 000015c2
[0000216f] 83c404 add esp,+04
[00002172] 5d pop ebp
[00002173] c3 ret
Size in bytes:(0018) [00002173]
*limited to 20,000,000 instructions*
machine stack stack machine assembly
address address data code language
======== ======== ======== ========== ============= [00002182][00103806][00000000] 55 push ebp ; begin main
[00002183][00103806][00000000] 8bec mov ebp,esp [00002185][00103802][00002162] 6862210000 push 00002162 ; push DDD [0000218a][001037fe][0000218f] e833f4ffff call 000015c2 ; call HHH
New slave_stack at:1038aa
Begin Local Halt Decider Simulation Execution Trace Stored at:1138b2 [00002162][001138a2][001138a6] 55 push ebp [00002163][001138a2][001138a6] 8bec mov ebp,esp [00002165][0011389e][00002162] 6862210000 push 00002162 ; push DDD [0000216a][0011389a][0000216f] e853f4ffff call 000015c2 ; call HHH
New slave_stack at:14e2d2
[00002162][0015e2ca][0015e2ce] 55 push ebp [00002163][0015e2ca][0015e2ce] 8bec mov ebp,esp [00002165][0015e2c6][00002162] 6862210000 push 00002162 ; push DDD [0000216a][0015e2c2][0000216f] e853f4ffff call 000015c2 ; call HHH
New slave_stack at:15e372
[00002162][0016e36a][0016e36e] 55 push ebp [00002163][0016e36a][0016e36e] 8bec mov ebp,esp [00002165][0016e366][00002162] 6862210000 push 00002162 ; push DDD [0000216a][0016e362][0000216f] e853f4ffff call 000015c2 ; call HHH
New slave_stack at:16e412
[00002162][0017e40a][0017e40e] 55 push ebp [00002163][0017e40a][0017e40e] 8bec mov ebp,esp [00002165][0017e406][00002162] 6862210000 push 00002162 ; push DDD [0000216a][0017e402][0000216f] e853f4ffff call 000015c2 ; call HHH
Number of Instructions Executed(20000000) == 298507 Pages
On 8/27/2024 3:23 AM, Mikko wrote:And since DDD is calling an HHH that is programmed to detect the
On 2024-08-22 04:22:11 +0000, olcott said:
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD) >>>>>>>>>>>>> that does abort is supposed predict what would happen >>>>>>>>>>>>> if it never aborted.
Professor Sipser understood that what is not a part of the text >>>>>>>>>>>> is not a part of the agreement. What H is required to predict >>>>>>>>>>>> is fully determined by the words "halt decider H". The previous >>>>>>>>>>>> word "simulating" refers to an implementation detail and does >>>>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
If simulating halt decider H correctly simulates its >>>>>>>>>>> input D
until H correctly determines that its simulated D would >>>>>>>>>>> never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations. >>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
It is crucial to the requirements in that it specifies that >>>>>>>>>>> H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which >>>>>>>>>> includes ALL the code of everything it calls, which includes >>>>>>>>>> H, so with your system, changing H gives a DIFFERENT input, >>>>>>>>>> which is not comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H >>>>>>>>>>Nope, by H correctly predicting, with a partial simulation of >>>>>>>>>> D by H if possible, if the COMPLETE simulaiton by a
"hypothetical H" replacing H but not changing the input, would >>>>>>>>>> never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of >>>>>>>>>> fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED >>>>>>>>>> emulation of its input, and if, and only if, it can determine >>>>>>>>>> that such an emulation would never halt, then it can abort its >>>>>>>>>> emulation.
Note, that is the emulation of this exact input, including D >>>>>>>>>> calling the ORIGINAL H, not changing to the Hypothetical,
since by the rules of the field, the input is a fixed string, >>>>>>>>>> and fully defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting that >>>>>>>> you are a liar trying to create an ad hominem attack that failed. >>>>>>>>
I have been over this same point again and again and again and
your "rebuttal" is changing the subject or calling me stupid.
What "change of subject", I just point out what the words you try
to use actually mean, and why your claims are wrong by the rules
of the system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't
say you are wrong because you are stupid, you are wrong because
the words you use don't mean what you think they do, and thus your >>>>>> conclusions are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an
unlimited simulation of this EXACT input, which means that it must >>>>>> call the H that you claim to be getting the right answer, which is >>>>>> the H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why the
Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
That is relevant only if the input specifies that the behaviour
of that different HHH is a part of the behaviour of DDD.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
On 8/27/2024 3:23 AM, Mikko wrote:And since DDD is calling an HHH that is programmed to detect the
On 2024-08-22 04:22:11 +0000, olcott said:
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD) >>>>>>>>>>>>>>> that does abort is supposed predict what would happen >>>>>>>>>>>>>>> if it never aborted.
Professor Sipser understood that what is not a part of the >>>>>>>>>>>>>> text
is not a part of the agreement. What H is required to predict >>>>>>>>>>>>>> is fully determined by the words "halt decider H". The >>>>>>>>>>>>>> previous
word "simulating" refers to an implementation detail and does >>>>>>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>> 10/13/2022>
If simulating halt decider H correctly simulates its >>>>>>>>>>>>> input D
until H correctly determines that its simulated D >>>>>>>>>>>>> would never
stop running unless aborted then
H can abort its simulation of D and correctly report >>>>>>>>>>>>> that D
specifies a non-halting sequence of configurations. >>>>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>> 10/13/2022>
It is crucial to the requirements in that it specifies that >>>>>>>>>>>>> H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which >>>>>>>>>>>> includes ALL the code of everything it calls, which includes >>>>>>>>>>>> H, so with your system, changing H gives a DIFFERENT input, >>>>>>>>>>>> which is not comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H >>>>>>>>>>>>Nope, by H correctly predicting, with a partial simulation >>>>>>>>>>>> of D by H if possible, if the COMPLETE simulaiton by a >>>>>>>>>>>> "hypothetical H" replacing H but not changing the input, >>>>>>>>>>>> would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of >>>>>>>>>>>> fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED >>>>>>>>>>>> emulation of its input, and if, and only if, it can
determine that such an emulation would never halt, then it >>>>>>>>>>>> can abort its emulation.
Note, that is the emulation of this exact input, including D >>>>>>>>>>>> calling the ORIGINAL H, not changing to the Hypothetical, >>>>>>>>>>>> since by the rules of the field, the input is a fixed
string, and fully defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting >>>>>>>>>> that you are a liar trying to create an ad hominem attack that >>>>>>>>>> failed.
I have been over this same point again and again and again and >>>>>>>>> your "rebuttal" is changing the subject or calling me stupid. >>>>>>>>>
What "change of subject", I just point out what the words you
try to use actually mean, and why your claims are wrong by the >>>>>>>> rules of the system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't >>>>>>>> say you are wrong because you are stupid, you are wrong because >>>>>>>> the words you use don't mean what you think they do, and thus
your conclusions are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an >>>>>>>> unlimited simulation of this EXACT input, which means that it
must call the H that you claim to be getting the right answer, >>>>>>>> which is the H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why
the Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
That is relevant only if the input specifies that the behaviour
of that different HHH is a part of the behaviour of DDD.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as well and
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:*THIS IS YOUR REASONING*
And since DDD is calling an HHH that is programmed to detect the
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> 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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as well and >>>
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
If we don't do it this way then infinite loops always halt.
On 8/28/2024 9:38 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:46 schreef olcott:
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
And since DDD is calling an HHH that is programmed to detect the
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as
well and
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
Apparently you still do not understand that HHH should process its
input, not your dreams of a pure hypothetical non-input.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
In other words you are saying that HHH must report that
infinite loops halt even though halting is reaching a
final halt state and infinite loops cannot possibly reach
a final halt state.
Your replies have stepped over the line of an honest dialogue.
On 8/28/2024 10:14 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 16:53 schreef olcott:
On 8/28/2024 9:38 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:46 schreef olcott:
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
And since DDD is calling an HHH that is programmed to detect the >>>>>>>> 'special condition', so that it aborts and halts, DDD halts as >>>>>>>> well and
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
HHH is only required to correctly predict whether or not DDD >>>>>>>>> *would never stop running unless aborted*
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
Apparently you still do not understand that HHH should process its
input, not your dreams of a pure hypothetical non-input.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
In other words you are saying that HHH must report that
infinite loops halt even though halting is reaching a
final halt state and infinite loops cannot possibly reach
a final halt state.
Your replies have stepped over the line of an honest dialogue.
No, you are dishonest by putting words in my mouth that I did not say.
I said HHH should report that a *halting* program halt.
You make it that I said that HHH must report that *infinite loops* halt.
HHH must report on what the behavior of its input
WOULD BE if it never aborted it emulation.
Neither DDD nor Infinite_Loop can possibly reach
their own final halt state NO MATTER WHAT HHH DOES..
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
REACH FINAL HALT STATE
On 8/28/2024 11:23 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 17:18 schreef olcott:
On 8/28/2024 10:14 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 16:53 schreef olcott:
On 8/28/2024 9:38 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:46 schreef olcott:
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:HHH simulates DDD until it has inductive evidence that
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
And since DDD is calling an HHH that is programmed to detect >>>>>>>>>> the 'special condition', so that it aborts and halts, DDD
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>> 10/13/2022>
HHH is only required to correctly predict whether or not DDD >>>>>>>>>>> *would never stop running unless aborted*
halts as well and
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor. >>>>>>>
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
Apparently you still do not understand that HHH should process its >>>>>> input, not your dreams of a pure hypothetical non-input.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
In other words you are saying that HHH must report that
infinite loops halt even though halting is reaching a
final halt state and infinite loops cannot possibly reach
a final halt state.
Your replies have stepped over the line of an honest dialogue.
No, you are dishonest by putting words in my mouth that I did not say. >>>>
I said HHH should report that a *halting* program halt.
You make it that I said that HHH must report that *infinite loops*
halt.
HHH must report on what the behavior of its input
WOULD BE if it never aborted it emulation.
No, that is your error.
Read the specs a few more hundred times until
you notice exactly what the words actually say.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
*would never stop running unless aborted*
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
On 8/27/2024 3:23 AM, Mikko wrote:And since DDD is calling an HHH that is programmed to detect the
On 2024-08-22 04:22:11 +0000, olcott said:
On 8/21/2024 10:35 PM, Richard Damon wrote:
On 8/21/24 11:26 PM, olcott wrote:
On 8/21/2024 9:06 PM, Richard Damon wrote:
On 8/21/24 9:55 PM, olcott wrote:
On 8/21/2024 8:45 PM, Richard Damon wrote:
On 8/21/24 9:23 PM, olcott wrote:
On 8/21/2024 7:00 PM, Richard Damon wrote:
On 8/21/24 8:30 AM, olcott wrote:
On 8/21/2024 3:01 AM, Mikko wrote:
On 2024-08-21 03:01:38 +0000, olcott said:
*We are only talking about one single point*
Professor Sipser must have understood that an HHH(DDD) >>>>>>>>>>>>>>> that does abort is supposed predict what would happen >>>>>>>>>>>>>>> if it never aborted.
Professor Sipser understood that what is not a part of the >>>>>>>>>>>>>> text
is not a part of the agreement. What H is required to predict >>>>>>>>>>>>>> is fully determined by the words "halt decider H". The >>>>>>>>>>>>>> previous
word "simulating" refers to an implementation detail and does >>>>>>>>>>>>>> not affect the requirements.
<MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>> 10/13/2022>
If simulating halt decider H correctly simulates its >>>>>>>>>>>>> input D
until H correctly determines that its simulated D >>>>>>>>>>>>> would never
stop running unless aborted then
H can abort its simulation of D and correctly report >>>>>>>>>>>>> that D
specifies a non-halting sequence of configurations. >>>>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words >>>>>>>>>>>>> 10/13/2022>
It is crucial to the requirements in that it specifies that >>>>>>>>>>>>> H is required to predict
(a) The behavior specified by the finite string D
Which must include *ALL* of the code of the PROGRAM D, which >>>>>>>>>>>> includes ALL the code of everything it calls, which includes >>>>>>>>>>>> H, so with your system, changing H gives a DIFFERENT input, >>>>>>>>>>>> which is not comparable in behavior to this input.
(b) As measured by the correct partial simulation of D by H >>>>>>>>>>>>Nope, by H correctly predicting, with a partial simulation >>>>>>>>>>>> of D by H if possible, if the COMPLETE simulaiton by a >>>>>>>>>>>> "hypothetical H" replacing H but not changing the input, >>>>>>>>>>>> would never halt.
(c) When H would never abort its simulation of F
Which, since that isn't the case, put you into the realm of >>>>>>>>>>>> fantasy.
(d) This includes H simulating itself simulating D
Right, H must CORRECTLY predict the behavior of an UNABORTED >>>>>>>>>>>> emulation of its input, and if, and only if, it can
determine that such an emulation would never halt, then it >>>>>>>>>>>> can abort its emulation.
Note, that is the emulation of this exact input, including D >>>>>>>>>>>> calling the ORIGINAL H, not changing to the Hypothetical, >>>>>>>>>>>> since by the rules of the field, the input is a fixed
string, and fully defines the behavior of the input.
You are contradicting yourself.
Your ADD may prevent you from
concentrating well enough to see this.
I was right, you couldn't name it so you are just admiting >>>>>>>>>> that you are a liar trying to create an ad hominem attack that >>>>>>>>>> failed.
I have been over this same point again and again and again and >>>>>>>>> your "rebuttal" is changing the subject or calling me stupid. >>>>>>>>>
What "change of subject", I just point out what the words you
try to use actually mean, and why your claims are wrong by the >>>>>>>> rules of the system you claim to be working in.
The fact that you don't understand DOES make you stupid. I don't >>>>>>>> say you are wrong because you are stupid, you are wrong because >>>>>>>> the words you use don't mean what you think they do, and thus
your conclusions are just incorrect.
That you seem to NEVER LEARN is what makes you stupid.
Professor Sipser clearly agreed that an H that does
a finite simulation of D is to predict the behavior
of an unlimited simulation of D.
Right, H needs to predict in a finite number of steps, what an >>>>>>>> unlimited simulation of this EXACT input, which means that it
must call the H that you claim to be getting the right answer, >>>>>>>> which is the H that does abort and return non-halting.
OK then you seem to have this correctly, unless you interpret
this as a self-contradiction.
Why do you think it could be a self-contradiction?
It is an impossiblity for H to correctly due it, but that is why
the Halting Problem is non-computable.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA
The finite HHH(DDD) emulates itself emulating DDD exactly once
and this is sufficient for this HHH to predict what a different
HHH(DDD) do that never aborted its emulation of its input.
That is relevant only if the input specifies that the behaviour
of that different HHH is a part of the behaviour of DDD.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as well and
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
When the emulation of DDD is aborted
THIS DOES NOT COUNT AS DDD HALTING
Unless I repeat things too many times Richard
never sees that I said anything because Richard
has ADD. Maybe you have the same problem?
the simulated DDD would halt as well if not aborted (but keeping the
aborting input) and there is no need to abort a halting function.
That it halts is proved by the direct execution and by the correct
simulation by HHH1.
But HHH cannot possibly simulate *itself*, because when it aborts, it
aborts one cycle too soon.
Therefore, its prediction is wrong.
The problem is not the simulation, but the algorithm to detects this
'special condition'. This algorithm is trying to detect non-halting
behaviour. It that algorithm would be correct, then the problem would
be solved. But the proven halting theorem tells us that no such
algorithm exists.
Therefore, the discussion should not be about the simulation, but
about this algorithm that detects the 'special condition'.
But it seems that olcott hides this algorithm, maybe, because he knows
it is incorrect, and he tries to shift the discussion to whether the
simulation is correct or not.
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:*THIS IS YOUR REASONING*
And since DDD is calling an HHH that is programmed to detect the
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> 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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as well and >>>
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
If we don't do it this way then infinite loops always halt.
On 8/29/2024 2:35 AM, Mikko wrote:
On 2024-08-28 12:46:42 +0000, olcott said:
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:
And since DDD is calling an HHH that is programmed to detect the
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
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
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as
well and
*THIS IS YOUR REASONING*
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
If we don't do it this way then infinite loops always halt.
I would consider the infinite loops that always halt a more useful
result.
A halt decider that always ignores its input and reports
halting is more useful? A decider such as mine would prevent
Denial Of Service (DOS) attacks. Permitting DOS attacks
is less useful.
On 8/29/2024 2:35 AM, Mikko wrote:
On 2024-08-28 12:46:42 +0000, olcott said:
On 8/28/2024 7:34 AM, Fred. Zwarts wrote:
Op 28.aug.2024 om 14:07 schreef olcott:
On 8/28/2024 4:00 AM, Fred. Zwarts wrote:
Op 27.aug.2024 om 15:32 schreef olcott:*THIS IS YOUR REASONING*
And since DDD is calling an HHH that is programmed to detect the
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>> 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
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>>>
HHH is only required to correctly predict whether or not DDD
*would never stop running unless aborted*
'special condition', so that it aborts and halts, DDD halts as well and >>>>>
If you are hungry and never eat you will remain hungry.
You are hungry and eat becoming no longer hungry.
*This proves that you never needed to eat*
No, apparently, your understanding of logic English is very poor.
HHH simulates DDD until it has inductive evidence that
in the purely hypothetical case where a different HHH
would never abort its emulation of DDD that DDD would
never terminate normally.
If we don't do it this way then infinite loops always halt.
I would consider the infinite loops that always halt a more useful result. >>
A halt decider that always ignores its input and reports
halting is more useful?
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 154:33:13 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,848 |