On 8/21/2024 3:01 AM, Mikko wrote:That is not a recursive simulation.
On 2024-08-21 03:01:38 +0000, olcott said:
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen if it never
aborted.
*if D actually calls the H that aborts (=halts and returns)Professor Sipser understood that what is not a part of the text is not<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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.
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 isc is wrong. H does abort, and so does it when called by D.
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 1:30 PM, Fred. Zwarts wrote:That HHH is not simulating itself.
Op 21.aug.2024 om 14:30 schreef olcott:
On 8/21/2024 3:01 AM, Mikko wrote:Which is only complete if it includes all functions called by D.
On 2024-08-21 03:01:38 +0000, olcott said:<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
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>
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
Including the H that has the same behaviour as the simulating H.
(b) As measured by the correct partial simulation of D by HWhich 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 FNo, 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.
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(d) This includes H simulating itself simulating DItself, 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.
DDD.
On 8/21/2024 1:30 PM, joes wrote:
Am Wed, 21 Aug 2024 07:30:36 -0500 schrieb olcott:
On 8/21/2024 3:01 AM, Mikko wrote:That is not a recursive simulation.
On 2024-08-21 03:01:38 +0000, olcott said:
Professor Sipser must have understood that an HHH(DDD)
that does abort is supposed predict what would happen if it never
aborted.
*if D actually calls the H that aborts (=halts and returns)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<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
determined by the words "halt decider H". The previous word
"simulating" refers to an implementation detail and does not affect the >>>> requirements.
     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 isc is wrong. H does abort, and so does it when called by D.
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
The subject is not right or wrong, the subject
is what this guy: https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
(Professor Sipser) agreed to.
Your words are so obviously crooked that only fool can be fooled.
On 8/22/2024 3:21 AM, Fred. Zwarts wrote:But that program doesn’t call its own (aborting) simulator HHH.
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;
}
Yes, it would.There is a reason why HHH has an input. If it were correct to predictThat is stupid
the behaviour of a hypothetical non-input, then HHH would not need an
input.
--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:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be if it didTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD)But that different hypothetical HHH is a non-input.
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.
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/22/2024 8:21 AM, joes wrote:bla bla
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
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.
But still emulating a D that calls an aborting H.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.
It is also not the simulator (since they are the same).THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finiteBut that different hypothetical HHH is a non-input.
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.
No; only if the same goes for the outermost one (but that doesn’t halt). Otherwise it is not simulating itself.I don't know how you twist words to get that. HHH is required to predictHHH is supposed to predict what the behavior of DDD would be if it didIf IT didn’t abort DDD calling its aborting self.
not abort its emulation of DDD that is what the words that Professor
agreed to mean.
the behavior of DDD as if every HHH had its abort code removed.
--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/21/2024 10:35 PM, Richard Damon wrote:That other HHH still has to simulate the HHH that aborts.
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:
It is crucial to the requirements in that it specifies that H is >>>>>>>>> required to predict (a) The behavior specified by the finite >>>>>>>>> string DWhich 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.
(d) This includes H simulating itself simulating DNote, 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.
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.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD) emulates itself emulating DDD exactly once and this is sufficient forWhy do you think it could be a self-contradiction?OK then you seem to have this correctly, unless you interpret this asProfessor Sipser clearly agreed that an H that does a finiteRight, H needs to predict in a finite number of steps, what an
simulation of D is to predict the behavior of an unlimited
simulation of D.
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.
a self-contradiction.
It is an impossiblity for H to correctly do it, but that is why the
Halting Problem is non-computable.
this HHH to predict what a different HHH(DDD) do that never aborted its emulation of its input.
On 8/21/2024 8:45 PM, Richard Damon wrote:What’s the contradiction?
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:
You are contradicting yourself.(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.
On the contrary, we are talking in circles.I have been over this same point again and again and again and your "rebuttal" is changing the subject or calling me stupid.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.
Professor Sipser clearly agreed that an H that does a finite simulationIf the simulator *itself* would not abort. The H called by D is,
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.I don’t think you understood him.
Nice.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.
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/22/2024 12:28 PM, joes wrote:
Am Wed, 21 Aug 2024 23:22:11 -0500 schrieb olcott:
On 8/21/2024 10:35 PM, Richard Damon wrote:That other HHH still has to simulate the HHH that aborts.
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:
It is crucial to the requirements in that it specifies that H is >>>>>>>>>>> required to predict (a) The behavior specified by the finite >>>>>>>>>>> string DWhich 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.
(d) This includes H simulating itself simulating DNote, 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.
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.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD)Why do you think it could be a self-contradiction?OK then you seem to have this correctly, unless you interpret this as >>>>> a self-contradiction.Professor Sipser clearly agreed that an H that does a finiteRight, H needs to predict in a finite number of steps, what an
simulation of D is to predict the behavior of an unlimited
simulation of D.
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.
It is an impossiblity for H to correctly do it, but that is why the
Halting Problem is non-computable.
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 not what the words mean.
HHH(DDD) simulates itself simulating DDD until
it has the basis to prove that this will keep
repeating until aborted. Then the outermost
directly executed HHH aborts its own DDD.
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
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.THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finiteBut that different hypothetical HHH is a non-input.
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.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be ifTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite >>>>>>>>> HHH(DDD)But that different hypothetical HHH is a non-input.
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.
it did
not abort its emulation of DDD that is what the words that Professor >>>>>>> agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
On 8/22/2024 9:31 PM, Richard Damon wrote:
On 8/22/24 9:39 PM, olcott wrote:
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be if >>>>>>>>> it didTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite >>>>>>>>>>> HHH(DDD)But that different hypothetical HHH is a non-input.
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.
not abort its emulation of DDD that is what the words that
Professor
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
Yes, it is, at least when you understand the TECHNICAL meaning of the
words in Computation Theory.
Termination analyzers in software engineering are
isomorphic to partial halt deciders in computer
science you really can't get away with saying otherwise
and not look foolish.
Something you are just IGNORANT of.
Sorry, you are just proving your utter stupidty by your instance of
talking about something you haven't actually studied by just think you
know.
On 8/22/2024 10:11 PM, Richard Damon wrote:
On 8/22/24 10:54 PM, olcott wrote:
On 8/22/2024 9:31 PM, Richard Damon wrote:
On 8/22/24 9:39 PM, olcott wrote:
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be >>>>>>>>>>> if it didTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The >>>>>>>>>>>>> finite HHH(DDD)But that different hypothetical HHH is a non-input.
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.
not abort its emulation of DDD that is what the words that >>>>>>>>>>> Professor
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
Yes, it is, at least when you understand the TECHNICAL meaning of
the words in Computation Theory.
Termination analyzers in software engineering are
isomorphic to partial halt deciders in computer
science you really can't get away with saying otherwise
and not look foolish.
Then they must follow the same rules (or you are lying that they are
isomoprhic).
Deciders of program behavior must be given PROGRAMS, which always
contain ALL of the code used by it, thus for DDD, it includes the HHH
that it calls.
It was ridiculous that you ever assumed otherwise.
Incomplete descriptions that just don't contain everything are just
incorrect.
Also, "Termination analyzers" are NOT the same thing as a Halt
Deciders, as the term "Termination Analyzers" refer to something that
decides if a given program will Halt on ALL POSSIBLE inputs, rather
than the specific given input that a Halt Decider decides on.
So you don't know what "isomorphic" means.
It does not mean identical in every respect.
Maybe "functionally equivalent" is easy for you.
Sorry, you are just proving your ignorance of what you are trying to
talk about.
It is not I that am proving ignorance.
You didn't know what "isomorphic means"
Something you are just IGNORANT of.
Sorry, you are just proving your utter stupidty by your instance of
talking about something you haven't actually studied by just think
you know.
On 8/22/2024 10:11 PM, Richard Damon wrote:
On 8/22/24 10:54 PM, olcott wrote:
On 8/22/2024 9:31 PM, Richard Damon wrote:
On 8/22/24 9:39 PM, olcott wrote:
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be if it didTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD)But that different hypothetical HHH is a non-input.
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.
not abort its emulation of DDD that is what the words that Professor
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
Yes, it is, at least when you understand the TECHNICAL meaning of the
words in Computation Theory.
Termination analyzers in software engineering are
isomorphic to partial halt deciders in computer
science you really can't get away with saying otherwise
and not look foolish.
Then they must follow the same rules (or you are lying that they are
isomoprhic).
Deciders of program behavior must be given PROGRAMS, which always
contain ALL of the code used by it, thus for DDD, it includes the HHH
that it calls.
It was ridiculous that you ever assumed otherwise.
Incomplete descriptions that just don't contain everything are just incorrect.
Also, "Termination analyzers" are NOT the same thing as a Halt
Deciders, as the term "Termination Analyzers" refer to something that
decides if a given program will Halt on ALL POSSIBLE inputs, rather
than the specific given input that a Halt Decider decides on.
So you don't know what "isomorphic" means.
It does not mean identical in every respect.
Maybe "functionally equivalent" is easy for you.
On 8/22/2024 11:59 AM, joes wrote:What happens when your main(HHH(DDD)) is simulated by HHH?
Am Thu, 22 Aug 2024 08:36:33 -0500 schrieb olcott:
On 8/22/2024 8:21 AM, joes wrote:But still emulating a D that calls an aborting H.
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:
Op 22.aug.2024 om 06:22 schreef olcott: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>
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.
How do you justify the use of a static variable?It is also not the simulator (since they are the same).THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIABut that different hypothetical HHH is a non-input.
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.
It <is> emulating the exact same code at the exact same machine address exactly twice.No; only if the same goes for the outermost one (but that doesn’tI don't know how you twist words to get that. HHH is required toHHH is supposed to predict what the behavior of DDD would be if itIf IT didn’t abort DDD calling its aborting self.
did not abort its emulation of DDD that is what the words that
Professor agreed to mean.
predict the behavior of DDD as if every HHH had its abort code
removed.
halt).
Otherwise it is not simulating itself.
--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/22/2024 7:54 PM, Richard Damon wrote:
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
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.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.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
PREDICT HYPOTHETICAL BEHAVIOR
On 8/22/2024 12:28 PM, joes wrote:Only IF it will in fact keep repeating, which is not the case.
Am Wed, 21 Aug 2024 23:22:11 -0500 schrieb olcott:That is not what the words mean.
On 8/21/2024 10:35 PM, Richard Damon wrote:That other HHH still has to simulate the HHH that aborts.
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:
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.
That you seem to NEVER LEARN is what makes you stupid.
THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD)Why do you think it could be a self-contradiction?OK then you seem to have this correctly, unless you interpret thisProfessor Sipser clearly agreed that an H that does a finiteRight, H needs to predict in a finite number of steps, what an
simulation of D is to predict the behavior of an unlimited
simulation of D.
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.
as a self-contradiction.
It is an impossiblity for H to correctly do it, but that is why the
Halting Problem is non-computable.
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.
HHH(DDD) simulates itself simulating DDD until it has the basis to prove
that this will keep repeating until aborted. Then the outermost directly executed HHH aborts its own DDD.
On 8/22/2024 12:30 PM, joes wrote:
Am Wed, 21 Aug 2024 20:55:52 -0500 schrieb olcott:
On 8/21/2024 8:45 PM, Richard Damon wrote:What’s the contradiction?
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:
You are contradicting yourself.(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.
On the contrary, we are talking in circles.I have been over this same point again and again and again and yourYour 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.
"rebuttal" is changing the subject or calling me stupid.
Professor Sipser clearly agreed that an H that does a finite simulationIf the simulator *itself* would not abort. The H called by D is,
of D is to predict the behavior of an unlimited simulation of D.
by construction, the same and *does* abort.
Ben saw this right away and it seems that most everyone else simply lied >>> about it.I don’t think you understood him.
He agreed to my own words that I spent two years carefully crafting.
I know what my own words mean.
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be if it didTHIS 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 abortedBut that different hypothetical HHH is a non-input.
its emulation of its input.
not abort its emulation of DDD that is what the words that Professor
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
On 8/22/2024 11:59 AM, joes wrote:
Am Thu, 22 Aug 2024 08:36:33 -0500 schrieb olcott:
On 8/22/2024 8:21 AM, joes wrote:bla bla
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
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.
But still emulating a D that calls an aborting H.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.
It is also not the simulator (since they are the same).THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finiteBut that different hypothetical HHH is a non-input.
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.
No; only if the same goes for the outermost one (but that doesn’t halt). >> Otherwise it is not simulating itself.I don't know how you twist words to get that. HHH is required to predict >>> the behavior of DDD as if every HHH had its abort code removed.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.If IT didn’t abort DDD calling its aborting self.
It <is> emulating the exact same code at the exact same
machine address exactly twice.
On 8/22/2024 7:54 PM, Richard Damon wrote:
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
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.THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finiteBut that different hypothetical HHH is a non-input.
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.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
On 8/22/2024 11:12 PM, Richard Damon wrote:
On 8/22/24 11:53 PM, olcott wrote:
On 8/22/2024 10:11 PM, Richard Damon wrote:
On 8/22/24 10:54 PM, olcott wrote:
On 8/22/2024 9:31 PM, Richard Damon wrote:
On 8/22/24 9:39 PM, olcott wrote:
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
not abort its emulation of DDD that is what the words that >>>>>>>>>>>>> ProfessorTHIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The >>>>>>>>>>>>>>> finite HHH(DDD)But that different hypothetical HHH is a non-input. >>>>>>>>>>>>> HHH is supposed to predict what the behavior of DDD would >>>>>>>>>>>>> be if it did
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.
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
Yes, it is, at least when you understand the TECHNICAL meaning of
the words in Computation Theory.
Termination analyzers in software engineering are
isomorphic to partial halt deciders in computer
science you really can't get away with saying otherwise
and not look foolish.
Then they must follow the same rules (or you are lying that they are
isomoprhic).
Deciders of program behavior must be given PROGRAMS, which always
contain ALL of the code used by it, thus for DDD, it includes the
HHH that it calls.
It was ridiculous that you ever assumed otherwise.
But you keep on trying to pass of your "DDD" that doesn't contain HHH
as your input.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
That code has been available for years, ask Mike to explain
it to you.
Incomplete descriptions that just don't contain everything are just
incorrect.
Also, "Termination analyzers" are NOT the same thing as a Halt
Deciders, as the term "Termination Analyzers" refer to something
that decides if a given program will Halt on ALL POSSIBLE inputs,
rather than the specific given input that a Halt Decider decides on.
So you don't know what "isomorphic" means.
It does not mean identical in every respect.
Maybe "functionally equivalent" is easy for you.
It means of the same form "iso" same, "morph" form.
So, how do you consider them functionally equivalent if they don't do
the same sort of thing.
Note, Termination analyzing is a MUCH tougher problem, and it CAN'T be
done by simple emulation, but must be done in a much more abstract
look at the operation.
Not for inputs that have no inputs.
Sorry, you are just proving your ignorance of what you are trying to
talk about.
It is not I that am proving ignorance.
You didn't know what "isomorphic means"
No, *YOU* DON'T seem to, as there seems to be more differences in your
comparison than similarities.
For example, NOTHING in the definiton of a "Termination Analzer" says
it is "Partial".
Saying partial only means that it is not all knowing.
It is just that the field understand that they must be partial as it
is impossible to do it completely.
See that you are not as dumb as your words make you seem.
Jst as most discussion of trying to Halt Decide will assume partial
results, unless specifically talking about the Halting Problem where
the precision is needed.
HHH is a termination analyzer for DDD and a full
halt decider with for the domain of consisting of
the finite string of the x86 machine code of DDD.
Something you are just IGNORANT of.
Sorry, you are just proving your utter stupidty by your instance
of talking about something you haven't actually studied by just
think you know.
Am Wed, 21 Aug 2024 20:55:52 -0500 schrieb olcott:
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.
If the simulator *itself* would not abort. The H called by D is,
by construction, the same and *does* abort.
Ben saw this right away and it seems that most everyone else simply liedI don’t think you understood him.
about it.
On 8/23/2024 2:24 AM, joes wrote:
Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:
On 8/22/2024 12:28 PM, joes wrote:
Am Wed, 21 Aug 2024 23:22:11 -0500 schrieb olcott:That is not what the words mean.
On 8/21/2024 10:35 PM, Richard Damon wrote:That other HHH still has to simulate the HHH that aborts.
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:
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.
That you seem to NEVER LEARN is what makes you stupid.
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 abortedWhy do you think it could be a self-contradiction?OK then you seem to have this correctly, unless you interpret this >>>>>>> as a self-contradiction.Professor Sipser clearly agreed that an H that does a finite >>>>>>>>> simulation of D is to predict the behavior of an unlimitedRight, 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.
simulation of D.
It is an impossiblity for H to correctly do it, but that is why the >>>>>> Halting Problem is non-computable.
its emulation of its input.
HHH(DDD) simulates itself simulating DDD until it has the basis to prove >>> that this will keep repeating until aborted. Then the outermost directly >>> executed HHH aborts its own DDD.
Only IF it will in fact keep repeating, which is not the case.
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Please pay much closer attention. I want to fully defend my
legacy before I die of POD24. I am not here to engage in head games.
<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
HHH is partially simulating itself, so it should at least return
that it halts.
joes <noreply@example.org> writes:
Am Wed, 21 Aug 2024 20:55:52 -0500 schrieb olcott:
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.
If the simulator *itself* would not abort. The H called by D is,
by construction, the same and *does* abort.
We don't really know what context Sipser was given. I got in touch at
the time so do I know he had enough context to know that PO's ideas were "wacky" and that had agreed to what he considered a "minor remark".
Since PO considers his words finely crafted and key to his so-called
work I think it's clear that Sipser did not take the "minor remark" he
agreed to to mean what PO takes it to mean! My own take if that he
(Sipser) read it as a general remark about how to determine some cases,
i.e. that D names an input that H can partially simulate to determine
it's halting or otherwise. We all know or could construct some such
cases.
I suspect he was tricked because PO used H and D as the names without
making it clear that D was constructed from H in the usual way (Sipser
uses H and D in at least one of his proofs). Of course, he is clued in enough know that, if D is indeed constructed from H like that, the
"minor remark" becomes true by being a hypothetical: if the moon is made
of cheese, the Martians can look forward to a fine fondue. But,
personally, I think the professor is more straight talking than that,
and he simply took as a method that can work for some inputs. That's
the only way is could be seen as a "minor remark" with being accused of
being disingenuous.
Ben saw this right away and it seems that most everyone else simply lied >>> about it.I don’t think you understood him.
I don't think PO even reads what people write. He certainly works hard
to avoid addressing any points made to him. I think it's true to say
that pretty much every paraphrase he attempts "X thinks ..." (usually
phrased as "so you are saying that black is white?") is garbage. Understanding what other people say is low in his priorities since they
must be wrong anyway.
(I refuse to have anything more to do with PO directly after he was unconscionably rude, but I do keep an eye out for my name in case he continues to smear it.)
On 8/23/2024 2:24 AM, joes wrote:It is the case only if you still cheat with the Root variable, which
Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:
On 8/22/2024 12:28 PM, joes wrote:
Am Wed, 21 Aug 2024 23:22:11 -0500 schrieb olcott:That is not what the words mean.
On 8/21/2024 10:35 PM, Richard Damon wrote:That other HHH still has to simulate the HHH that aborts.
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:
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.
That you seem to NEVER LEARN is what makes you stupid.
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 abortedWhy do you think it could be a self-contradiction?OK then you seem to have this correctly, unless you interpret this >>>>>>> as a self-contradiction.Professor Sipser clearly agreed that an H that does a finite >>>>>>>>> simulation of D is to predict the behavior of an unlimitedRight, 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.
simulation of D.
It is an impossiblity for H to correctly do it, but that is why the >>>>>> Halting Problem is non-computable.
its emulation of its input.
HHH(DDD) simulates itself simulating DDD until it has the basis to prove >>> that this will keep repeating until aborted. Then the outermost directly >>> executed HHH aborts its own DDD.
Only IF it will in fact keep repeating, which is not the case.
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
On 23/08/2024 22:07, Ben Bacarisse wrote:
joes <noreply@example.org> writes:
Am Wed, 21 Aug 2024 20:55:52 -0500 schrieb olcott:
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.
If the simulator *itself* would not abort. The H called by D is,
by construction, the same and *does* abort.
We don't really know what context Sipser was given. I got in touch at
the time so do I know he had enough context to know that PO's ideas were
"wacky" and that had agreed to what he considered a "minor remark".
Since PO considers his words finely crafted and key to his so-called
work I think it's clear that Sipser did not take the "minor remark" he
agreed to to mean what PO takes it to mean! My own take if that he
(Sipser) read it as a general remark about how to determine some cases,
i.e. that D names an input that H can partially simulate to determine
it's halting or otherwise. We all know or could construct some such
cases.
Exactly my reading. It makes Sipser's agreement natural, because it is
both correct [with sensible interpretation of terms], and moreover
describes an obvious strategy that a partial decider might use that can decide halting for some specific cases. No need for Sipser to be
deceptive or misleading here, when the truth suffices. (In particular
no need to employ "tricksy" vacuous truth get out clauses just to get
PO off his back as some have suggested.)
So that PO will have no cause to quote me as supporting his case: what Sipser understood he was agreeing to was NOT what PO interprets it as meaning. Sipser would not agree that the conclusion applies in PO's
HHH(DDD) scenario, where DDD halts.
On 2024-08-24 01:10:49 +0000, Mike Terry said:
On 23/08/2024 22:07, Ben Bacarisse wrote:
joes <noreply@example.org> writes:
Am Wed, 21 Aug 2024 20:55:52 -0500 schrieb olcott:
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.
If the simulator *itself* would not abort. The H called by D is,
by construction, the same and *does* abort.
We don't really know what context Sipser was given. I got in touch at
the time so do I know he had enough context to know that PO's ideas were >>> "wacky" and that had agreed to what he considered a "minor remark".
Since PO considers his words finely crafted and key to his so-called
work I think it's clear that Sipser did not take the "minor remark" he
agreed to to mean what PO takes it to mean! My own take if that he
(Sipser) read it as a general remark about how to determine some cases,
i.e. that D names an input that H can partially simulate to determine
it's halting or otherwise. We all know or could construct some such
cases.
Exactly my reading. It makes Sipser's agreement natural, because it is both correct [with
sensible interpretation of terms], and moreover describes an obvious strategy that a partial
decider might use that can decide halting for some specific cases. No need for Sipser to be
deceptive or misleading here, when the truth suffices. (In particular no need to employ "tricksy"
vacuous truth get out clauses just to get PO off his back as some have suggested.)
So that PO will have no cause to quote me as supporting his case: what Sipser understood he was
agreeing to was NOT what PO interprets it as meaning. Sipser would not agree that the conclusion
applies in PO's HHH(DDD) scenario, where DDD halts.
An important part of the agreement is "H correctly determines" which
does not happen in HHH(DDD).
On 8/21/2024 2:55 PM, joes wrote:
Am Wed, 21 Aug 2024 13:52:46 -0500 schrieb olcott:>> 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.
That HHH is not simulating itself.
<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/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
HHH is supposed to predict what the behavior of DDD would be if it didTHIS 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 abortedBut that different hypothetical HHH is a non-input.
its emulation of its input.
not abort its emulation of DDD that is what the words that Professor
agreed to mean.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
On 8/22/2024 8:26 PM, Richard Damon wrote:
On 8/22/24 9:21 PM, olcott wrote:
On 8/22/2024 7:54 PM, Richard Damon wrote:Nope, Predict the ACTUAL behavior.
On 8/22/24 9:36 AM, olcott wrote:
On 8/22/2024 8:21 AM, joes wrote:
Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:
On 8/22/2024 3:16 AM, Fred. Zwarts wrote:If IT didn’t abort DDD calling its aborting self.
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.
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.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.
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.
But that isn't the input, so that is just a LIE.
PREDICT HYPOTHETICAL BEHAVIOR
You are just admitting you are lying about the
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 158:06:46 |
| Calls: | 10,384 |
| Calls today: | 1 |
| Files: | 14,056 |
| Messages: | 6,416,482 |