Software engineers can easily verify that D correctly simulated by H
cannot possibly reach its own line 09 and terminate normally.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 D(D);
15 }

*Execution Trace*
Line 14: main() invokes D(D)

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

Is it dead obvious to everyone here when examining the execution
trace of lines 14 and 06 above that D correctly simulated by H cannot
possibly terminate normally by reaching its own line 09?

This means that when termination analyzer H aborts its simulation of D
and reports that its correctly simulated input cannot possibly terminate
normally it is merely reporting an easily verified fact.

*THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*

I will provide the next steps of the analysis after the above has been
accepted.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 12:40 PM, olcott wrote:
> Software engineers can easily verify that D correctly simulated by H
> cannot possibly reach its own line 09 and terminate normally.
>
> The x86utm operating system based on an open source x86 emulator. This
> system enables one C function to execute another C function in debug
> step mode. When H simulates D it creates a separate process context for
> D with its own memory, stack and virtual registers. H is able to
> simulate D simulating itself, thus the only limit to recursive
> simulations is RAM.
>
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   D(D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes D(D)
>
> *keeps repeating* (unless aborted)
> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach its own line 09.
>
> Is it dead obvious to everyone here when examining the execution
> trace of lines 14 and 06 above that D correctly simulated by H cannot
> possibly terminate normally by reaching its own line 09?
>
> This means that when termination analyzer H aborts its simulation of D
> and reports that its correctly simulated input cannot possibly terminate
> normally it is merely reporting an easily verified fact.
>
> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
>
> I will provide the next steps of the analysis after the above has been
> accepted.
>
>
>

Right, it is impossibl to design an H that can correctly simulate that D
and reach a final state.

Thus, no H can validly say the D built on it is Halting.

But this is irrelevent to the Halting Proble, except as a step to show
that no H can be a correct halt decider.

Remember, The Halting problem is asking about the behavior of the ACTUAL
MACHINE (in this case D(D)).

We have just shown that no H can correctly say that its D(D) Halts.

We also know, and you have agreed to, that if H says that its D(D) is
non-halting that the actual execution of D(D) will halt, since D(D) will
call H(D,D) which WILL return 0 and D(D) will then Halt.

All your claim shows is that you are too stupid to understand what the
actual Halting Problem is. You claim that the actual "reallity" is the
faerie tale simulation done by H, which CAN'T be correct, BY DEFINITION,
since a "Correct Simulation" (if it is applicable to the Halting
Problem) must agree with the behavior of the actual machine.

You don't understand the Halting Problem.

You don't seem to understand how programs actually work, since you seem
to think that somehow H(D,D) can behave different depending on things
that are not inputs to it.

You don't seem to understand the meaning of requirements, since the
actual requirement talk about the actual machine, but you think
something else can over rule the plain reading of the actual requirement.

You don't seem to understand about correct logic, since you insist on
using most of the falacies in the book, and don't understand that you
need to start from the actual accepted truths of the system, and that
you can't just make up your own.

You also clearly don't understand hat is meant by Truth, since you keep
on insisting that a clearly false statement must be true, and refuse to
even follow your on logic rules to show something is true. You think
that it can be true that H does, as the exact same program, two totally
different things. You think that just because you hypothsis something,
that it must exist. (Your truth is based on Magical Faerie Dust power
Purple Unicorn Magic)

In other words, you are clearly demonstrated that you are, in fact, an
ignorant, pathological, lying idiot.

YOU HAVE FAILED

On 6/12/2023 6:36 PM, Richard Damon wrote:
> On 6/12/23 12:40 PM, olcott wrote:
>> Software engineers can easily verify that D correctly simulated by H
>> cannot possibly reach its own line 09 and terminate normally.
>>
>> The x86utm operating system based on an open source x86 emulator. This
>> system enables one C function to execute another C function in debug
>> step mode. When H simulates D it creates a separate process context for
>> D with its own memory, stack and virtual registers. H is able to
>> simulate D simulating itself, thus the only limit to recursive
>> simulations is RAM.
>>
>> // The following is written in C
>> //
>> 01 typedef int (*ptr)(); // pointer to int function
>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>> 03
>> 04 int D(ptr x)
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   D(D);
>> 15 }
>>
>> *Execution Trace*
>> Line 14: main() invokes D(D)
>>
>> *keeps repeating* (unless aborted)
>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach its own line 09.
>>
>> Is it dead obvious to everyone here when examining the execution
>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>> possibly terminate normally by reaching its own line 09?
>>
>> This means that when termination analyzer H aborts its simulation of D
>> and reports that its correctly simulated input cannot possibly terminate
>> normally it is merely reporting an easily verified fact.
>>
>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
>>
>> I will provide the next steps of the analysis after the above has been
>> accepted.
>>
>>
>>
>
> Right, it is impossibl to design an H that can correctly simulate that D
> and reach a final state.
>
> Thus, no H can validly say the D built on it is Halting.
>
It is a verified fact that H does correctly report that D correctly
simulated by H cannot possibly terminate normally.

For any program H that might determine whether programs halt, a
"pathological" program D, called with some input, can pass its own
source and its input to H and then specifically do the opposite of what
H predicts D will do. *No H can exist that handles this case*
https://en.wikipedia.org/wiki/Halting_problem

It is a verified fact that H and D have the halting problem pathological
relationship to each other.

Until you acknowledge these two verified facts it remains obvious that
you are only playing troll head games and have no interest in any honest
dialogue.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 8:31 PM, olcott wrote:
> On 6/12/2023 6:36 PM, Richard Damon wrote:
>> On 6/12/23 12:40 PM, olcott wrote:
>>> Software engineers can easily verify that D correctly simulated by H
>>> cannot possibly reach its own line 09 and terminate normally.
>>>
>>> The x86utm operating system based on an open source x86 emulator. This
>>> system enables one C function to execute another C function in debug
>>> step mode. When H simulates D it creates a separate process context for
>>> D with its own memory, stack and virtual registers. H is able to
>>> simulate D simulating itself, thus the only limit to recursive
>>> simulations is RAM.
>>>
>>> // The following is written in C
>>> //
>>> 01 typedef int (*ptr)(); // pointer to int function
>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>> 03
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   D(D);
>>> 15 }
>>>
>>> *Execution Trace*
>>> Line 14: main() invokes D(D)
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>
>>> Is it dead obvious to everyone here when examining the execution
>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>> possibly terminate normally by reaching its own line 09?
>>>
>>> This means that when termination analyzer H aborts its simulation of D
>>> and reports that its correctly simulated input cannot possibly terminate
>>> normally it is merely reporting an easily verified fact.
>>>
>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
>>>
>>> I will provide the next steps of the analysis after the above has
>>> been accepted.
>>>
>>>
>>>
>>
>> Right, it is impossibl to design an H that can correctly simulate that
>> D and reach a final state.
>>
>> Thus, no H can validly say the D built on it is Halting.
>>
> It is a verified fact that H does correctly report that D correctly
> simulated by H cannot possibly terminate normally.

So, you admit you are working on POOP and not the Halting Problem?

>
> For any program H that might determine whether programs halt, a
> "pathological" program D, called with some input, can pass its own
> source and its input to H and then specifically do the opposite of what
> H predicts D will do. *No H can exist that handles this case*
> https://en.wikipedia.org/wiki/Halting_problem

Nope, H predicts what IT will do, not what the program that its input
represents.

D(D) Halts, thus H(D,D) should have answered Halt if H is a Halt Decider.

>
> It is a verified fact that H and D have the halting problem pathological
> relationship to each other.

So?

>
> Until you acknowledge these two verified facts it remains obvious that
> you are only playing troll head games and have no interest in any honest
> dialogue.
>

No, until you admit that you have been mistaken about the actual
question of the halting problem for all these years you are just showing
yourself to be an ignorant pathological lying idiot.

Remember, The Halting problem is about the behavior of the PROGRAM
descirbed to the decider.

If H(D,D) doesn't not refer to the behavior of D(D), the H is NOT a
Halting Decider, but just your POOP decider.

You have been told this many times, and your refusal to learn this just
shows it isn't an "Honest Mistake", but that you ARE just a pathetic liar.

Yes, H can't simulate its input to a final state, and I have told you
many times that is a true statement. Yes, their relationship can be
d4scribed as "pathological". But neither of those statement changes the
required answer for a Halting Decider which must answer about the
behavior of the actual program when run, and that program must use an
exact copy (modified as described) of the decider, which means that it
will get the exact same answer back as when the decider is run on it.

You are just proving yourself to be stupid.

On 6/12/2023 8:26 PM, Richard Damon wrote:
> On 6/12/23 8:31 PM, olcott wrote:
>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>> On 6/12/23 12:40 PM, olcott wrote:
>>>> Software engineers can easily verify that D correctly simulated by H
>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>
>>>> The x86utm operating system based on an open source x86 emulator. This
>>>> system enables one C function to execute another C function in debug
>>>> step mode. When H simulates D it creates a separate process context for
>>>> D with its own memory, stack and virtual registers. H is able to
>>>> simulate D simulating itself, thus the only limit to recursive
>>>> simulations is RAM.
>>>>
>>>> // The following is written in C
>>>> //
>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>> 03
>>>> 04 int D(ptr x)
>>>> 05 {
>>>> 06   int Halt_Status = H(x, x);
>>>> 07   if (Halt_Status)
>>>> 08     HERE: goto HERE;
>>>> 09   return Halt_Status;
>>>> 10 }
>>>> 11
>>>> 12 void main()
>>>> 13 {
>>>> 14   D(D);
>>>> 15 }
>>>>
>>>> *Execution Trace*
>>>> Line 14: main() invokes D(D)
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>
>>>> Is it dead obvious to everyone here when examining the execution
>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>> possibly terminate normally by reaching its own line 09?
>>>>
>>>> This means that when termination analyzer H aborts its simulation of D
>>>> and reports that its correctly simulated input cannot possibly
>>>> terminate
>>>> normally it is merely reporting an easily verified fact.
>>>>
>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
>>>>
>>>> I will provide the next steps of the analysis after the above has
>>>> been accepted.
>>>>
>>>>
>>>>
>>>
>>> Right, it is impossibl to design an H that can correctly simulate
>>> that D and reach a final state.
>>>
>>> Thus, no H can validly say the D built on it is Halting.
>>>
>> It is a verified fact that H does correctly report that D correctly
>> simulated by H cannot possibly terminate normally.
>
> So, you admit you are working on POOP and not the Halting Problem?
>

It is a verified fact that H does correctly report that D correctly
simulated by H cannot possibly terminate normally.

Until you explicitly acknowledge that verified fact I am no longer
willing to talk to you.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 9:38 PM, olcott wrote:
> On 6/12/2023 8:26 PM, Richard Damon wrote:
>> On 6/12/23 8:31 PM, olcott wrote:
>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>> Software engineers can easily verify that D correctly simulated by H
>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>
>>>>> The x86utm operating system based on an open source x86 emulator. This
>>>>> system enables one C function to execute another C function in debug
>>>>> step mode. When H simulates D it creates a separate process context
>>>>> for
>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>> simulations is RAM.
>>>>>
>>>>> // The following is written in C
>>>>> //
>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>> 03
>>>>> 04 int D(ptr x)
>>>>> 05 {
>>>>> 06   int Halt_Status = H(x, x);
>>>>> 07   if (Halt_Status)
>>>>> 08     HERE: goto HERE;
>>>>> 09   return Halt_Status;
>>>>> 10 }
>>>>> 11
>>>>> 12 void main()
>>>>> 13 {
>>>>> 14   D(D);
>>>>> 15 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 14: main() invokes D(D)
>>>>>
>>>>> *keeps repeating* (unless aborted)
>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>
>>>>> Is it dead obvious to everyone here when examining the execution
>>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>>> possibly terminate normally by reaching its own line 09?
>>>>>
>>>>> This means that when termination analyzer H aborts its simulation of D
>>>>> and reports that its correctly simulated input cannot possibly
>>>>> terminate
>>>>> normally it is merely reporting an easily verified fact.
>>>>>
>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
>>>>>
>>>>> I will provide the next steps of the analysis after the above has
>>>>> been accepted.
>>>>>
>>>>>
>>>>>
>>>>
>>>> Right, it is impossibl to design an H that can correctly simulate
>>>> that D and reach a final state.
>>>>
>>>> Thus, no H can validly say the D built on it is Halting.
>>>>
>>> It is a verified fact that H does correctly report that D correctly
>>> simulated by H cannot possibly terminate normally.
>>
>> So, you admit you are working on POOP and not the Halting Problem?
>>
>
> It is a verified fact that H does correctly report that D correctly
> simulated by H cannot possibly terminate normally.
>
> Until you explicitly acknowledge that verified fact I am no longer
> willing to talk to you.
>
>

Since that isn't the question of the Halting Problem, you are just
proving that you have been LYING for the past decade about working on it.

Face it, you are just proving that you are an ignorant pathological
lying idiot that doesn't know what he is talking about but insists that
his stupid ideas MUST be right, because, by you UNSOUND logic, it must be.

The fact that you insist that I must agree to statements that I have
mostly agreed to just shows your stupidity.

Yes, H can not simulate this input to a final state. The problem is that
any H that reports this fact as an interpreation the input is
non-halting, as shown that it has NOT done a correct simulation (by the
definitons that allow the replacing of the behavior of the program by a
correct simulation), and thus has based its reasoning on unsound logic.

You have failed.

On 6/12/2023 8:55 PM, Richard Damon wrote:
> On 6/12/23 9:38 PM, olcott wrote:
>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>> On 6/12/23 8:31 PM, olcott wrote:
>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>> Software engineers can easily verify that D correctly simulated by H
>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>
>>>>>> The x86utm operating system based on an open source x86 emulator.
>>>>>> This
>>>>>> system enables one C function to execute another C function in debug
>>>>>> step mode. When H simulates D it creates a separate process
>>>>>> context for
>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>> simulations is RAM.
>>>>>>
>>>>>> // The following is written in C
>>>>>> //
>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>> 03
>>>>>> 04 int D(ptr x)
>>>>>> 05 {
>>>>>> 06   int Halt_Status = H(x, x);
>>>>>> 07   if (Halt_Status)
>>>>>> 08     HERE: goto HERE;
>>>>>> 09   return Halt_Status;
>>>>>> 10 }
>>>>>> 11
>>>>>> 12 void main()
>>>>>> 13 {
>>>>>> 14   D(D);
>>>>>> 15 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 14: main() invokes D(D)
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>>
>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>> trace of lines 14 and 06 above that D correctly simulated by H cannot
>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>
>>>>>> This means that when termination analyzer H aborts its simulation
>>>>>> of D
>>>>>> and reports that its correctly simulated input cannot possibly
>>>>>> terminate
>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>
>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>> ENGINEERING*
>>>>>>
>>>>>> I will provide the next steps of the analysis after the above has
>>>>>> been accepted.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Right, it is impossibl to design an H that can correctly simulate
>>>>> that D and reach a final state.
>>>>>
>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>
>>>> It is a verified fact that H does correctly report that D correctly
>>>> simulated by H cannot possibly terminate normally.
>>>
>>> So, you admit you are working on POOP and not the Halting Problem?
>>>
>>
>> It is a verified fact that H does correctly report that D correctly
>> simulated by H cannot possibly terminate normally.
>>
>> Until you explicitly acknowledge that verified fact I am no longer
>> willing to talk to you.
>>
>>
>
> Since that isn't the question of the Halting Problem,
Until you explicitly acknowledge that verified fact I am no longer
willing to talk to you.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 9:59 PM, olcott wrote:
> On 6/12/2023 8:55 PM, Richard Damon wrote:
>> On 6/12/23 9:38 PM, olcott wrote:
>>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>>> On 6/12/23 8:31 PM, olcott wrote:
>>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>>> Software engineers can easily verify that D correctly simulated by H
>>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>>
>>>>>>> The x86utm operating system based on an open source x86 emulator.
>>>>>>> This
>>>>>>> system enables one C function to execute another C function in debug
>>>>>>> step mode. When H simulates D it creates a separate process
>>>>>>> context for
>>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>>> simulations is RAM.
>>>>>>>
>>>>>>> // The following is written in C
>>>>>>> //
>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>>> 03
>>>>>>> 04 int D(ptr x)
>>>>>>> 05 {
>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>> 07   if (Halt_Status)
>>>>>>> 08     HERE: goto HERE;
>>>>>>> 09   return Halt_Status;
>>>>>>> 10 }
>>>>>>> 11
>>>>>>> 12 void main()
>>>>>>> 13 {
>>>>>>> 14   D(D);
>>>>>>> 15 }
>>>>>>>
>>>>>>> *Execution Trace*
>>>>>>> Line 14: main() invokes D(D)
>>>>>>>
>>>>>>> *keeps repeating* (unless aborted)
>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>>>>
>>>>>>> *Simulation invariant*
>>>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>>>
>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>> cannot
>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>
>>>>>>> This means that when termination analyzer H aborts its simulation
>>>>>>> of D
>>>>>>> and reports that its correctly simulated input cannot possibly
>>>>>>> terminate
>>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>>
>>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>>> ENGINEERING*
>>>>>>>
>>>>>>> I will provide the next steps of the analysis after the above has
>>>>>>> been accepted.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, it is impossibl to design an H that can correctly simulate
>>>>>> that D and reach a final state.
>>>>>>
>>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>>
>>>>> It is a verified fact that H does correctly report that D correctly
>>>>> simulated by H cannot possibly terminate normally.
>>>>
>>>> So, you admit you are working on POOP and not the Halting Problem?
>>>>
>>>
>>> It is a verified fact that H does correctly report that D correctly
>>> simulated by H cannot possibly terminate normally.
>>>
>>> Until you explicitly acknowledge that verified fact I am no longer
>>> willing to talk to you.
>>>
>>>
>>
>> Since that isn't the question of the Halting Problem,
> Until you explicitly acknowledge that verified fact I am no longer
> willing to talk to you.
>
>

Which verifyied fact?

I agree that H can not correctly simulate its input to a final state.
The problem is that you miss the implication of this.

If H aborts its simulation to try to give an answer, it now has failed
to "correctly simulate" its input by any definition that allows it to
substitute the simulation for the actual behavior of the program.

Thus, you statement that H can not correctly simulate its input to a
final state DOES NOT MEAN that it is correct to abort and say the input
is non-halting, as that action violates the premise that it does
correctly simulated the input.

Having been on the path to that result, doesn't mean it is allowed to
depart and still be on the path.

If you are on the highway to your destination, you can't get off early
and still say that you took the road all the way to your destination,
and the only simulation that shows behavior is the simulation that goes
to the end.

How can a simulation show something that it never has seen. It has been
noted that the behavior of the code of D after H returns to it affect
the correct answer, so H can't determine the correct answer without
seeing that behavior.

And, since the question IS about the original machine, and NOT H's
simulation of it (unless H performs a COMPLETE and correct simulation of
the input) its simulation is unable to prove the right answer.

You are just proving that you are totally ignorant of what you talk
about, and a pathological liar about what you are doing.

You are just trying to lie that you are actually working on the Halting
Problem, when it is clear you know virtually nothing about the topic.
You show utter stupidity about anything connected to it, or logic, or
what is truth.

On 6/12/2023 10:03 PM, Richard Damon wrote:
> On 6/12/23 9:59 PM, olcott wrote:
>> On 6/12/2023 8:55 PM, Richard Damon wrote:
>>> On 6/12/23 9:38 PM, olcott wrote:
>>>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>>>> On 6/12/23 8:31 PM, olcott wrote:
>>>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>>>> Software engineers can easily verify that D correctly simulated
>>>>>>>> by H
>>>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>>>
>>>>>>>> The x86utm operating system based on an open source x86
>>>>>>>> emulator. This
>>>>>>>> system enables one C function to execute another C function in
>>>>>>>> debug
>>>>>>>> step mode. When H simulates D it creates a separate process
>>>>>>>> context for
>>>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>>>> simulations is RAM.
>>>>>>>>
>>>>>>>> // The following is written in C
>>>>>>>> //
>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>>>>>>> 03
>>>>>>>> 04 int D(ptr x)
>>>>>>>> 05 {
>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>> 07   if (Halt_Status)
>>>>>>>> 08     HERE: goto HERE;
>>>>>>>> 09   return Halt_Status;
>>>>>>>> 10 }
>>>>>>>> 11
>>>>>>>> 12 void main()
>>>>>>>> 13 {
>>>>>>>> 14   D(D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>
>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>> D(D)
>>>>>>>>
>>>>>>>> *Simulation invariant*
>>>>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>>>>
>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>> cannot
>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>
>>>>>>>> This means that when termination analyzer H aborts its
>>>>>>>> simulation of D
>>>>>>>> and reports that its correctly simulated input cannot possibly
>>>>>>>> terminate
>>>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>>>
>>>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>>>> ENGINEERING*
>>>>>>>>
>>>>>>>> I will provide the next steps of the analysis after the above
>>>>>>>> has been accepted.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, it is impossibl to design an H that can correctly simulate
>>>>>>> that D and reach a final state.
>>>>>>>
>>>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>>>
>>>>>> It is a verified fact that H does correctly report that D correctly
>>>>>> simulated by H cannot possibly terminate normally.
>>>>>
>>>>> So, you admit you are working on POOP and not the Halting Problem?
>>>>>
>>>>
>>>> It is a verified fact that H does correctly report that D correctly
>>>> simulated by H cannot possibly terminate normally.
>>>>
>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>> willing to talk to you.
>>>>
>>>>
>>>
>>> Since that isn't the question of the Halting Problem,
>> Until you explicitly acknowledge that verified fact I am no longer
>> willing to talk to you.
>>
>>
>
> Which verifyied fact?
>
It is a verified fact that H does correctly report that D correctly
simulated by H cannot possibly terminate normally.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 11:04 PM, olcott wrote:
> On 6/12/2023 10:03 PM, Richard Damon wrote:
>> On 6/12/23 9:59 PM, olcott wrote:
>>> On 6/12/2023 8:55 PM, Richard Damon wrote:
>>>> On 6/12/23 9:38 PM, olcott wrote:
>>>>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>>>>> On 6/12/23 8:31 PM, olcott wrote:
>>>>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>>>>> Software engineers can easily verify that D correctly simulated
>>>>>>>>> by H
>>>>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>>>>
>>>>>>>>> The x86utm operating system based on an open source x86
>>>>>>>>> emulator. This
>>>>>>>>> system enables one C function to execute another C function in
>>>>>>>>> debug
>>>>>>>>> step mode. When H simulates D it creates a separate process
>>>>>>>>> context for
>>>>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>>>>> simulations is RAM.
>>>>>>>>>
>>>>>>>>> // The following is written in C
>>>>>>>>> //
>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its
>>>>>>>>> input
>>>>>>>>> 03
>>>>>>>>> 04 int D(ptr x)
>>>>>>>>> 05 {
>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>> 09   return Halt_Status;
>>>>>>>>> 10 }
>>>>>>>>> 11
>>>>>>>>> 12 void main()
>>>>>>>>> 13 {
>>>>>>>>> 14   D(D);
>>>>>>>>> 15 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>>>>> D(D)
>>>>>>>>>
>>>>>>>>> *Simulation invariant*
>>>>>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>>>>>
>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>>> cannot
>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>
>>>>>>>>> This means that when termination analyzer H aborts its
>>>>>>>>> simulation of D
>>>>>>>>> and reports that its correctly simulated input cannot possibly
>>>>>>>>> terminate
>>>>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>>>>
>>>>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>>>>> ENGINEERING*
>>>>>>>>>
>>>>>>>>> I will provide the next steps of the analysis after the above
>>>>>>>>> has been accepted.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, it is impossibl to design an H that can correctly
>>>>>>>> simulate that D and reach a final state.
>>>>>>>>
>>>>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>>>>
>>>>>>> It is a verified fact that H does correctly report that D correctly
>>>>>>> simulated by H cannot possibly terminate normally.
>>>>>>
>>>>>> So, you admit you are working on POOP and not the Halting Problem?
>>>>>>
>>>>>
>>>>> It is a verified fact that H does correctly report that D correctly
>>>>> simulated by H cannot possibly terminate normally.
>>>>>
>>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>>> willing to talk to you.
>>>>>
>>>>>
>>>>
>>>> Since that isn't the question of the Halting Problem,
>>> Until you explicitly acknowledge that verified fact I am no longer
>>> willing to talk to you.
>>>
>>>
>>
>> Which verifyied fact?
>>
> It is a verified fact that H does correctly report that D correctly
> simulated by H cannot possibly terminate normally.
>

And how have you "verified" that?

Remember, any H that has aborted its simulation has not "correctly
simulated" its input per the requirements to use a simulation in place
of the actual behavior of the program.

Since H does abort its simulation, it hasn't "Correctly Simulated" its
input per the requirements to use the simulation in the place of the
actual behavior of the program.

A statment that is based on a false premise is not true.

You are just proveing yourself to be a hypocrit, as well as the ignorant
pathological lying idiot, as you yourself say that truth must start from
the basics truths of the system, so since H doesn't correctly simulate
its input, you can't presume that it does.

FAIL.

On 6/12/2023 10:14 PM, Richard Damon wrote:
> On 6/12/23 11:04 PM, olcott wrote:
>> On 6/12/2023 10:03 PM, Richard Damon wrote:
>>> On 6/12/23 9:59 PM, olcott wrote:
>>>> On 6/12/2023 8:55 PM, Richard Damon wrote:
>>>>> On 6/12/23 9:38 PM, olcott wrote:
>>>>>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>>>>>> On 6/12/23 8:31 PM, olcott wrote:
>>>>>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>>>>>> Software engineers can easily verify that D correctly
>>>>>>>>>> simulated by H
>>>>>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>>>>>
>>>>>>>>>> The x86utm operating system based on an open source x86
>>>>>>>>>> emulator. This
>>>>>>>>>> system enables one C function to execute another C function in
>>>>>>>>>> debug
>>>>>>>>>> step mode. When H simulates D it creates a separate process
>>>>>>>>>> context for
>>>>>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>>>>>> simulations is RAM.
>>>>>>>>>>
>>>>>>>>>> // The following is written in C
>>>>>>>>>> //
>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its
>>>>>>>>>> input
>>>>>>>>>> 03
>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>> 05 {
>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>> 10 }
>>>>>>>>>> 11
>>>>>>>>>> 12 void main()
>>>>>>>>>> 13 {
>>>>>>>>>> 14   D(D);
>>>>>>>>>> 15 }
>>>>>>>>>>
>>>>>>>>>> *Execution Trace*
>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>
>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>> simulates D(D)
>>>>>>>>>>
>>>>>>>>>> *Simulation invariant*
>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line 09.
>>>>>>>>>>
>>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by H
>>>>>>>>>> cannot
>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>
>>>>>>>>>> This means that when termination analyzer H aborts its
>>>>>>>>>> simulation of D
>>>>>>>>>> and reports that its correctly simulated input cannot possibly
>>>>>>>>>> terminate
>>>>>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>>>>>
>>>>>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>>>>>> ENGINEERING*
>>>>>>>>>>
>>>>>>>>>> I will provide the next steps of the analysis after the above
>>>>>>>>>> has been accepted.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, it is impossibl to design an H that can correctly
>>>>>>>>> simulate that D and reach a final state.
>>>>>>>>>
>>>>>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>>>>>
>>>>>>>> It is a verified fact that H does correctly report that D correctly
>>>>>>>> simulated by H cannot possibly terminate normally.
>>>>>>>
>>>>>>> So, you admit you are working on POOP and not the Halting Problem?
>>>>>>>
>>>>>>
>>>>>> It is a verified fact that H does correctly report that D correctly
>>>>>> simulated by H cannot possibly terminate normally.
>>>>>>
>>>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>>>> willing to talk to you.
>>>>>>
>>>>>>
>>>>>
>>>>> Since that isn't the question of the Halting Problem,
>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>> willing to talk to you.
>>>>
>>>>
>>>
>>> Which verifyied fact?
>>>
>> It is a verified fact that H does correctly report that D correctly
>> simulated by H cannot possibly terminate normally.
>>
>
> And how have you "verified" that?
>
> Remember, any H that has aborted its simulation has not "correctly
> simulated" its input

As per the requirements of a termination analyzer that has been designed
to prevent DOS attacks

It is a verified fact that H does correctly report that D correctly
simulated by H cannot possibly terminate normally, thus D must not be
allowed to execute.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/12/23 11:32 PM, olcott wrote:
> On 6/12/2023 10:14 PM, Richard Damon wrote:
>> On 6/12/23 11:04 PM, olcott wrote:
>>> On 6/12/2023 10:03 PM, Richard Damon wrote:
>>>> On 6/12/23 9:59 PM, olcott wrote:
>>>>> On 6/12/2023 8:55 PM, Richard Damon wrote:
>>>>>> On 6/12/23 9:38 PM, olcott wrote:
>>>>>>> On 6/12/2023 8:26 PM, Richard Damon wrote:
>>>>>>>> On 6/12/23 8:31 PM, olcott wrote:
>>>>>>>>> On 6/12/2023 6:36 PM, Richard Damon wrote:
>>>>>>>>>> On 6/12/23 12:40 PM, olcott wrote:
>>>>>>>>>>> Software engineers can easily verify that D correctly
>>>>>>>>>>> simulated by H
>>>>>>>>>>> cannot possibly reach its own line 09 and terminate normally.
>>>>>>>>>>>
>>>>>>>>>>> The x86utm operating system based on an open source x86
>>>>>>>>>>> emulator. This
>>>>>>>>>>> system enables one C function to execute another C function
>>>>>>>>>>> in debug
>>>>>>>>>>> step mode. When H simulates D it creates a separate process
>>>>>>>>>>> context for
>>>>>>>>>>> D with its own memory, stack and virtual registers. H is able to
>>>>>>>>>>> simulate D simulating itself, thus the only limit to recursive
>>>>>>>>>>> simulations is RAM.
>>>>>>>>>>>
>>>>>>>>>>> // The following is written in C
>>>>>>>>>>> //
>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its
>>>>>>>>>>> input
>>>>>>>>>>> 03
>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>> 05 {
>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>> 10 }
>>>>>>>>>>> 11
>>>>>>>>>>> 12 void main()
>>>>>>>>>>> 13 {
>>>>>>>>>>> 14   D(D);
>>>>>>>>>>> 15 }
>>>>>>>>>>>
>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>
>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>
>>>>>>>>>>> *Simulation invariant*
>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>> 09.
>>>>>>>>>>>
>>>>>>>>>>> Is it dead obvious to everyone here when examining the execution
>>>>>>>>>>> trace of lines 14 and 06 above that D correctly simulated by
>>>>>>>>>>> H cannot
>>>>>>>>>>> possibly terminate normally by reaching its own line 09?
>>>>>>>>>>>
>>>>>>>>>>> This means that when termination analyzer H aborts its
>>>>>>>>>>> simulation of D
>>>>>>>>>>> and reports that its correctly simulated input cannot
>>>>>>>>>>> possibly terminate
>>>>>>>>>>> normally it is merely reporting an easily verified fact.
>>>>>>>>>>>
>>>>>>>>>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE
>>>>>>>>>>> ENGINEERING*
>>>>>>>>>>>
>>>>>>>>>>> I will provide the next steps of the analysis after the above
>>>>>>>>>>> has been accepted.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, it is impossibl to design an H that can correctly
>>>>>>>>>> simulate that D and reach a final state.
>>>>>>>>>>
>>>>>>>>>> Thus, no H can validly say the D built on it is Halting.
>>>>>>>>>>
>>>>>>>>> It is a verified fact that H does correctly report that D
>>>>>>>>> correctly
>>>>>>>>> simulated by H cannot possibly terminate normally.
>>>>>>>>
>>>>>>>> So, you admit you are working on POOP and not the Halting Problem?
>>>>>>>>
>>>>>>>
>>>>>>> It is a verified fact that H does correctly report that D correctly
>>>>>>> simulated by H cannot possibly terminate normally.
>>>>>>>
>>>>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>>>>> willing to talk to you.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Since that isn't the question of the Halting Problem,
>>>>> Until you explicitly acknowledge that verified fact I am no longer
>>>>> willing to talk to you.
>>>>>
>>>>>
>>>>
>>>> Which verifyied fact?
>>>>
>>> It is a verified fact that H does correctly report that D correctly
>>> simulated by H cannot possibly terminate normally.
>>>
>>
>> And how have you "verified" that?
>>
>> Remember, any H that has aborted its simulation has not "correctly
>> simulated" its input
>
> As per the requirements of a termination analyzer that has been designed
> to prevent DOS attacks
>
> It is a verified fact that H does correctly report that D correctly
> simulated by H cannot possibly terminate normally, thus D must not be
> allowed to execute.
>
>

So, you admit to not working on the Halting Problem, but are only
working on your POOP.

Fine, just don't lie and claim you have proved something you haven't.

You are just a hypocritical ignorant pathological lying idiot.

You have failed, and any possible use of your idea about "correct
reasoning" have been destroyed by your tainting all your work with your
falsehoods.

YOU HAVE FAILED.