On 1/16/2024 6:42 PM, immibis wrote:
> On 1/16/24 15:52, olcott wrote:
>> On 1/16/2024 1:49 AM, immibis wrote:
>>> On 1/16/24 00:55, olcott wrote:
>>>> On 1/14/2024 10:55 PM, immibis wrote:
>>>>> On 1/14/24 16:55, olcott wrote:
>>>>>> On 1/14/2024 2:14 AM, immibis wrote:
>>>>>>> On 1/13/24 17:15, olcott wrote:
>>>>>>>> On 1/13/2024 6:07 AM, immibis wrote:
>>>>>>>>> On 1/13/24 04:39, Richard Damon wrote:
>>>>>>>>>> So, are you admitting that H doesn't care about getting the
>>>>>>>>>> right answer to the Halting Problem? (Since it doesn't rely on
>>>>>>>>>> the actual definiton of what it is to do)
>>>>>>>>>
>>>>>>>>> Olcott has acknowledged at least a few times that his H doesn't
>>>>>>>>> solve the halting problem, but he thinks it does solve a
>>>>>>>>> different problem, which I'll call the Olcott-halting problem,
>>>>>>>>> which is the halting problem for "non-self-contradictory"
>>>>>>>>> programs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is true that H either correctly solves the halting problem
>>>>>>>> or the halting problem's pathological input must be rejected
>>>>>>>> as semantically invalid.
>>>>>>>>
>>>>>>>>> He hasn't even solved that, and he can't even tell which
>>>>>>>>> programs are self-contradictory,
>>>>>>>>
>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>>>>> At the bottom of the file:
>>>>>>>>
>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112fd1
>>>>>>>> Address_of_H:1542
>>>>>>>> [00001c72][00112fbd][00112fc1] 55             push ebp
>>>>>>>> [00001c73][00112fbd][00112fc1] 8bec           mov ebp,esp
>>>>>>>> [00001c75][00112fb9][00102f8d] 51             push ecx
>>>>>>>> [00001c76][00112fb9][00102f8d] 8b4508         mov eax,[ebp+08]
>>>>>>>> [00001c79][00112fb5][00001c72] 50             push eax
>>>>>>>> [00001c7a][00112fb5][00001c72] 8b4d08         mov ecx,[ebp+08]
>>>>>>>> [00001c7d][00112fb1][00001c72] 51             push ecx
>>>>>>>> [00001c7e][00112fad][00001c83] e8bff8ffff     call 00001542
>>>>>>>> H: *Infinitely Recursive Simulation Detected Simulation Stopped*
>>>>>>>
>>>>>>> The simulation is only infinitely recursive if the program it
>>>>>>> simulates doesn't have an infinite recursion checker. If it has
>>>>>>> an infinite recursion checker, the checker stops the recursion
>>>>>>> and it isn't infinite.
>>>>>>>
>>>>>>
>>>>>> void Infinite_Loop2()
>>>>>> {
>>>>>> L1: goto L3;
>>>>>> L2: goto L1;
>>>>>> L3: goto L2;
>>>>>> }
>>>>>>
>>>>>> The above is not an actual infinite loop because
>>>>>> its simulator aborts it simulation?
>>>>>>
>>>>> The above is not a simulator.
>>>>
>>>> Exactly what software engineering background do you have?
>>>> I have been a professional C++ software engineer since 2000.
>>>>
>>> Enough to understand the difference between the inner simulator and
>>> the outer simulator when you simulate a simulator.
>>
>> Apparently not quite.
>> I repeat the question what computer language do you have
>> ten full time years as a software engineer?
>>
>
> Enough to understand that if the only reason a program doesn't reach its
> final state is that it's aborted

Yes that right there proves that you simply don't have
sufficient technical understanding.

*You are incapable of comprehending recursive simulation*
THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION

> then the correct return value from the
> halting decider is 1.

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

On 1/16/24 8:31 PM, olcott wrote:
> On 1/16/2024 6:42 PM, immibis wrote:
>> On 1/16/24 15:52, olcott wrote:
>>> On 1/16/2024 1:49 AM, immibis wrote:
>>>> On 1/16/24 00:55, olcott wrote:
>>>>> On 1/14/2024 10:55 PM, immibis wrote:
>>>>>> On 1/14/24 16:55, olcott wrote:
>>>>>>> On 1/14/2024 2:14 AM, immibis wrote:
>>>>>>>> On 1/13/24 17:15, olcott wrote:
>>>>>>>>> On 1/13/2024 6:07 AM, immibis wrote:
>>>>>>>>>> On 1/13/24 04:39, Richard Damon wrote:
>>>>>>>>>>> So, are you admitting that H doesn't care about getting the
>>>>>>>>>>> right answer to the Halting Problem? (Since it doesn't rely
>>>>>>>>>>> on the actual definiton of what it is to do)
>>>>>>>>>>
>>>>>>>>>> Olcott has acknowledged at least a few times that his H
>>>>>>>>>> doesn't solve the halting problem, but he thinks it does solve
>>>>>>>>>> a different problem, which I'll call the Olcott-halting
>>>>>>>>>> problem, which is the halting problem for
>>>>>>>>>> "non-self-contradictory" programs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is true that H either correctly solves the halting problem
>>>>>>>>> or the halting problem's pathological input must be rejected
>>>>>>>>> as semantically invalid.
>>>>>>>>>
>>>>>>>>>> He hasn't even solved that, and he can't even tell which
>>>>>>>>>> programs are self-contradictory,
>>>>>>>>>
>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>>>>>> At the bottom of the file:
>>>>>>>>>
>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112fd1
>>>>>>>>> Address_of_H:1542
>>>>>>>>> [00001c72][00112fbd][00112fc1] 55             push ebp
>>>>>>>>> [00001c73][00112fbd][00112fc1] 8bec           mov ebp,esp
>>>>>>>>> [00001c75][00112fb9][00102f8d] 51             push ecx
>>>>>>>>> [00001c76][00112fb9][00102f8d] 8b4508         mov eax,[ebp+08]
>>>>>>>>> [00001c79][00112fb5][00001c72] 50             push eax
>>>>>>>>> [00001c7a][00112fb5][00001c72] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>> [00001c7d][00112fb1][00001c72] 51             push ecx
>>>>>>>>> [00001c7e][00112fad][00001c83] e8bff8ffff     call 00001542
>>>>>>>>> H: *Infinitely Recursive Simulation Detected Simulation Stopped*
>>>>>>>>
>>>>>>>> The simulation is only infinitely recursive if the program it
>>>>>>>> simulates doesn't have an infinite recursion checker. If it has
>>>>>>>> an infinite recursion checker, the checker stops the recursion
>>>>>>>> and it isn't infinite.
>>>>>>>>
>>>>>>>
>>>>>>> void Infinite_Loop2()
>>>>>>> {
>>>>>>> L1: goto L3;
>>>>>>> L2: goto L1;
>>>>>>> L3: goto L2;
>>>>>>> }
>>>>>>>
>>>>>>> The above is not an actual infinite loop because
>>>>>>> its simulator aborts it simulation?
>>>>>>>
>>>>>> The above is not a simulator.
>>>>>
>>>>> Exactly what software engineering background do you have?
>>>>> I have been a professional C++ software engineer since 2000.
>>>>>
>>>> Enough to understand the difference between the inner simulator and
>>>> the outer simulator when you simulate a simulator.
>>>
>>> Apparently not quite.
>>> I repeat the question what computer language do you have
>>> ten full time years as a software engineer?
>>>
>>
>> Enough to understand that if the only reason a program doesn't reach
>> its final state is that it's aborted
>
> Yes that right there proves that you simply don't have
> sufficient technical understanding.
>
> *You are incapable of comprehending recursive simulation*
> THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION

Which is also why your H, if it actually meets your requirements, can't
either, so it isn't a decider.

Once H fails to be a correct decider, then D can halt, and the
non-correct simulating H needs to take that into account, but doesn't.

>
>> then the correct return value from the halting decider is 1.
>
>

On 1/17/24 02:31, olcott wrote:
> On 1/16/2024 6:42 PM, immibis wrote:
>> On 1/16/24 15:52, olcott wrote:
>>> On 1/16/2024 1:49 AM, immibis wrote:
>>>> On 1/16/24 00:55, olcott wrote:
>>>>> On 1/14/2024 10:55 PM, immibis wrote:
>>>>>> On 1/14/24 16:55, olcott wrote:
>>>>>>> On 1/14/2024 2:14 AM, immibis wrote:
>>>>>>>> On 1/13/24 17:15, olcott wrote:
>>>>>>>>> On 1/13/2024 6:07 AM, immibis wrote:
>>>>>>>>>> On 1/13/24 04:39, Richard Damon wrote:
>>>>>>>>>>> So, are you admitting that H doesn't care about getting the
>>>>>>>>>>> right answer to the Halting Problem? (Since it doesn't rely
>>>>>>>>>>> on the actual definiton of what it is to do)
>>>>>>>>>>
>>>>>>>>>> Olcott has acknowledged at least a few times that his H
>>>>>>>>>> doesn't solve the halting problem, but he thinks it does solve
>>>>>>>>>> a different problem, which I'll call the Olcott-halting
>>>>>>>>>> problem, which is the halting problem for
>>>>>>>>>> "non-self-contradictory" programs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is true that H either correctly solves the halting problem
>>>>>>>>> or the halting problem's pathological input must be rejected
>>>>>>>>> as semantically invalid.
>>>>>>>>>
>>>>>>>>>> He hasn't even solved that, and he can't even tell which
>>>>>>>>>> programs are self-contradictory,
>>>>>>>>>
>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>>>>>> At the bottom of the file:
>>>>>>>>>
>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112fd1
>>>>>>>>> Address_of_H:1542
>>>>>>>>> [00001c72][00112fbd][00112fc1] 55             push ebp
>>>>>>>>> [00001c73][00112fbd][00112fc1] 8bec           mov ebp,esp
>>>>>>>>> [00001c75][00112fb9][00102f8d] 51             push ecx
>>>>>>>>> [00001c76][00112fb9][00102f8d] 8b4508         mov eax,[ebp+08]
>>>>>>>>> [00001c79][00112fb5][00001c72] 50             push eax
>>>>>>>>> [00001c7a][00112fb5][00001c72] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>> [00001c7d][00112fb1][00001c72] 51             push ecx
>>>>>>>>> [00001c7e][00112fad][00001c83] e8bff8ffff     call 00001542
>>>>>>>>> H: *Infinitely Recursive Simulation Detected Simulation Stopped*
>>>>>>>>
>>>>>>>> The simulation is only infinitely recursive if the program it
>>>>>>>> simulates doesn't have an infinite recursion checker. If it has
>>>>>>>> an infinite recursion checker, the checker stops the recursion
>>>>>>>> and it isn't infinite.
>>>>>>>>
>>>>>>>
>>>>>>> void Infinite_Loop2()
>>>>>>> {
>>>>>>> L1: goto L3;
>>>>>>> L2: goto L1;
>>>>>>> L3: goto L2;
>>>>>>> }
>>>>>>>
>>>>>>> The above is not an actual infinite loop because
>>>>>>> its simulator aborts it simulation?
>>>>>>>
>>>>>> The above is not a simulator.
>>>>>
>>>>> Exactly what software engineering background do you have?
>>>>> I have been a professional C++ software engineer since 2000.
>>>>>
>>>> Enough to understand the difference between the inner simulator and
>>>> the outer simulator when you simulate a simulator.
>>>
>>> Apparently not quite.
>>> I repeat the question what computer language do you have
>>> ten full time years as a software engineer?
>>>
>>
>> Enough to understand that if the only reason a program doesn't reach
>> its final state is that it's aborted
>
> Yes that right there proves that you simply don't have
> sufficient technical understanding.
>
> *You are incapable of comprehending recursive simulation*
> THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION
>

Recursive simulation that can abort

>> then the correct return value from the halting decider is 1.
>
>

On 1/17/2024 5:25 AM, immibis wrote:
> On 1/17/24 02:31, olcott wrote:
>> On 1/16/2024 6:42 PM, immibis wrote:
>>> On 1/16/24 15:52, olcott wrote:
>>>> On 1/16/2024 1:49 AM, immibis wrote:
>>>>> On 1/16/24 00:55, olcott wrote:
>>>>>> On 1/14/2024 10:55 PM, immibis wrote:
>>>>>>> On 1/14/24 16:55, olcott wrote:
>>>>>>>> On 1/14/2024 2:14 AM, immibis wrote:
>>>>>>>>> On 1/13/24 17:15, olcott wrote:
>>>>>>>>>> On 1/13/2024 6:07 AM, immibis wrote:
>>>>>>>>>>> On 1/13/24 04:39, Richard Damon wrote:
>>>>>>>>>>>> So, are you admitting that H doesn't care about getting the
>>>>>>>>>>>> right answer to the Halting Problem? (Since it doesn't rely
>>>>>>>>>>>> on the actual definiton of what it is to do)
>>>>>>>>>>>
>>>>>>>>>>> Olcott has acknowledged at least a few times that his H
>>>>>>>>>>> doesn't solve the halting problem, but he thinks it does
>>>>>>>>>>> solve a different problem, which I'll call the Olcott-halting
>>>>>>>>>>> problem, which is the halting problem for
>>>>>>>>>>> "non-self-contradictory" programs.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is true that H either correctly solves the halting problem
>>>>>>>>>> or the halting problem's pathological input must be rejected
>>>>>>>>>> as semantically invalid.
>>>>>>>>>>
>>>>>>>>>>> He hasn't even solved that, and he can't even tell which
>>>>>>>>>>> programs are self-contradictory,
>>>>>>>>>>
>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>>>>>>> At the bottom of the file:
>>>>>>>>>>
>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112fd1
>>>>>>>>>> Address_of_H:1542
>>>>>>>>>> [00001c72][00112fbd][00112fc1] 55             push ebp
>>>>>>>>>> [00001c73][00112fbd][00112fc1] 8bec           mov ebp,esp
>>>>>>>>>> [00001c75][00112fb9][00102f8d] 51             push ecx
>>>>>>>>>> [00001c76][00112fb9][00102f8d] 8b4508         mov eax,[ebp+08]
>>>>>>>>>> [00001c79][00112fb5][00001c72] 50             push eax
>>>>>>>>>> [00001c7a][00112fb5][00001c72] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>> [00001c7d][00112fb1][00001c72] 51             push ecx
>>>>>>>>>> [00001c7e][00112fad][00001c83] e8bff8ffff     call 00001542
>>>>>>>>>> H: *Infinitely Recursive Simulation Detected Simulation Stopped*
>>>>>>>>>
>>>>>>>>> The simulation is only infinitely recursive if the program it
>>>>>>>>> simulates doesn't have an infinite recursion checker. If it has
>>>>>>>>> an infinite recursion checker, the checker stops the recursion
>>>>>>>>> and it isn't infinite.
>>>>>>>>>
>>>>>>>>
>>>>>>>> void Infinite_Loop2()
>>>>>>>> {
>>>>>>>> L1: goto L3;
>>>>>>>> L2: goto L1;
>>>>>>>> L3: goto L2;
>>>>>>>> }
>>>>>>>>
>>>>>>>> The above is not an actual infinite loop because
>>>>>>>> its simulator aborts it simulation?
>>>>>>>>
>>>>>>> The above is not a simulator.
>>>>>>
>>>>>> Exactly what software engineering background do you have?
>>>>>> I have been a professional C++ software engineer since 2000.
>>>>>>
>>>>> Enough to understand the difference between the inner simulator and
>>>>> the outer simulator when you simulate a simulator.
>>>>
>>>> Apparently not quite.
>>>> I repeat the question what computer language do you have
>>>> ten full time years as a software engineer?
>>>>
>>>
>>> Enough to understand that if the only reason a program doesn't reach
>>> its final state is that it's aborted
>>
>> Yes that right there proves that you simply don't have
>> sufficient technical understanding.
>>
>> *You are incapable of comprehending recursive simulation*
>> THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION
>>
>
> Recursive simulation that can abort

Recursive simulation <is> a non-halting behavior pattern.

>
>>> then the correct return value from the halting decider is 1.
>>
>>
>

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

On 1/17/24 15:44, olcott wrote:
> On 1/17/2024 5:25 AM, immibis wrote:
>> On 1/17/24 02:31, olcott wrote:
>>>
>>> *You are incapable of comprehending recursive simulation*
>>> THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION
>>>
>>
>> Recursive simulation that can abort
>
> Recursive simulation <is> a non-halting behavior pattern.

not if it can abort
>
>>
>>>> then the correct return value from the halting decider is 1.
>>>
>>>
>>
>

On 1/17/24 9:44 AM, olcott wrote:
> On 1/17/2024 5:25 AM, immibis wrote:
>> On 1/17/24 02:31, olcott wrote:
>>> On 1/16/2024 6:42 PM, immibis wrote:
>>>> On 1/16/24 15:52, olcott wrote:
>>>>> On 1/16/2024 1:49 AM, immibis wrote:
>>>>>> On 1/16/24 00:55, olcott wrote:
>>>>>>> On 1/14/2024 10:55 PM, immibis wrote:
>>>>>>>> On 1/14/24 16:55, olcott wrote:
>>>>>>>>> On 1/14/2024 2:14 AM, immibis wrote:
>>>>>>>>>> On 1/13/24 17:15, olcott wrote:
>>>>>>>>>>> On 1/13/2024 6:07 AM, immibis wrote:
>>>>>>>>>>>> On 1/13/24 04:39, Richard Damon wrote:
>>>>>>>>>>>>> So, are you admitting that H doesn't care about getting the
>>>>>>>>>>>>> right answer to the Halting Problem? (Since it doesn't rely
>>>>>>>>>>>>> on the actual definiton of what it is to do)
>>>>>>>>>>>>
>>>>>>>>>>>> Olcott has acknowledged at least a few times that his H
>>>>>>>>>>>> doesn't solve the halting problem, but he thinks it does
>>>>>>>>>>>> solve a different problem, which I'll call the
>>>>>>>>>>>> Olcott-halting problem, which is the halting problem for
>>>>>>>>>>>> "non-self-contradictory" programs.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is true that H either correctly solves the halting problem
>>>>>>>>>>> or the halting problem's pathological input must be rejected
>>>>>>>>>>> as semantically invalid.
>>>>>>>>>>>
>>>>>>>>>>>> He hasn't even solved that, and he can't even tell which
>>>>>>>>>>>> programs are self-contradictory,
>>>>>>>>>>>
>>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>>>>>>>> At the bottom of the file:
>>>>>>>>>>>
>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:112fd1
>>>>>>>>>>> Address_of_H:1542
>>>>>>>>>>> [00001c72][00112fbd][00112fc1] 55             push ebp
>>>>>>>>>>> [00001c73][00112fbd][00112fc1] 8bec           mov ebp,esp
>>>>>>>>>>> [00001c75][00112fb9][00102f8d] 51             push ecx
>>>>>>>>>>> [00001c76][00112fb9][00102f8d] 8b4508         mov eax,[ebp+08]
>>>>>>>>>>> [00001c79][00112fb5][00001c72] 50             push eax
>>>>>>>>>>> [00001c7a][00112fb5][00001c72] 8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>> [00001c7d][00112fb1][00001c72] 51             push ecx
>>>>>>>>>>> [00001c7e][00112fad][00001c83] e8bff8ffff     call 00001542
>>>>>>>>>>> H: *Infinitely Recursive Simulation Detected Simulation Stopped*
>>>>>>>>>>
>>>>>>>>>> The simulation is only infinitely recursive if the program it
>>>>>>>>>> simulates doesn't have an infinite recursion checker. If it
>>>>>>>>>> has an infinite recursion checker, the checker stops the
>>>>>>>>>> recursion and it isn't infinite.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void Infinite_Loop2()
>>>>>>>>> {
>>>>>>>>> L1: goto L3;
>>>>>>>>> L2: goto L1;
>>>>>>>>> L3: goto L2;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The above is not an actual infinite loop because
>>>>>>>>> its simulator aborts it simulation?
>>>>>>>>>
>>>>>>>> The above is not a simulator.
>>>>>>>
>>>>>>> Exactly what software engineering background do you have?
>>>>>>> I have been a professional C++ software engineer since 2000.
>>>>>>>
>>>>>> Enough to understand the difference between the inner simulator
>>>>>> and the outer simulator when you simulate a simulator.
>>>>>
>>>>> Apparently not quite.
>>>>> I repeat the question what computer language do you have
>>>>> ten full time years as a software engineer?
>>>>>
>>>>
>>>> Enough to understand that if the only reason a program doesn't reach
>>>> its final state is that it's aborted
>>>
>>> Yes that right there proves that you simply don't have
>>> sufficient technical understanding.
>>>
>>> *You are incapable of comprehending recursive simulation*
>>> THE REASON THAT D CANNOT POSSIBLY HALT IS RECURSIVE SIMULATION
>>>
>>
>> Recursive simulation that can abort
>
> Recursive simulation <is> a non-halting behavior pattern.

INFINITELY recursive simulation level is non-halting.

If the simulation being called for aborts and return then it is not
infinitely recursive.

3 is not infinity.

>
>>
>>>> then the correct return value from the halting decider is 1.
>>>
>>>
>>
>

On 2024-01-14 15:39:16 +0000, olcott said:

> On 1/14/2024 5:04 AM, Mikko wrote:
>> On 2024-01-13 19:17:08 +0000, olcott said:
>>
>>> On 1/13/2024 12:25 PM, Mike Terry wrote:
>>>> On 13/01/2024 08:36, Mikko wrote:
>>>>> On 2024-01-12 16:26:52 +0000, olcott said:
>>>>>
>>>>>> On 1/12/2024 2:22 AM, Mikko wrote:
>>>>>>> On 2024-01-11 14:22:34 +0000, olcott said about
>>>>>>> "Try and show how D correctly simulated by H reaches its own line 09":
>>>>>>>
>>>>>>>> 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   H(D,D);
>>>>>>>> 15 }
>>>>>>>>
>>>>>>>> *Execution Trace*
>>>>>>>> Line 14: main() invokes H(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 past its own line 06*
>>>>>>>
>>>>>>> What the correct simulation trace is, and in particular whether it
>>>>>>> reaches the line 09, depends on what H does.
>>>>>>>
>>>>>>
>>>>>> Mike Terry has confirmed that H does correctly simulate N steps of D.
>>>>>> There is no possible way that any correct simulation of D by any H
>>>>>> that can possibly exist ever reaches line 06 of D.
>>>>>>
>>>>>> *This can be confirmed by the source code of D posted above*
>>>>>
>>>>> Apparently Mike Terry had a different interpretation of "any H that
>>>>> can possibly exist". What I said is true about some H that is consitent
>>>>> with the question of OP.
>>>>
>>>> I don't recall ever commenting on the phrase "any H that can possibly
>>>> exist".  It's one of those "duffer" phrases that I wouldn't even bother
>>>> trying to pin down with PO.  Like his "What is the /correct simulation
>>>> trace/ of D(D) /by H/ ?"
>>>>
>>>> PO loves to grab little quotations from people, and then present them
>>>> without the surrounding context so that he can make out that people are
>>>> supporting his position when they are not.  It's one of his ways of
>>>> trying to swat away legitimate criticisms of his arguments without
>>>> addressing them.
>>>>
>>>> Anyway, FTR what I said was that AFAICT the x86utm simulation code does
>>>> indeed correctly simulate individual x86 instructions.  For example if
>>>> it simulates a "push eax" instruction, the current (virtual) eax
>>>> register gets stored in virtual memory at the correct location on the
>>>> stack, and (virtual) esp register is correctly decremented, and
>>>> (virtual) eip is correctly incremented etc. etc.. That functionality
>>>> was not written by PO, and while it is tedious it is not "difficult"
>>>> code, and is all within .  Also AFAICT PO's own x86utm "step
>>>> simulation" primitive appears to be correctly simulated and to nest
>>>> correctly.  So if H simulates (say) 427 steps of D(D), AFAICT those 427
>>>> steps are simulated correctly.
>>>>
>>>> I also made it clear that if after those 427 steps, H decides it's seen
>>>> enough, and stops simulating and returns "non-halting" then since D(D)
>>>> does in fact halt,
>>>
>>> 01 int D(ptr x)  // pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>>
>>> That means that you are using the strawman deception and changing the
>>> subject away from D correctly simulated by H that cannot possibly reach
>>> its own line 06 and terminate normally in 1 to infinity steps of correct
>>> simulation.
>>>
>>> Do you understand that int sum(int y, int x){return x + y;}
>>> cannot correctly return 7 for sum(3,2) ???
>>>
>>> A decider must report on its actual input and is not allowed
>>> to report on anything else. The directly executed
>>> *D(D) IS NOT A FREAKING INPUT TO H*
>>
>> Yes it is. A call H(T, I) tells H everything about T(I), so T(I) is
>> given in the input. If T == D and I == D then T(I) == D(D) and
>> is given in the input.
>>
>> Mikko
>>
>
> 01 int D(ptr x) // ptr is pointer to int function
> 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 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> 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.
>
> No one can possibly provide the exact sequence of the line numbers
> of D correctly simulated by H that differs from the above sequence.
> *This proves that D correctly simulated by H does not halt*

Nice to see you don't disagree.

Mikko