00 int H(ptr x, ptr x) // ptr is pointer to int function
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

We are examining the behavior of D(D) for every possible H/D pair
where 1 to N steps of D(D) are simulated by H.

*Execution Trace*
Line 11: main() invokes H(D,D) that simulates D(D)

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

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

(a) It is a verified fact that for every possible H/D pair where
1 to N steps of D(D) are simulated by H that this simulated D(D)
cannot possibly reach past its own line 03.

(b) Rebuttals must show a counter example where 1 to N steps
of D(D) are simulated by H and the simulated D(D) reaches past
its own line 03.

*Termination Analyzer H is Not Fooled by Pathological Input D*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

*Fully operational code implemented in the x86utm operating system*
https://github.com/plolcott/x86utm

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

On 5/3/24 9:40 AM, olcott wrote:
> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
> 01 int D(ptr x)
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> We are examining the behavior of D(D) for every possible H/D pair
> where 1 to N steps of D(D) are simulated by H.
>
> *Execution Trace*
> Line 11: main() invokes H(D,D) that simulates D(D)
>
> *keeps repeating* (unless aborted)
> Line 01
> Line 02
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.

Nope.

>
> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.

WAS DONE.

>
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
>
>
>

Proven wrong, and you have declined to try to refute that proof.

If you claim I haven't done this, make a clear statement of that claim,
with a clear statement that if I can point out where I did this, and you
failed to respond, you will admit that you are just wrong and will admit
that you logic is just broken and will give up the statement that people
haven't refuted you.

Unitl then, you have effectively conceded that you statement is just
FALSE, and your repeating it is just demonstration that are just a
pathological liar that doesn't understand what he is talking abour.

On 5/3/2024 8:40 AM, olcott wrote:
> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
> 01 int D(ptr x)
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> We are examining the behavior of D(D) for every possible H/D pair
> where 1 to N steps of D(D) are simulated by H.
>
> *Execution Trace*
> Line 11: main() invokes H(D,D) that simulates D(D)
>
> *keeps repeating* (unless aborted)
> Line 01
> Line 02
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.

Since everyone is denying these facts on the basis that no one
here has a clue about what execution traces are and how they work
it makes no sense to go to the next step.

>
> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.
>
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
>
>
>

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

On 5/3/2024 8:40 AM, olcott wrote:
> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
> 01 int D(ptr x)
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> We are examining the behavior of D(D) for every possible H/D pair
> where 1 to N steps of D(D) are simulated by H.
>
> *Execution Trace*
> Line 11: main() invokes H(D,D) that simulates D(D)
>
> *keeps repeating* (unless aborted)
> Line 01
> Line 02
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> (a) It is a verified fact that for every possible H/D pair where
> 1 to N steps of D(D) are simulated by H that this simulated D(D)
> cannot possibly reach past its own line 03.
>

I only had to add this new step because I found that some people just
do not understand that when the executed H(D,D) aborts its simulated
input that all of the nested simulations (if any) immediately totally
stop running. No simulated H ever returns any value to any simulated D.
We can sum this up much more concisely with (a).

> (b) Rebuttals must show a counter example where 1 to N steps
> of D(D) are simulated by H and the simulated D(D) reaches past
> its own line 03.
>
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>
> *Fully operational code implemented in the x86utm operating system*
> https://github.com/plolcott/x86utm
>
>
>

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

On 5/3/24 6:42 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>> 01 int D(ptr x)
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> We are examining the behavior of D(D) for every possible H/D pair
>> where 1 to N steps of D(D) are simulated by H.
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D) that simulates D(D)
>>
>> *keeps repeating* (unless aborted)
>> Line 01
>> Line 02
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
>
> Since everyone is denying these facts on the basis that no one
> here has a clue about what execution traces are and how they work
> it makes no sense to go to the next step.

(a) has been proven incorrect.

If you won't make the effort to try to refute that proof, you are just
admitting that you are not interested in an honest dialog.

Of course people won't accept a step that is known to be incorrect.

If you won't handle the objections, YOU are the one holding up your
progress.

>
>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.

Which it was.

>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
>

On 5/3/24 8:13 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>> 01 int D(ptr x)
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> We are examining the behavior of D(D) for every possible H/D pair
>> where 1 to N steps of D(D) are simulated by H.
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D) that simulates D(D)
>>
>> *keeps repeating* (unless aborted)
>> Line 01
>> Line 02
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
>>
>
> I only had to add this new step because I found that some people just
> do not understand that when the executed H(D,D) aborts its simulated
> input that all of the nested simulations (if any) immediately totally
> stop running. No simulated H ever returns any value to any simulated D.
> We can sum this up much more concisely with (a).

Fixing definitions is good.

The refutation of (a) that I gave didn't use that "loop hole" and both
of the examples actually simulated the steps to past line 3.

After all, how can you simulate past line 3 and not simulate any steps?

The no-simulation case was just showing that using your conclusion from
(a) and saying that H is correct to abort here, allows, with just as
valid of logic, to allow a decider to trivally decide to abort either
after 0, or with your modification, after 1 step, to just abort and say
it couldn't reach the end.

>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.

Was done.

You need to refute that example or you are just admitting you are a liar
that makes claims that have been disproven.

The fact that you don't understand how it was disproven, the fact that
you know that the statements were made and you haven't refuted it, means
your claims have become unproven statements, and thus not valid to claim.

>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
>

On 5/3/2024 4:53 PM, Richard Damon wrote:
> On 5/3/24 9:40 AM, olcott wrote:
>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>> 01 int D(ptr x)
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> We are examining the behavior of D(D) for every possible H/D pair
>> where 1 to N steps of D(D) are simulated by H.
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D) that simulates D(D)
>>
>> *keeps repeating* (unless aborted)
>> Line 01
>> Line 02
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
>
> Nope.
>

*This only requires knowing two things*
(1) What an execution trace is and how it works.
You seem to know that other people here do not.

(2) When the executed H(D,D) aborts its simulated input
that all of the nested simulations (if any) immediately
totally stop running. No simulated H ever returns any value
to any simulated D.

*This seems to be over your head and you don't know it*

>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.
>
> WAS DONE.
>
>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
>
> Proven wrong, and you have declined to try to refute that proof.
>
> If you claim I haven't done this, make a clear statement of that claim,
> with a clear statement that if I can point out where I did this, and you
> failed to respond, you will admit that you are just wrong and will admit
> that you logic is just broken and will give up the statement that people
> haven't refuted you.
>
> Unitl then, you have effectively conceded that you statement is just
> FALSE, and your repeating it is just demonstration that are just a
> pathological liar that doesn't understand what he is talking abour.

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

On 5/3/2024 10:24 PM, Richard Damon wrote:
> On 5/3/24 8:13 PM, olcott wrote:
>> On 5/3/2024 8:40 AM, olcott wrote:
>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>> 01 int D(ptr x)
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> We are examining the behavior of D(D) for every possible H/D pair
>>> where 1 to N steps of D(D) are simulated by H.
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 01
>>> Line 02
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>>
>>
>> I only had to add this new step because I found that some people just
>> do not understand that when the executed H(D,D) aborts its simulated
>> input that all of the nested simulations (if any) immediately totally
>> stop running. No simulated H ever returns any value to any simulated D.
>> We can sum this up much more concisely with (a).
>
> Fixing definitions is good.
>
> The refutation of (a) that I gave didn't use that "loop hole" and both
> of the examples actually simulated the steps to past line 3.
>
> After all, how can you simulate past line 3 and not simulate any steps?
>

THIS WAS THE DEFINITION THAT YOU RESPONDED TO
(a) It is a verified fact that *D(D) simulated by H* cannot
possibly reach past line 03 of *D(D) simulated by H* whether
H aborts its simulation or not.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
That is a ridiculously stupid mistake.

> The no-simulation case was just showing that using your conclusion from
> (a) and saying that H is correct to abort here, allows, with just as
> valid of logic, to allow a decider to trivally decide to abort either
> after 0, or with your modification, after 1 step, to just abort and say
> it couldn't reach the end.
>
>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
>
> Was done.
>
> You need to refute that example or you are just admitting you are a liar
> that makes claims that have been disproven.
>

No I am proving that one of your rebuttals was a ridiculously stupid
mistake. When you make a ridiculously stupid mistake that is not me
lying at all.

If you have a better rebuttal please provide it.

> The fact that you don't understand how it was disproven, the fact that
> you know that the statements were made and you haven't refuted it, means
> your claims have become unproven statements, and thus not valid to claim.
>

*It was not me that made the ridiculously stupid mistake*

>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
>

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

On 5/3/2024 5:42 PM, olcott wrote:
> On 5/3/2024 8:40 AM, olcott wrote:
>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>> 01 int D(ptr x)
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> We are examining the behavior of D(D) for every possible H/D pair
>> where 1 to N steps of D(D) are simulated by H.
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D) that simulates D(D)
>>
>> *keeps repeating* (unless aborted)
>> Line 01
>> Line 02
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> (a) It is a verified fact that for every possible H/D pair where
>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>> cannot possibly reach past its own line 03.
>
> Since everyone is denying these facts on the basis that no one
> here has a clue about what execution traces are and how they work
> it makes no sense to go to the next step.
>

The next step depends on this prior step and is trivially
entailed by this prior step. When each D simulated by H
of the infinite set of H/D pairs cannot possibly reach past
its own line 03 then it cannot possibly reach its own line
06 and halt.

There is one more software engineering step that depends
on the above steps and is trivially entailed by the above
step. After this last software engineering step we begin
to get into the computer science steps.

>>
>> (b) Rebuttals must show a counter example where 1 to N steps
>> of D(D) are simulated by H and the simulated D(D) reaches past
>> its own line 03.
>>
>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>
>> *Fully operational code implemented in the x86utm operating system*
>> https://github.com/plolcott/x86utm
>>
>>
>>
>

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

On 5/3/24 10:32 PM, olcott wrote:
> On 5/3/2024 4:53 PM, Richard Damon wrote:
>> On 5/3/24 9:40 AM, olcott wrote:
>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>> 01 int D(ptr x)
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> We are examining the behavior of D(D) for every possible H/D pair
>>> where 1 to N steps of D(D) are simulated by H.
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 01
>>> Line 02
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>
>> Nope.
>>
>
> *This only requires knowing two things*
> (1) What an execution trace is and how it works.
> You seem to know that other people here do not.

Proven otherwise and ignored by you, proving you are just a pathological
liar.

>
> (2) When the executed H(D,D) aborts its simulated input
> that all of the nested simulations (if any) immediately
> totally stop running. No simulated H ever returns any value
> to any simulated D.
>
> *This seems to be over your head and you don't know it*

Nope, it stops the SIMULATION of all the programs nested in it, but does
not stop the BEHAVIOR of those programs, as that is defined by the
direct execution of it.

This seems over YOUR head.

>
>>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
>>
>> WAS DONE.
>>
>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
>> Proven wrong, and you have declined to try to refute that proof.
>>
>> If you claim I haven't done this, make a clear statement of that
>> claim, with a clear statement that if I can point out where I did
>> this, and you failed to respond, you will admit that you are just
>> wrong and will admit that you logic is just broken and will give up
>> the statement that people haven't refuted you.
>>
>> Unitl then, you have effectively conceded that you statement is just
>> FALSE, and your repeating it is just demonstration that are just a
>> pathological liar that doesn't understand what he is talking abour.
>

On 5/3/24 7:55 PM, olcott wrote:
> On 5/3/2024 5:42 PM, olcott wrote:
>> On 5/3/2024 8:40 AM, olcott wrote:
>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>> 01 int D(ptr x)
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> We are examining the behavior of D(D) for every possible H/D pair
>>> where 1 to N steps of D(D) are simulated by H.
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 01
>>> Line 02
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> (a) It is a verified fact that for every possible H/D pair where
>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>> cannot possibly reach past its own line 03.
>>
>> Since everyone is denying these facts on the basis that no one
>> here has a clue about what execution traces are and how they work
>> it makes no sense to go to the next step.
>>
>
> The next step depends on this prior step and is trivially
> entailed by this prior step. When each D simulated by H
> of the infinite set of H/D pairs cannot possibly reach past
> its own line 03 then it cannot possibly reach its own line
> 06 and halt.
>
> There is one more software engineering step that depends
> on the above steps and is trivially entailed by the above
> step. After this last software engineering step we begin
> to get into the computer science steps.
>

And since that step is wrong, you need to go back and fix it.

Your (a) has been proven INCORRECT, and descriptions of TWO DIFFERENT
methods that an H could use to get past there described.

Your ignoring them just proves you are just a pathological liar.

>>>
>>> (b) Rebuttals must show a counter example where 1 to N steps
>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>> its own line 03.
>>>
>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>
>>> *Fully operational code implemented in the x86utm operating system*
>>> https://github.com/plolcott/x86utm
>>>
>>>
>>>
>>
>

On 5/3/24 11:39 PM, olcott wrote:
> On 5/3/2024 10:24 PM, Richard Damon wrote:
>> On 5/3/24 8:13 PM, olcott wrote:
>>> On 5/3/2024 8:40 AM, olcott wrote:
>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>> 01 int D(ptr x)
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> We are examining the behavior of D(D) for every possible H/D pair
>>>> where 1 to N steps of D(D) are simulated by H.
>>>>
>>>> *Execution Trace*
>>>> Line 11: main() invokes H(D,D) that simulates D(D)
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 01
>>>> Line 02
>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>
>>>> (a) It is a verified fact that for every possible H/D pair where
>>>> 1 to N steps of D(D) are simulated by H that this simulated D(D)
>>>> cannot possibly reach past its own line 03.
>>>>
>>>
>>> I only had to add this new step because I found that some people just
>>> do not understand that when the executed H(D,D) aborts its simulated
>>> input that all of the nested simulations (if any) immediately totally
>>> stop running. No simulated H ever returns any value to any simulated D.
>>> We can sum this up much more concisely with (a).
>>
>> Fixing definitions is good.
>>
>> The refutation of (a) that I gave didn't use that "loop hole" and both
>> of the examples actually simulated the steps to past line 3.
>>
>> After all, how can you simulate past line 3 and not simulate any steps?
>>
>
> THIS WAS THE DEFINITION THAT YOU RESPONDED TO
> (a) It is a verified fact that *D(D) simulated by H* cannot
> possibly reach past line 03 of *D(D) simulated by H* whether
> H aborts its simulation or not.
>
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
>
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
>
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.
>
> You took *D(D) simulated by H* to mean *D(D) NEVER simulated by H*
> That is a ridiculously stupid mistake.

You are looking at the wrong case and don't even seem to understand what
I was saying,

THAT example actually took your assumption that (a) was true, and
thought, based on this statement being true, what can I show, and I
showed that you can make a valid H that calls almost every input to be
non-halting.

You donn't seem to actually understand how logic works.

>
>> The no-simulation case was just showing that using your conclusion
>> from (a) and saying that H is correct to abort here, allows, with just
>> as valid of logic, to allow a decider to trivally decide to abort
>> either after 0, or with your modification, after 1 step, to just abort
>> and say it couldn't reach the end.
>>
>>>
>>>> (b) Rebuttals must show a counter example where 1 to N steps
>>>> of D(D) are simulated by H and the simulated D(D) reaches past
>>>> its own line 03.
>>
>> Was done.
>>
>> You need to refute that example or you are just admitting you are a
>> liar that makes claims that have been disproven.
>>
>
> No I am proving that one of your rebuttals was a ridiculously stupid
> mistake. When you make a ridiculously stupid mistake that is not me
> lying at all.

But you need to prove that ALL my rebuttals don't work.

>
> If you have a better rebuttal please provide it.

I did. You ignored it.

>
>> The fact that you don't understand how it was disproven, the fact that
>> you know that the statements were made and you haven't refuted it,
>> means your claims have become unproven statements, and thus not valid
>> to claim.
>>
>
> *It was not me that made the ridiculously stupid mistake*

Yep, it was.

>
>>>>
>>>> *Termination Analyzer H is Not Fooled by Pathological Input D*
>>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>>>>
>>>> *Fully operational code implemented in the x86utm operating system*
>>>> https://github.com/plolcott/x86utm
>>>>
>>>>
>>>>
>>>
>>
>