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 }

What is step by step line-by-line correct sequence of steps
when the simulation of D by H reaches line 06?

Everyone says that the simulation of D by H is incorrect yet
no one can provide a correct sequence of steps that differs
from the one that H performs.

*A correct simulation of D by H cannot possibly terminate normally*
is proven beyond all possible doubt yet people disagree anyway.

--
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/9/24 04:16, olcott wrote:
> 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 }
>
> What is step by step line-by-line correct sequence of steps
> when the simulation of D by H reaches line 06?
>
> Everyone says that the simulation of D by H is incorrect yet
> no one can provide a correct sequence of steps that differs
> from the one that H performs.
>
> *A correct simulation of D by H cannot possibly terminate normally*
> is proven beyond all possible doubt yet people disagree anyway.
>

So if it terminates, it's incorrect.

On 1/8/2024 9:19 PM, immibis wrote:
> On 1/9/24 04:16, olcott wrote:
>> 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 }
>>
>> What is step by step line-by-line correct sequence of steps
>> when the simulation of D by H reaches line 06?
>>
>> Everyone says that the simulation of D by H is incorrect yet
>> no one can provide a correct sequence of steps that differs
>> from the one that H performs.
>>
>> *A correct simulation of D by H cannot possibly terminate normally*
>> is proven beyond all possible doubt yet people disagree anyway.
>>
>
> So if it terminates, it's incorrect.

A program/C function only halts if it terminates normally
by reaching its last instruction. Termination for any other
reason does not count as halting.

--
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/9/24 04:22, olcott wrote:
> On 1/8/2024 9:19 PM, immibis wrote:
>> On 1/9/24 04:16, olcott wrote:
>>> 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 }
>>>
>>> What is step by step line-by-line correct sequence of steps
>>> when the simulation of D by H reaches line 06?
>>>
>>> Everyone says that the simulation of D by H is incorrect yet
>>> no one can provide a correct sequence of steps that differs
>>> from the one that H performs.
>>>
>>> *A correct simulation of D by H cannot possibly terminate normally*
>>> is proven beyond all possible doubt yet people disagree anyway.
>>>
>>
>> So if it terminates, it's incorrect.
>
> A program/C function only halts if it terminates normally
> by reaching its last instruction. Termination for any other
> reason does not count as halting.
>

int H(ptr x, ptr y) {
begin_simulation(x, y);
abort_simulation();
return 0; // simulation cannot terminate normally
}

On 1/8/2024 9:32 PM, immibis wrote:
> On 1/9/24 04:22, olcott wrote:
>> On 1/8/2024 9:19 PM, immibis wrote:
>>> On 1/9/24 04:16, olcott wrote:
>>>> 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 }
>>>>
>>>> What is step by step line-by-line correct sequence of steps
>>>> when the simulation of D by H reaches line 06?
>>>>
>>>> Everyone says that the simulation of D by H is incorrect yet
>>>> no one can provide a correct sequence of steps that differs
>>>> from the one that H performs.
>>>>
>>>> *A correct simulation of D by H cannot possibly terminate normally*
>>>> is proven beyond all possible doubt yet people disagree anyway.
>>>>
>>>
>>> So if it terminates, it's incorrect.
>>
>> A program/C function only halts if it terminates normally
>> by reaching its last instruction. Termination for any other
>> reason does not count as halting.
>>
>
> int H(ptr x, ptr y) {
>     begin_simulation(x, y);
>     abort_simulation();
>     return 0; // simulation cannot terminate normally
> }

This H on input D cannot possibly reach past its own first line.

My H is based on a superb x86 emulator that allows any C function
to execute another C function in debug-step mode, while comparing
the prior sequence of steps to known non-halting behavior patterns.

--
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/8/24 10:22 PM, olcott wrote:
> On 1/8/2024 9:19 PM, immibis wrote:
>> On 1/9/24 04:16, olcott wrote:
>>> 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 }
>>>
>>> What is step by step line-by-line correct sequence of steps
>>> when the simulation of D by H reaches line 06?
>>>
>>> Everyone says that the simulation of D by H is incorrect yet
>>> no one can provide a correct sequence of steps that differs
>>> from the one that H performs.
>>>
>>> *A correct simulation of D by H cannot possibly terminate normally*
>>> is proven beyond all possible doubt yet people disagree anyway.
>>>
>>
>> So if it terminates, it's incorrect.
>
> A program/C function only halts if it terminates normally
> by reaching its last instruction. Termination for any other
> reason does not count as halting.
>

Right, and the PROGRAM (not the simulation) does that.

An aborted simulation does not prove non-halting.

On 1/8/24 10:37 PM, olcott wrote:
> On 1/8/2024 9:32 PM, immibis wrote:
>> On 1/9/24 04:22, olcott wrote:
>>> On 1/8/2024 9:19 PM, immibis wrote:
>>>> On 1/9/24 04:16, olcott wrote:
>>>>> 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 }
>>>>>
>>>>> What is step by step line-by-line correct sequence of steps
>>>>> when the simulation of D by H reaches line 06?
>>>>>
>>>>> Everyone says that the simulation of D by H is incorrect yet
>>>>> no one can provide a correct sequence of steps that differs
>>>>> from the one that H performs.
>>>>>
>>>>> *A correct simulation of D by H cannot possibly terminate normally*
>>>>> is proven beyond all possible doubt yet people disagree anyway.
>>>>>
>>>>
>>>> So if it terminates, it's incorrect.
>>>
>>> A program/C function only halts if it terminates normally
>>> by reaching its last instruction. Termination for any other
>>> reason does not count as halting.
>>>
>>
>> int H(ptr x, ptr y) {
>>      begin_simulation(x, y);
>>      abort_simulation();
>>      return 0; // simulation cannot terminate normally
>> }
>
> This H on input D cannot possibly reach past its own first line.
>
> My H is based on a superb x86 emulator that allows any C function
> to execute another C function in debug-step mode, while comparing
> the prior sequence of steps to known non-halting behavior patterns.
>

ANd that list includes false positives, so is just wrong.

On 1/8/24 10:16 PM, olcott wrote:
> 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 }
>
> What is step by step line-by-line correct sequence of steps
> when the simulation of D by H reaches line 06?
>
> Everyone says that the simulation of D by H is incorrect yet
> no one can provide a correct sequence of steps that differs
> from the one that H performs.
>
> *A correct simulation of D by H cannot possibly terminate normally*
> is proven beyond all possible doubt yet people disagree anyway.
>

There is no H that does it.

It is the Barber that shaves only those who do not shave themselves, and
thus is, in your own words, an invalid question, show that you are just
too stupid.

On 1/9/24 04:37, olcott wrote:
> On 1/8/2024 9:32 PM, immibis wrote:
>> On 1/9/24 04:22, olcott wrote:
>>> On 1/8/2024 9:19 PM, immibis wrote:
>>>> On 1/9/24 04:16, olcott wrote:
>>>>> 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 }
>>>>>
>>>>> What is step by step line-by-line correct sequence of steps
>>>>> when the simulation of D by H reaches line 06?
>>>>>
>>>>> Everyone says that the simulation of D by H is incorrect yet
>>>>> no one can provide a correct sequence of steps that differs
>>>>> from the one that H performs.
>>>>>
>>>>> *A correct simulation of D by H cannot possibly terminate normally*
>>>>> is proven beyond all possible doubt yet people disagree anyway.
>>>>>
>>>>
>>>> So if it terminates, it's incorrect.
>>>
>>> A program/C function only halts if it terminates normally
>>> by reaching its last instruction. Termination for any other
>>> reason does not count as halting.
>>>
>>
>> int H(ptr x, ptr y) {
>>      begin_simulation(x, y);
>>      abort_simulation();
>>      return 0; // simulation cannot terminate normally
>> }
>
> This H on input D cannot possibly reach past its own first line.
>
> My H is based on a superb x86 emulator that allows any C function
> to execute another C function in debug-step mode, while comparing
> the prior sequence of steps to known non-halting behavior patterns.
>
The prior sequence of steps is an undeclared input to the
double-simulated program which makes its behaviour diverge from the
actual double execution of the program.

On 1/8/2024 9:49 PM, immibis wrote:
> On 1/9/24 04:37, olcott wrote:
>> On 1/8/2024 9:32 PM, immibis wrote:
>>> On 1/9/24 04:22, olcott wrote:
>>>> On 1/8/2024 9:19 PM, immibis wrote:
>>>>> On 1/9/24 04:16, olcott wrote:
>>>>>> 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 }
>>>>>>
>>>>>> What is step by step line-by-line correct sequence of steps
>>>>>> when the simulation of D by H reaches line 06?
>>>>>>
>>>>>> Everyone says that the simulation of D by H is incorrect yet
>>>>>> no one can provide a correct sequence of steps that differs
>>>>>> from the one that H performs.
>>>>>>
>>>>>> *A correct simulation of D by H cannot possibly terminate normally*
>>>>>> is proven beyond all possible doubt yet people disagree anyway.
>>>>>>
>>>>>
>>>>> So if it terminates, it's incorrect.
>>>>
>>>> A program/C function only halts if it terminates normally
>>>> by reaching its last instruction. Termination for any other
>>>> reason does not count as halting.
>>>>
>>>
>>> int H(ptr x, ptr y) {
>>>      begin_simulation(x, y);
>>>      abort_simulation();
>>>      return 0; // simulation cannot terminate normally
>>> }
>>
>> This H on input D cannot possibly reach past its own first line.
>>
>> My H is based on a superb x86 emulator that allows any C function
>> to execute another C function in debug-step mode, while comparing
>> the prior sequence of steps to known non-halting behavior patterns.
>>
> The prior sequence of steps is an undeclared input to the
> double-simulated program which makes its behaviour diverge from the
> actual double execution of the program.

On 1/8/2024 9:20 PM, immibis wrote:
> On 1/9/24 04:20, olcott wrote:
>> It is stipulated that H simulates D you ignored this
>> aspect of the problem definition.
>>
>
> Then a correct simulation can't possibly terminate.

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 }

*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 1/8/24 10:56 PM, olcott wrote:
> On 1/8/2024 9:49 PM, immibis wrote:
>> On 1/9/24 04:37, olcott wrote:
>>> On 1/8/2024 9:32 PM, immibis wrote:
>>>> On 1/9/24 04:22, olcott wrote:
>>>>> On 1/8/2024 9:19 PM, immibis wrote:
>>>>>> On 1/9/24 04:16, olcott wrote:
>>>>>>> 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 }
>>>>>>>
>>>>>>> What is step by step line-by-line correct sequence of steps
>>>>>>> when the simulation of D by H reaches line 06?
>>>>>>>
>>>>>>> Everyone says that the simulation of D by H is incorrect yet
>>>>>>> no one can provide a correct sequence of steps that differs
>>>>>>> from the one that H performs.
>>>>>>>
>>>>>>> *A correct simulation of D by H cannot possibly terminate normally*
>>>>>>> is proven beyond all possible doubt yet people disagree anyway.
>>>>>>>
>>>>>>
>>>>>> So if it terminates, it's incorrect.
>>>>>
>>>>> A program/C function only halts if it terminates normally
>>>>> by reaching its last instruction. Termination for any other
>>>>> reason does not count as halting.
>>>>>
>>>>
>>>> int H(ptr x, ptr y) {
>>>>      begin_simulation(x, y);
>>>>      abort_simulation();
>>>>      return 0; // simulation cannot terminate normally
>>>> }
>>>
>>> This H on input D cannot possibly reach past its own first line.
>>>
>>> My H is based on a superb x86 emulator that allows any C function
>>> to execute another C function in debug-step mode, while comparing
>>> the prior sequence of steps to known non-halting behavior patterns.
>>>
>> The prior sequence of steps is an undeclared input to the
>> double-simulated program which makes its behaviour diverge from the
>> actual double execution of the program.
>
> On 1/8/2024 9:20 PM, immibis wrote:
> > On 1/9/24 04:20, olcott wrote:
> >> It is stipulated that H simulates D you ignored this
> >> aspect of the problem definition.
> >>
> >
> > Then a correct simulation can't possibly terminate.
>
> 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 }
>
> *D correctly simulated by H cannot possibly terminate normally*
>

And an H that correctly simulates D can not return an answer.

On 2024-01-09 03:16:49 +0000, olcott said:

> 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 }
>
> What is step by step line-by-line correct sequence of steps
> when the simulation of D by H reaches line 06?

There are two possibilities.

For a superficial simulation it is sufficient to
determine what H(x, x) returns and assign that
to Halt_Status and then simulate forward.

For detailed simulation the calling sequence to H must be
simulated and then one by whatever instructions there are
in H.

Mikko

On 1/9/2024 8:42 AM, Mikko wrote:
> On 2024-01-09 03:16:49 +0000, olcott said:
>
>> 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 }
>>
>> What is step by step line-by-line correct sequence of steps
>> when the simulation of D by H reaches line 06?
>
> There are two possibilities.
>
> For a superficial simulation it is sufficient to
> determine what H(x, x) returns and assign that
> to Halt_Status and then simulate forward.
>
> For detailed simulation the calling sequence to H must be
> simulated and then one by whatever instructions there are
> in H.
>
> Mikko
>

OK great so you are saying that when D correctly simulated by H
reaches line 06 that H must simulate the invocation of H(D,D).

That <is> correct. It also means that D correctly simulated
by any H that can possibly exist cannot possibly reaches its
own line 09, thus cannot possibly reach its own final instruction
and terminate normally, thus never halts.

--
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/9/24 12:33 PM, olcott wrote:
> On 1/9/2024 8:42 AM, Mikko wrote:
>> On 2024-01-09 03:16:49 +0000, olcott said:
>>
>>> 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 }
>>>
>>> What is step by step line-by-line correct sequence of steps
>>> when the simulation of D by H reaches line 06?
>>
>> There are two possibilities.
>>
>> For a superficial simulation it is sufficient to
>> determine what H(x, x) returns and assign that
>> to Halt_Status and then simulate forward.
>>
>> For detailed simulation the calling sequence to H must be
>> simulated and then one by whatever instructions there are
>> in H.
>>
>> Mikko
>>
>
> OK great so you are saying that when D correctly simulated by H
> reaches line 06 that H must simulate the invocation of H(D,D).
>
> That <is> correct. It also means that D correctly simulated
> by any H that can possibly exist cannot possibly reaches its
> own line 09, thus cannot possibly reach its own final instruction
> and terminate normally, thus never halts.
>

You are making the unwarrented assumption that an H CAN simulate the
input correctly and also be a decider.

Any H that simulates the input (based on itself) doesn't answer, and any
H that answers, didn't simulate its input corrctly, as shown by
continuing this exact simulation with another pure simulator.

Note, the definition of D is that it is based on a particular H, not
whatever simulator is looking at it. THAT definition is actually
impossible to build as an independent machine.

Your changing D to match the H is what creates the "self-reference" that
makes the question not have an answer and thus incorrect to ask. This
shows that an H meeting your requirement just doesn't exist, like the
Barber that shaves everone who doesn't have themselves.

It isn't the question of who a barber shaves that is invalid, it is
trying to choose THAT Barber, who just can't exist.

THe Halting Question is perfectly valid for any input that actually
exists, we just can't make a D from an H that doesn't exist.