typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
Simulating termination analyzers must report on the behavior
that their finite string input specifies thus HHH must report
that DDD correctly emulated by HHH remains stuck in recursive
simulation.
Everyone else seems to be flat out dishonest or totally ignorant.
At least one of my reviewers does not seem to understand that
infinite recursion does not halt.
On 7/1/2024 8:51 PM, Richard Damon wrote:
On 7/1/24 9:25 PM, olcott wrote:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Right.
Then why do you contradict yourself below? Did you forget to lie?
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
But only when you can actually PROVE that the full emulation of the
program would be non-halting.
Too late you already agreed.
You must have forgot to lie.
Simulating termination analyzers must report on the behavior
that their finite string input specifies thus HHH must report
that DDD correctly emulated by HHH remains stuck in recursive
simulation.
But if DDD WAS stuck in infinte recursion, so must be HHH, so it isn't
a decider.
Too late, you already agreed that HHH(DDD) is correct.
HHH can't have different behavior when emulated by HHH then when it isSure it is. If we don't do it that way then we stupidly
actually run.
The problem is that "Emulated by the Decider" is NOT a valid criteria
for the behavior of the input, since it isn't a function of just the
input.
ignore that HHH(DDD) must abort its emulation.
The "Behavior of the input" will be the behavior of the program the
input represents when it is run.
If we assume that then we stupidly ignore that
HHH(DDD) must abort its emulation.
Basically it is too late you forget to lie and told the truth
on the first point thus contradicting yourself on every other point.
On 7/1/2024 9:35 PM, Richard Damon wrote:
On 7/1/24 10:09 PM, olcott wrote:
On 7/1/2024 8:51 PM, Richard Damon wrote:
On 7/1/24 9:25 PM, olcott wrote:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Right.
Then why do you contradict yourself below? Did you forget to lie?
Because I didn't contradict my self or lie, as the programs are
different.
See what you agreed to by re-reading the words that
you agreed to and you will see that you forgot to lie
this time.
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
Simulating termination analyzers must report on the behavior
that their finite string input specifies thus HHH must report
that DDD correctly emulated by HHH remains stuck in recursive
simulation.
Everyone else seems to be flat out dishonest or totally ignorant.
At least one of my reviewers does not seem to understand that
infinite recursion does not halt.
int main()At the cost of not doing the full simulation. If you want it to terminate.
{
HHH(Infinite_Loop); HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows that when
HHH emulates the machine language of Infinite_Loop, Infinite_Recursion,
and DDD that it must abort these emulations so that itself can terminate normally.
When this is construed as non-halting criteria then simulatingIt gets the decider part right, but not the simulator part.
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
Simulating termination analyzers must report on the behavior that their finite string input specifies thus HHH must report that DDD correctly emulated by HHH remains stuck in recursive simulation.Of course we want the right answer, which is not whatever HHH makes up,
On 7/1/2024 10:09 PM, Richard Damon wrote:
On 7/1/24 10:52 PM, olcott wrote:
On 7/1/2024 9:35 PM, Richard Damon wrote:
On 7/1/24 10:09 PM, olcott wrote:
On 7/1/2024 8:51 PM, Richard Damon wrote:
On 7/1/24 9:25 PM, olcott wrote:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Right.
Then why do you contradict yourself below? Did you forget to lie?
Because I didn't contradict my self or lie, as the programs are
different.
See what you agreed to by re-reading the words that
you agreed to and you will see that you forgot to lie
this time.
Your streaching. You know what I mean, and if you want to get finicky,
I will pull out the doxens of LIES that you have implicitly admitted
to by not providing the references you claimed to have.
Yes, HHH must abort its emulation to return, but that doesn't mean
that THIS input in non-halting.
*I tricked you into forgetting to lie so you told the truth*
<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>
As Ben has already agreed to criteria has been met.
I could point out that it is IMPOSSIBLE for you HHH to actually
correctly do the emulation you claim on the input provided (since
there is no code provded to emulate the call HHH) so your question is
just invalid.
*You already know that I already provided this code* https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
On 7/2/2024 6:32 AM, joes wrote:So why must a pure simulator terminate?
Am Mon, 01 Jul 2024 20:25:40 -0500 schrieb olcott:
This <is> the problem that I am willing to discuss.Every C programmer that knows what an x86 emulator is knows that whenAt the cost of not doing the full simulation. If you want it to
HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations so
that itself can terminate normally.
terminate.
When this is construed as non-halting criteria then simulatingIt gets the decider part right, but not the simulator part.
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
Which is not what DDD does, since the HHH that it calls detects aSimulating termination analyzers must report on the behavior that
their finite string input specifies thus HHH must report that DDD
correctly emulated by HHH remains stuck in recursive simulation.
Do you understand the difference?Of course we want the right answer, which is not whatever HHH makes up,
but what the input DDD does by itself.
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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 relevant that it *does* abort. That is relevant when determining
whether it is correct.
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.
Therefore, whether or not it must abort, is incorrect criteria. The
fact that it *does* abort (and aborts too early to see correctly the
behaviour) shows that the simulation is incorrect.
Simulating termination analyzers must report on the behavior
that their finite string input specifies thus HHH must report
that DDD correctly emulated by HHH remains stuck in recursive
simulation.
It is not stuck in recursive simulation. We are speaking about an HHH
that *does* abort after two cycles. So, not stuck, the simulation is
only aborted too soon.
Dreaming of another HHH that got stuck because it does not abort is
irrelevant, because this HHH *does* abort.
Everyone else seems to be flat out dishonest or totally ignorant.
At least one of my reviewers does not seem to understand that
infinite recursion does not halt.
It is dishonest to claim that two equals infinite.
Two cycles of recursive simulation is not equal to an infinite recursion.
You don't seem to understand such simple facts.
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be irrelevant
does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation.
Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:Repeating the same thing that has already been proved to be
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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> >>>>
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation.
Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>> so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct
simulation. Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not correct.
Your problem is you just assume things to exist that don't, because
you don't understand what Truth actually means.
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(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
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>
*Professor Sipser would agree that HHH/DDD meets the above criteria*
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>>>> so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct
simulation. Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not
correct.
Your problem is you just assume things to exist that don't, because
you don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show Godel
wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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>
*Professor Sipser would agree that HHH/DDD meets the above criteria*
Your HHH that returns an answer does NOT "Correctly Simulate" its
input by the definition of producing the exact results of executing
the machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process https://inria.hal.science/hal-03404798/file/hipc2021.pdf
On 7/2/2024 8:25 PM, Richard Damon wrote:
On 7/2/24 9:18 PM, olcott wrote:
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these >>>>>>>>>>>>> emulations
so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be >>>>>>>>>> irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct
simulation. Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not
correct.
Your problem is you just assume things to exist that don't,
because you don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show
Godel wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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> >>>>>
*Professor Sipser would agree that HHH/DDD meets the above criteria* >>>>>
Your HHH that returns an answer does NOT "Correctly Simulate" its
input by the definition of producing the exact results of executing
the machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Nope, YOU are making the mistake. You just ignorant of the definitions.
Professor Sipser probably does understand the x86 language.And the x86 language says the same thing,
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf
YOU are just a liar, as proved by the fact that you can not give the
Diagonalization proof you claimed you had.
Sorry, you are just too stupid to understand.
You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
Every C programmer that knows what an x86 emulator is knows that >>>>>>> when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations so >>>>>>> that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to beIf you disagree with this you are either dishonest or clueless I no
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation.
Your simulation is not correct.
longer care which one.
DDD is correctly emulated by HHH which calls an emulated HHH(DDD) to
repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls this
emulated HHH(DDD) to repeat the process until aborted (which may be
never).
On 7/2/2024 1:23 AM, Mikko wrote:
On 2024-07-02 01:25:40 +0000, olcott said:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
The "must" there is not quite correct. If the emulator does not abort
then it will run forever or until the emulator is aborted by some
external agent. That is not a problem unless there is an additional
requirement, not specified above, that the emulator must terminate
normally.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>>>> so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be irrelevant >>>>>>>> does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation. >>>>>>>> Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not correct. >>>>
Your problem is you just assume things to exist that don't, because you >>>> don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show Godel wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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>
*Professor Sipser would agree that HHH/DDD meets the above criteria*
Your HHH that returns an answer does NOT "Correctly Simulate" its input
by the definition of producing the exact results of executing the
machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process https://inria.hal.science/hal-03404798/file/hipc2021.pdf
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
Every C programmer that knows what an x86 emulator is knows that >>>>>>>>> when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations so >>>>>>>>> that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to beIf you disagree with this you are either dishonest or clueless I no
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation. >>>>>> Your simulation is not correct.
longer care which one.
DDD is correctly emulated by HHH which calls an emulated HHH(DDD) to >>>>> repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls this
emulated HHH(DDD) to repeat the process until aborted (which may be
never).
HHH halts on input DDD.
void DDD()
{
HHH(DDD);
}
DDD correctly simulated by HHH cannot possibly halt.
On 7/2/2024 10:50 PM, joes wrote:WTF? It only calls HHH, which you just said halts.
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
HHH halts on input DDD.Whatever HHH does, it does not run forever but aborts.HHH repeats the process twice and aborts too soon.
DDD is correctly emulated by any HHH that can exist which calls this
emulated HHH(DDD) to repeat the process until aborted (which may be
never).
DDD correctly simulated by HHH cannot possibly halt.
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
Every C programmer that knows what an x86 emulator is knows that >>>>>>>>>>> when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these
emulations so
that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to beIf you disagree with this you are either dishonest or clueless I no >>>>>>> longer care which one.
irrelevant does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation. >>>>>>>> Your simulation is not correct.
DDD is correctly emulated by HHH which calls an emulated HHH(DDD) to >>>>>>> repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls this >>>>> emulated HHH(DDD) to repeat the process until aborted (which may be
never).
HHH halts on input DDD.
void DDD()
{
HHH(DDD);
}
DDD correctly simulated by HHH cannot possibly halt.
That would be an error of the simulator, because it aborts its own
simulation too soon, one cycle before the simulated HHH would return and
You dishonestly redefined the problem so that it has no correct answer.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>> that
when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these >>>>>>>>>>>>> emulations so
that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to be >>>>>>>>>> irrelevant does not bring the discussion any further.If you disagree with this you are either dishonest or clueless >>>>>>>>> I no
Sipser is not relevant, because that is about a correct
simulation.
Your simulation is not correct.
longer care which one.
DDD is correctly emulated by HHH which calls an emulated
HHH(DDD) to
repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls this >>>>>>> emulated HHH(DDD) to repeat the process until aborted (which may be >>>>>>> never).
HHH halts on input DDD.
void DDD()
{
HHH(DDD);
}
DDD correctly simulated by HHH cannot possibly halt.
That would be an error of the simulator, because it aborts its own
simulation too soon, one cycle before the simulated HHH would return
and
You dishonestly redefined the problem so that it has no correct answer.
(Ignoring an distracting irrelevant hominem remark.)
If you think that "What time is a three story building?" must have a
correct answer, you are wrong.
Similarly, if you think that HHH can simulate itself correctly, you
are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does not
return.
DDD is making it unnecessarily complex, but has the same problem.
main correctly emulated by H never stops running unless aborted.
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
This <is> the problem that I am willing to discuss.Every C programmer that knows what an x86 emulator is >>>>>>>>>>>>>>> knows that
when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these >>>>>>>>>>>>>>> emulations so
that itself can terminate normally.
Whether or not it *must* abort is not very relevant. >>>>>>>>>>>>>
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to be >>>>>>>>>>>> irrelevant does not bring the discussion any further.If you disagree with this you are either dishonest or
Sipser is not relevant, because that is about a correct >>>>>>>>>>>> simulation.
Your simulation is not correct.
clueless I no
longer care which one.
DDD is correctly emulated by HHH which calls an emulated >>>>>>>>>>> HHH(DDD) to
repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls >>>>>>>>> this
emulated HHH(DDD) to repeat the process until aborted (which >>>>>>>>> may be
never).
HHH halts on input DDD.
void DDD()
{
HHH(DDD);
}
DDD correctly simulated by HHH cannot possibly halt.
That would be an error of the simulator, because it aborts its own >>>>>> simulation too soon, one cycle before the simulated HHH would
return and
You dishonestly redefined the problem so that it has no correct
answer.
(Ignoring an distracting irrelevant hominem remark.)
If you think that "What time is a three story building?" must have a
correct answer, you are wrong.
Similarly, if you think that HHH can simulate itself correctly, you
are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does
not return.
DDD is making it unnecessarily complex, but has the same problem.
main correctly emulated by H never stops running unless aborted.
HHH is unable to simulate main correctly, because it unable to
simulate itself correctly.
The 'unless phrase' is misleading, because we are talking about a H
*does* abort. Dreaming of one that does not abort, is irrelevant.
The correctly simulated main would stop, because the simulated H is
only one cycle away from its return when its simulation is aborted.
HHH is required to report on what would happen if HHH did not abort.
HHH is forbidden from getting its own self stuck in infinite execution. Emulated instances of itself is not its actual self.
On 7/3/2024 2:27 AM, Mikko wrote:
On 2024-07-02 12:20:54 +0000, olcott said:
On 7/2/2024 1:23 AM, Mikko wrote:
On 2024-07-02 01:25:40 +0000, olcott said:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
The "must" there is not quite correct. If the emulator does not abort
then it will run forever or until the emulator is aborted by some
external agent. That is not a problem unless there is an additional
requirement, not specified above, that the emulator must terminate
normally.
This <is> the problem that I am willing to discuss.
What is the problem you are willing to discuss?
Are you willing to do anything else about to that problem?
The part that you ignored.
On 7/3/2024 2:42 AM, Mikko wrote:
On 2024-07-03 01:18:52 +0000, olcott said:
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>>>>>> so that itself can terminate normally.
Whether or not it *must* abort is not very relevant.
This <is> the problem that I am willing to discuss.
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be irrelevant
does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation. >>>>>>>>>> Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not correct.
Your problem is you just assume things to exist that don't, because you >>>>>> don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show Godel wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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> >>>>>
*Professor Sipser would agree that HHH/DDD meets the above criteria* >>>>>
Your HHH that returns an answer does NOT "Correctly Simulate" its input >>>> by the definition of producing the exact results of executing the
machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Professor Sipser probably does understand the x86 language.
What makes you think so? How can you justify "probably" instead of, say,
"pssobly"?
The following contains nothing relevant:
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf
If you make sure to not pay attention than you you
won't find anything relevant. I searched for ["sipser" "x86"]
On 7/3/2024 9:11 AM, joes wrote:Yes, DDD does not halt. But HHH aborts simulating it.
Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:An aborted simulation does not count as halting.
On 7/2/2024 10:50 PM, joes wrote:WTF? It only calls HHH, which you just said halts.
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
HHH halts on input DDD.Whatever HHH does, it does not run forever but aborts.HHH repeats the process twice and aborts too soon.
DDD is correctly emulated by any HHH that can exist which calls this >>>>> emulated HHH(DDD) to repeat the process until aborted (which may be
never).
DDD correctly simulated by HHH cannot possibly halt.
Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:No. HHH is simulating itself, not a different function that does not
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:HHH is unable to simulate main correctly, because it unable to simulate
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:That would be an error of the simulator, because it aborts its own >>>>>> simulation too soon, one cycle before the simulated HHH would
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:HHH halts on input DDD.
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:Whatever HHH does, it does not run forever but aborts.
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
This <is> the problem that I am willing to discuss.Every C programmer that knows what an x86 emulator is >>>>>>>>>>>>>>> knows that when HHH emulates the machine language of >>>>>>>>>>>>>>> Infinite_Loop,Whether or not it *must* abort is not very relevant. >>>>>>>>>>>>>
Infinite_Recursion, and DDD that it must abort these >>>>>>>>>>>>>>> emulations so that itself can terminate normally. >>>>>>>>>>>>>>
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
Repeating the same thing that has already been proved to be >>>>>>>>>>>> irrelevant does not bring the discussion any further. Sipser >>>>>>>>>>>> is not relevant, because that is about a correct simulation. >>>>>>>>>>>> Your simulation is not correct.If you disagree with this you are either dishonest or clueless >>>>>>>>>>> I no longer care which one.
DDD is correctly emulated by HHH which calls an emulated >>>>>>>>>>> HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist which calls >>>>>>>>> this emulated HHH(DDD) to repeat the process until aborted
(which may be never).
void DDD()
{
HHH(DDD);
}
DDD correctly simulated by HHH cannot possibly halt.
return and
You dishonestly redefined the problem so that it has no correct
answer.
(Ignoring an distracting irrelevant hominem remark.)
If you think that "What time is a three story building?" must have a
correct answer, you are wrong.
Similarly, if you think that HHH can simulate itself correctly, you
are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does not
return.
DDD is making it unnecessarily complex, but has the same problem.
main correctly emulated by H never stops running unless aborted.
itself correctly.
The 'unless phrase' is misleading, because we are talking about a H
*does* abort. Dreaming of one that does not abort, is irrelevant.
The correctly simulated main would stop, because the simulated H is
only one cycle away from its return when its simulation is aborted.
HHH is required to report on what would happen if HHH did not abort. HHH
is forbidden from getting its own self stuck in infinite execution.
Emulated instances of itself is not its actual self.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:As a matter of fact, H does abort it. It then returns to main,
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>> that when HHH emulates the machine language of
Infinite_Loop, Infinite_Recursion, and DDD that it must >>>>>>>>>>>>> abort these emulations so that itself can terminate
normally.
Whether or not it *must* abort is not very relevant.
Repeating the same thing that has already been proved to be >>>>>>>>>> irrelevant does not bring the discussion any further. Sipser is >>>>>>>>>> not relevant, because that is about a correct simulation.
Your simulation is not correct.
main correctly emulated by H never stops running unless aborted.You dishonestly redefined the problem so that it has no correctThat would be an error of the simulator, because it aborts its ownHHH halts on input DDD.Whatever HHH does, it does not run forever but aborts.DDD is correctly emulated by HHH which calls an emulated
HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
DDD is correctly emulated by any HHH that can exist which calls
this emulated HHH(DDD) to repeat the process until aborted (which >>>>>>> may be never).
DDD correctly simulated by HHH cannot possibly halt.
simulation too soon, one cycle before the simulated HHH would return
and
answer.
If you think that "What time is a three story building?" must have a
correct answer, you are wrong.
Similarly, if you think that HHH can simulate itself correctly, you are
wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does not
return.
DDD is making it unnecessarily complex, but has the same problem.
On 7/4/2024 6:09 AM, joes wrote:I was talking about main itself.
Am Wed, 03 Jul 2024 10:55:14 -0500 schrieb olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
main correctly simulated by H never returns.As a matter of fact, H does abort it. H then returns to main,Similarly, if you think that HHH can simulate itself correctly, youmain correctly emulated by H never stops running unless aborted.
are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does not
return.
DDD is making it unnecessarily complex, but has the same problem.
which then stops running.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does notHHH is required to report on what would happen if HHH did not abort.HHH is unable to simulate main correctly, because it unable toSimilarly, if you think that HHH can simulate itself correctly, you >>>>>> are wrong.main correctly emulated by H never stops running unless aborted.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does
not return.
DDD is making it unnecessarily complex, but has the same problem.
simulate itself correctly.
The 'unless phrase' is misleading, because we are talking about a H
*does* abort. Dreaming of one that does not abort, is irrelevant.
The correctly simulated main would stop, because the simulated H is
only one cycle away from its return when its simulation is aborted.
HHH is forbidden from getting its own self stuck in infinite
execution. Emulated instances of itself is not its actual self.
abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It is stupidly incorrect to think that HHH can wait on the next one.
On 7/4/2024 8:09 AM, joes wrote:Huh? HHH examines main. Sure, it doesn’t /simulate/ the return.
Am Thu, 04 Jul 2024 07:53:07 -0500 schrieb olcott:That is not the one that HHH examines.
On 7/4/2024 6:09 AM, joes wrote:I was talking about main itself.
Am Wed, 03 Jul 2024 10:55:14 -0500 schrieb olcott:main correctly simulated by H never returns.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:As a matter of fact, H does abort it. H then returns to main,
Similarly, if you think that HHH can simulate itself correctly, you >>>>>> are wrong.main correctly emulated by H never stops running unless aborted.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does
not return.
which then stops running.
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does notexecution. Emulated instances of itself is not its actual self.HHH is unable to simulate main correctly, because it unable toSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>> you are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>> not return.
DDD is making it unnecessarily complex, but has the same problem. >>>>>>> main correctly emulated by H never stops running unless aborted.
simulate itself correctly.
The 'unless phrase' is misleading, because we are talking about a H >>>>>> *does* abort. Dreaming of one that does not abort, is irrelevant.
The correctly simulated main would stop, because the simulated H is >>>>>> only one cycle away from its return when its simulation is aborted. >>>>> HHH is required to report on what would happen if HHH did not abort. >>>>> HHH is forbidden from getting its own self stuck in infinite
abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It
is stupidly incorrect to think that HHH can wait on the next one.
because that part isn’t simulated.
On 7/4/2024 8:38 AM, joes wrote:
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does notexecution. Emulated instances of itself is not its actual self.HHH is unable to simulate main correctly, because it unable toSimilarly, if you think that HHH can simulate itself correctly, you >>>>>>>> are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>> not return.
DDD is making it unnecessarily complex, but has the same problem. >>>>>>> main correctly emulated by H never stops running unless aborted.
simulate itself correctly.
The 'unless phrase' is misleading, because we are talking about a H >>>>>> *does* abort. Dreaming of one that does not abort, is irrelevant.
The correctly simulated main would stop, because the simulated H is >>>>>> only one cycle away from its return when its simulation is aborted. >>>>> HHH is required to report on what would happen if HHH did not abort. >>>>> HHH is forbidden from getting its own self stuck in infinite
abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It is
stupidly incorrect to think that HHH can wait on the next one.
because that part isn’t simulated.
Unless the outermost one aborts none of them do.
On 7/4/2024 10:07 AM, joes wrote:
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just >>>> because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does not >>>>>> abort. All calls are instances of the same code with the sameexecution. Emulated instances of itself is not its actual self.The 'unless phrase' is misleading, because we are talking about a H >>>>>>>> *does* abort. Dreaming of one that does not abort, is irrelevant. >>>>>>>> The correctly simulated main would stop, because the simulated H is >>>>>>>> only one cycle away from its return when its simulation is aborted. >>>>>>> HHH is required to report on what would happen if HHH did not abort. >>>>>>> HHH is forbidden from getting its own self stuck in infiniteSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>> you are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>>>> not return.
DDD is making it unnecessarily complex, but has the same problem. >>>>>>>>> main correctly emulated by H never stops running unless aborted. >>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>> simulate itself correctly.
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It >>>>> is stupidly incorrect to think that HHH can wait on the next one.
This the same same as saying the when everyone in
a foot race is in single file and 15 feet behind
the one in front of them that everyone will come
in first place. No you are wrong.
On 7/4/2024 10:07 AM, joes wrote:The inner ones ARE abortED, which prevents THEM from aborting.
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just >>>> because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that doesHHH is required to report on what would happen if HHH did notThe 'unless phrase' is misleading, because we are talking about a >>>>>>>> H *does* abort. Dreaming of one that does not abort, isSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>> simulate itself correctly.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>> does not return.
DDD is making it unnecessarily complex, but has the same
problem.
irrelevant. The correctly simulated main would stop, because the >>>>>>>> simulated H is only one cycle away from its return when its
simulation is aborted.
abort.
HHH is forbidden from getting its own self stuck in infinite
execution. Emulated instances of itself is not its actual self.
not abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It >>>>> is stupidly incorrect to think that HHH can wait on the next one.
On 7/4/2024 10:03 AM, joes wrote:This isn’t about OS programming.
Am Thu, 04 Jul 2024 08:32:10 -0500 schrieb olcott:You don't know enough about operating system programming to understand
On 7/4/2024 8:09 AM, joes wrote:Huh? HHH examines main. Sure, it doesn’t /simulate/ the return.
Am Thu, 04 Jul 2024 07:53:07 -0500 schrieb olcott:That is not the one that HHH examines.
On 7/4/2024 6:09 AM, joes wrote:I was talking about main itself.
Am Wed, 03 Jul 2024 10:55:14 -0500 schrieb olcott:main correctly simulated by H never returns.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:As a matter of fact, H does abort it. H then returns to main,
Similarly, if you think that HHH can simulate itself correctly, >>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>> not return.
which then stops running.
this.
There is more than one main() process. One of them cannot possibly haltThat makes no sense. They have exactly the same code.
and the other one halts.
On 7/4/2024 10:24 AM, Richard Damon wrote:
On 7/4/24 9:43 AM, olcott wrote:
On 7/4/2024 8:38 AM, joes wrote:
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just >>>> because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does not >>>>>> abort. All calls are instances of the same code with the sameexecution. Emulated instances of itself is not its actual self.The 'unless phrase' is misleading, because we are talking about a H >>>>>>>> *does* abort. Dreaming of one that does not abort, is irrelevant. >>>>>>>> The correctly simulated main would stop, because the simulated H is >>>>>>>> only one cycle away from its return when its simulation is aborted. >>>>>>> HHH is required to report on what would happen if HHH did not abort. >>>>>>> HHH is forbidden from getting its own self stuck in infiniteSimilarly, if you think that HHH can simulate itself
correctly, you
are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>>>> not return.
DDD is making it unnecessarily complex, but has the same problem. >>>>>>>>> main correctly emulated by H never stops running unless aborted. >>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>> simulate itself correctly.
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one.
It is
stupidly incorrect to think that HHH can wait on the next one.
Unless the outermost one aborts none of them do.
And, since it does (since you claim HHH(DDD) is correct in returning
non-halting) the all do, and thus DDD halts.
*No you are stupidly wrong*
This the same same as saying the when everyone in
a foot race is in single file and 15 feet behind
the one in front of them that everyone will come
in first place.
On 7/4/2024 10:24 AM, Richard Damon wrote:Why does HHH simulate a program that does not abort?
On 7/4/24 9:43 AM, olcott wrote:*No you are stupidly wrong*
On 7/4/2024 8:38 AM, joes wrote:And, since it does (since you claim HHH(DDD) is correct in returning
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just >>>> because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that doesHHH is required to report on what would happen if HHH did notThe 'unless phrase' is misleading, because we are talking about a >>>>>>>> H *does* abort. Dreaming of one that does not abort, isSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>> simulate itself correctly.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>> does not return.
DDD is making it unnecessarily complex, but has the same
problem.
irrelevant. The correctly simulated main would stop, because the >>>>>>>> simulated H is only one cycle away from its return when its
simulation is aborted.
abort.
HHH is forbidden from getting its own self stuck in infinite
execution. Emulated instances of itself is not its actual self.
not abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It >>>>> is stupidly incorrect to think that HHH can wait on the next one.
non-halting) the all do, and thus DDD halts.
This the same same as saying the when everyone in a foot race is in
single file and 15 feet behind the one in front of them that everyone
will come in first place.
On 7/4/2024 11:22 AM, joes wrote:The inner ones have the same criterion.
Am Thu, 04 Jul 2024 10:56:10 -0500 schrieb olcott:They all use the exact same code.
On 7/4/2024 10:07 AM, joes wrote:The inner ones ARE abortED, which prevents THEM from aborting.
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 14:22 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees >>>>>>> at least one fully execution trace of DDD before the next innerHHH is required to report on what would happen if HHH did not >>>>>>>>> abort.HHH is unable to simulate main correctly, because it unable to >>>>>>>>>> simulate itself correctly.Similarly, if you think that HHH can simulate itselfmain correctly emulated by H never stops running unless
correctly,
you are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>>>> does not return.
DDD is making it unnecessarily complex, but has the same >>>>>>>>>>>> problem.
aborted.
The 'unless phrase' is misleading, because we are talking about >>>>>>>>>> a H *does* abort. Dreaming of one that does not abort, is
irrelevant. The correctly simulated main would stop, because >>>>>>>>>> the simulated H is only one cycle away from its return when its >>>>>>>>>> simulation is aborted.
HHH is forbidden from getting its own self stuck in infinite >>>>>>>>> execution. Emulated instances of itself is not its actual self. >>>>>>>> No. HHH is simulating itself, not a different function that does >>>>>>>> not abort. All calls are instances of the same code with the same >>>>>>>> parameters. They all do the same thing: aborting.
one. It is stupidly incorrect to think that HHH can wait on the
next one.
just because that part isn’t simulated.
The outer one meets its abort criteria first.
This means unless the outer one aborts NONE OF THEM ABORT.Only because that is not simulated yet. That doesn’t mean that they
On 7/4/2024 11:24 AM, joes wrote:Oh, there should also be different instances of H.
Am Thu, 04 Jul 2024 10:58:03 -0500 schrieb olcott:The x86utm operating system spawns a separate process so that
On 7/4/2024 10:03 AM, joes wrote:
Am Thu, 04 Jul 2024 08:32:10 -0500 schrieb olcott:
On 7/4/2024 8:09 AM, joes wrote:Huh? HHH examines main. Sure, it doesn’t /simulate/ the return.
Am Thu, 04 Jul 2024 07:53:07 -0500 schrieb olcott:That is not the one that HHH examines.
On 7/4/2024 6:09 AM, joes wrote:I was talking about main itself.
Am Wed, 03 Jul 2024 10:55:14 -0500 schrieb olcott:main correctly simulated by H never returns.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:which then stops running.
Similarly, if you think that HHH can simulate itself correctly, >>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>> As a matter of fact, H does abort it. H then returns to main,
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>> does not return.
H can emulate another different instance of D in this separate process.
H must call DebugTrace()
to switch process contexts to emulate one more instruction of D.
What is their difference?It makes no sense only if you are totally clueless of operating system process contexts.There is more than one main() process. One of them cannot possiblyThat makes no sense. They have exactly the same code.
halt and the other one halts.
On 7/4/2024 11:34 AM, joes wrote:
Am Thu, 04 Jul 2024 11:29:10 -0500 schrieb olcott:
On 7/4/2024 11:24 AM, joes wrote:
Am Thu, 04 Jul 2024 10:58:03 -0500 schrieb olcott:The x86utm operating system spawns a separate process so that
On 7/4/2024 10:03 AM, joes wrote:
Am Thu, 04 Jul 2024 08:32:10 -0500 schrieb olcott:
On 7/4/2024 8:09 AM, joes wrote:Huh? HHH examines main. Sure, it doesn’t /simulate/ the return.
Am Thu, 04 Jul 2024 07:53:07 -0500 schrieb olcott:That is not the one that HHH examines.
On 7/4/2024 6:09 AM, joes wrote:I was talking about main itself.
Am Wed, 03 Jul 2024 10:55:14 -0500 schrieb olcott:main correctly simulated by H never returns.
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Similarly, if you think that HHH can simulate itself correctly, >>>>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>>>> As a matter of fact, H does abort it. H then returns to main, >>>>>>>>>> which then stops running.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>>>> does not return.
H can emulate another different instance of D in this separate process.
H must call DebugTrace()
to switch process contexts to emulate one more instruction of D.
Oh, there should also be different instances of H.There are. DDD and the HHH that DDD calls are in the
same process context. The DDD that the emulated HHH
emulates is in another process context.
It makes no sense only if you are totally clueless of operating systemThere is more than one main() process. One of them cannot possiblyThat makes no sense. They have exactly the same code.
halt and the other one halts.
process contexts.
What is their difference?
When the directly executed DDD calls HHH(DDD) the
DDD that HHH emulates is in an entirely different
process context. The first one halts only because
HHH correctly determines that its DDD does not halt.
On 7/4/2024 11:22 AM, joes wrote:
Am Thu, 04 Jul 2024 10:56:10 -0500 schrieb olcott:
On 7/4/2024 10:07 AM, joes wrote:The inner ones ARE abortED, which prevents THEM from aborting.
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 14:22 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees at >>>>>>> least one fully execution trace of DDD before the next inner one. It >>>>>>> is stupidly incorrect to think that HHH can wait on the next one. >>>>>> Stupidly incorrect is thinking that the next one wouldn’t abort just >>>>>> because that part isn’t simulated.HHH is required to report on what would happen if HHH did not >>>>>>>>> abort.The 'unless phrase' is misleading, because we are talking about a >>>>>>>>>> H *does* abort. Dreaming of one that does not abort, isSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>>>> simulate itself correctly.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>>>> does not return.
DDD is making it unnecessarily complex, but has the same >>>>>>>>>>>> problem.
irrelevant. The correctly simulated main would stop, because the >>>>>>>>>> simulated H is only one cycle away from its return when its >>>>>>>>>> simulation is aborted.
HHH is forbidden from getting its own self stuck in infinite >>>>>>>>> execution. Emulated instances of itself is not its actual self. >>>>>>>> No. HHH is simulating itself, not a different function that does >>>>>>>> not abort. All calls are instances of the same code with the same >>>>>>>> parameters. They all do the same thing: aborting.
They all use the exact same code.
The outer one meets its abort criteria first.
This means unless the outer one aborts NONE OF THEM ABORT.
On 7/4/2024 11:57 AM, Richard Damon wrote:
On 7/4/24 12:24 PM, olcott wrote:
On 7/4/2024 11:22 AM, joes wrote:
Am Thu, 04 Jul 2024 10:56:10 -0500 schrieb olcott:
On 7/4/2024 10:07 AM, joes wrote:The inner ones ARE abortED, which prevents THEM from aborting.
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 21:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 7/2/2024 1:42 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 14:22 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it alwaysHHH is required to report on what would happen if HHH did not >>>>>>>>>>> abort.HHH is unable to simulate main correctly, because it unable to >>>>>>>>>>>> simulate itself correctly.Similarly, if you think that HHH can simulate itself >>>>>>>>>>>>>> correctly,main correctly emulated by H never stops running unless >>>>>>>>>>>>> aborted.
you are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>>>>>> does not return.
DDD is making it unnecessarily complex, but has the same >>>>>>>>>>>>>> problem.
The 'unless phrase' is misleading, because we are talking >>>>>>>>>>>> about a
H *does* abort. Dreaming of one that does not abort, is >>>>>>>>>>>> irrelevant. The correctly simulated main would stop, because >>>>>>>>>>>> the
simulated H is only one cycle away from its return when its >>>>>>>>>>>> simulation is aborted.
HHH is forbidden from getting its own self stuck in infinite >>>>>>>>>>> execution. Emulated instances of itself is not its actual self. >>>>>>>>>> No. HHH is simulating itself, not a different function that does >>>>>>>>>> not abort. All calls are instances of the same code with the same >>>>>>>>>> parameters. They all do the same thing: aborting.
sees at
least one fully execution trace of DDD before the next inner >>>>>>>>> one. It
is stupidly incorrect to think that HHH can wait on the next one. >>>>>>>> Stupidly incorrect is thinking that the next one wouldn’t abort >>>>>>>> just
They all use the exact same code.
The outer one meets its abort criteria first.
This means unless the outer one aborts NONE OF THEM ABORT.
But since the outer one aborts, they ALL abort and are all halting.
I am not going to address your stupid lies and more.
On 7/4/2024 1:29 AM, Mikko wrote:
On 2024-07-03 13:13:59 +0000, olcott said:
On 7/3/2024 2:42 AM, Mikko wrote:
On 2024-07-03 01:18:52 +0000, olcott said:
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:This <is> the problem that I am willing to discuss.
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>>>>>>>> so that itself can terminate normally.
Whether or not it *must* abort is not very relevant. >>>>>>>>>>>>>
I am unwilling to discuss any other problem.
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to be irrelevant
does not bring the discussion any further.
Sipser is not relevant, because that is about a correct simulation.
Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process
until aborted (which may be never).
Only if your definiton of "Correct" includes things that are not correct.
Your problem is you just assume things to exist that don't, because you
don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show Godel wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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> >>>>>>>
*Professor Sipser would agree that HHH/DDD meets the above criteria* >>>>>>>
Your HHH that returns an answer does NOT "Correctly Simulate" its input >>>>>> by the definition of producing the exact results of executing the
machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Professor Sipser probably does understand the x86 language.
What makes you think so? How can you justify "probably" instead of, say, >>>> "pssobly"?
The following contains nothing relevant:
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf
If you make sure to not pay attention than you you
won't find anything relevant. I searched for ["sipser" "x86"]
Finding that you present claims without support is relevant enough for me. >>
Knowledge of the x86 language is 100% complete support.
On 7/4/2024 10:07 AM, joes wrote:
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:Stupidly incorrect is thinking that the next one wouldn’t abort just >>>> because that part isn’t simulated.
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees atNo. HHH is simulating itself, not a different function that does not >>>>>> abort. All calls are instances of the same code with the sameexecution. Emulated instances of itself is not its actual self.The 'unless phrase' is misleading, because we are talking about a H >>>>>>>> *does* abort. Dreaming of one that does not abort, is irrelevant. >>>>>>>> The correctly simulated main would stop, because the simulated H is >>>>>>>> only one cycle away from its return when its simulation is aborted. >>>>>>> HHH is required to report on what would happen if HHH did not abort. >>>>>>> HHH is forbidden from getting its own self stuck in infiniteSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>> you are wrong.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it does >>>>>>>>>> not return.
DDD is making it unnecessarily complex, but has the same problem. >>>>>>>>> main correctly emulated by H never stops running unless aborted. >>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>> simulate itself correctly.
parameters. They all do the same thing: aborting.
least one fully execution trace of DDD before the next inner one. It >>>>> is stupidly incorrect to think that HHH can wait on the next one.
This the same same as saying the when everyone in
a foot race is in single file and 15 feet behind
the one in front of them that everyone will come
in first place. No you are wrong.
On 7/5/2024 2:20 AM, Mikko wrote:
On 2024-07-04 12:39:09 +0000, olcott said:
On 7/4/2024 1:29 AM, Mikko wrote:
On 2024-07-03 13:13:59 +0000, olcott said:
On 7/3/2024 2:42 AM, Mikko wrote:
On 2024-07-03 01:18:52 +0000, olcott said:
On 7/2/2024 8:07 PM, Richard Damon wrote:
On 7/2/24 7:03 PM, olcott wrote:
On 7/2/2024 5:44 PM, Richard Damon wrote:
On 7/2/24 3:46 PM, olcott wrote:
On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 14:22 schreef olcott:
On 7/2/2024 3:22 AM, Fred. Zwarts wrote:
Op 02.jul.2024 om 03:25 schreef olcott:This <is> the problem that I am willing to discuss. >>>>>>>>>>>>>>> I am unwilling to discuss any other problem.
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
HERE: goto HERE;
}
void Infinite_Recursion()
{
Infinite_Recursion();
}
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}
Every C programmer that knows what an x86 emulator is >>>>>>>>>>>>>>>>> knows
that when HHH emulates the machine language of >>>>>>>>>>>>>>>>> Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these >>>>>>>>>>>>>>>>> emulations
so that itself can terminate normally.
Whether or not it *must* abort is not very relevant. >>>>>>>>>>>>>>>
This does meet the Sipser approved criteria.
<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>
Repeating the same thing that has already been proved to >>>>>>>>>>>>>> be irrelevant does not bring the discussion any further. >>>>>>>>>>>>>> Sipser is not relevant, because that is about a correct >>>>>>>>>>>>>> simulation. Your simulation is not correct.
If you disagree with this you are either dishonest
or clueless I no longer care which one.
_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]
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted. >>>>>>>>>>>>
HHH repeats the process twice and aborts too soon.
You are freaking thinking too damn narrow minded.
DDD is correctly emulated by any HHH that can exist
which calls this emulated HHH(DDD) to repeat the process >>>>>>>>>>> until aborted (which may be never).
Only if your definiton of "Correct" includes things that are >>>>>>>>>> not correct.
Your problem is you just assume things to exist that don't, >>>>>>>>>> because you don't understand what Truth actually means.
So, where is that Diagonalization proof you said you had to show >>>>>>>> Godel wrong?
Or are you just admitting you LIED about that?
void DDD()Nope.
{
HHH(DDD);
}
int main()
{
HHH(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
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>
*Professor Sipser would agree that HHH/DDD meets the above
criteria*
Your HHH that returns an answer does NOT "Correctly Simulate"
its input by the definition of producing the exact results of
executing the machine represented by it,
I can see what you fail to understand. Professor Sipser would
not make this same mistake.
Professor Sipser probably does understand the x86 language.
What makes you think so? How can you justify "probably" instead
of, say,
"pssobly"?
The following contains nothing relevant:
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf
If you make sure to not pay attention than you you
won't find anything relevant. I searched for ["sipser" "x86"]
Finding that you present claims without support is relevant enough
for me.
Knowledge of the x86 language is 100% complete support.
No, it is not. It might support your cliams a but if your writing would
reveal significant knowledge of the x86 language but it doesn't.
_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]
*In other words you are denying the verified fact*
That when DDD emulated by HHH according to the
semantics of the x86 language calls HHH(DDD) that
this call cannot possibly return.
*By denying this verified fact you are affirming*
That when DDD emulated by HHH according to the
semantics of the x86 language calls HHH(DDD) that
*THIS CALL CAN RETURN*
On 7/5/2024 2:32 AM, Mikko wrote:
On 2024-07-04 15:56:10 +0000, olcott said:
On 7/4/2024 10:07 AM, joes wrote:
Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:
On 7/4/2024 8:38 AM, joes wrote:Since the outermost aborts, all of them do.
Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:Unless the outermost one aborts none of them do.
On 7/4/2024 5:38 AM, joes wrote:
Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:
On 7/3/2024 11:09 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 17:55 schreef olcott:
On 7/3/2024 10:52 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 15:24 schreef olcott:
On 7/3/2024 3:42 AM, Fred. Zwarts wrote:
Op 03.jul.2024 om 05:55 schreef olcott:
On 7/2/2024 10:50 PM, joes wrote:
Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/2/2024 2:17 PM, Fred. Zwarts wrote:
Op 02.jul.2024 om 21:00 schreef olcott:
On 7/2/2024 1:42 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 14:22 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 7/2/2024 3:22 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 02.jul.2024 om 03:25 schreef olcott:
HHH always meets its abort criteria first because it always sees at >>>>>>> least one fully execution trace of DDD before the next inner one. It >>>>>>> is stupidly incorrect to think that HHH can wait on the next one. >>>>>> Stupidly incorrect is thinking that the next one wouldn’t abort just >>>>>> because that part isn’t simulated.abort. All calls are instances of the same code with the sameHHH is required to report on what would happen if HHH did not >>>>>>>>> abort.The 'unless phrase' is misleading, because we are talkingSimilarly, if you think that HHH can simulate itself correctly, >>>>>>>>>>>> you are wrong.main correctly emulated by H never stops running unless aborted. >>>>>>>>>> HHH is unable to simulate main correctly, because it unable to >>>>>>>>>> simulate itself correctly.
int H(ptr p, ptr i);
int main()
{
return H(main, 0);
}
You showed that H returns, but that the simulation thinks it >>>>>>>>>>>> does
not return.
DDD is making it unnecessarily complex, but has the same >>>>>>>>>>>> problem.
about a H
*does* abort. Dreaming of one that does not abort, is irrelevant. >>>>>>>>>> The correctly simulated main would stop, because the simulated >>>>>>>>>> H is
only one cycle away from its return when its simulation is >>>>>>>>>> aborted.
HHH is forbidden from getting its own self stuck in infinite >>>>>>>>> execution. Emulated instances of itself is not its actual self. >>>>>>>> No. HHH is simulating itself, not a different function that does >>>>>>>> not
parameters. They all do the same thing: aborting.
This the same same as saying the when everyone in
a foot race is in single file and 15 feet behind
the one in front of them that everyone will come
in first place. No you are wrong.
That "first place" is not in "the same" but your own lie.
In a turthful paraphrase there would be "to the fininsh line"
or something like that instead.
_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]
When HHH(DDD) simulates its input that calls HHH(DDD)
to simulate its input that simulates its input the outer
HHH has seen the first four instructions repeated, the
inner HHH has not seen the first four instructions repeated.
The outer one has met its abort criteria, the inner one
has not met its abort criteria.
If you now the x86 language you would already know that.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 169:08:23 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,551 |