On 8/15/2023 6:07 AM, Mikko wrote:
> On 2023-08-14 14:01:14 +0000, olcott said:
>
>> My point is that the correct behavior to measure is the *input* D
>> correctly simulated by H. For this simulation to be correct it must
>> account for the pathological relationship between D and H.
>
> Looks like an unjusufied minorty opinion. The really correct thing
> to measure is what the problem statement requires to be measured.

// 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 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.

If we assume that I am incorrect and determine that D simulated by H
halts then H gets stuck in infinite recursion.

>
>> The makes the behavior of D correctly simulated by H different than
>> the behavior of of the *non input* D(D) directly executed in main().
>
> If the beharioour of the simulated D(D) is different from the behaviour
> of real D(D) then the it is not correctly simulated.
>
> Mikko
>

If we assume that I am incorrect and determine that D simulated by H
halts then H gets stuck in infinite recursion.

All of my reviewers make sure that they deny reality.
D simulated by H cannot possibly get past its own line
06 assuming otherwise is a break from reality.

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

On 8/15/23 11:17 AM, olcott wrote:
> On 8/15/2023 6:07 AM, Mikko wrote:
>> On 2023-08-14 14:01:14 +0000, olcott said:
>>
>>> My point is that the correct behavior to measure is the *input* D
>>> correctly simulated by H. For this simulation to be correct it must
>>> account for the pathological relationship between D and H.
>>
>> Looks like an unjusufied minorty opinion. The really correct thing
>> to measure is what the problem statement requires to be measured.
>
> // 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   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.
>
> If we assume that I am incorrect and determine that D simulated by H
> halts then H gets stuck in infinite recursion.
>
>>
>>> The makes the behavior of D correctly simulated by H different than
>>> the behavior of of the *non input* D(D) directly executed in main().
>>
>> If the beharioour of the simulated D(D) is different from the behaviour
>> of real D(D) then the it is not correctly simulated.
>>
>> Mikko
>>
>
> If we assume that I am incorrect and determine that D simulated by H
> halts then H gets stuck in infinite recursion.

So, you don't understand plain English.

How does the question: "Does the computation represented by the input
halt?" get changed to "Does the simulation the input by H halts?",
especially when you claim the simulation by H doesn't need to match the
actual behavior of the computation described by the input to be "correct"?

(and how is that "Correct"?)

>
> All of my reviewers make sure that they deny reality.
> D simulated by H cannot possibly get past its own line
> 06 assuming otherwise is a break from reality.
>

No, YOU deny reality, The words say what they say and mean what they
mean, and you don't get to change them, no matter how much you don't
understand them.

The question is "Does the computation (meaning machine + input)
described by the input to the the decider halt?" ask ANYTHING about the
simulation of the input by H, and how is a "Correct SImulation"
something that doesn't match the behavior of what is being simulated?

You LIE about what you are doing.

You CLAIM to be following the requirements in the proof, which say build
a machine (which you are calling subroutine D) that asks H what it will
do when given a representation of itself, and that is done in your D by
the call H(D,D), so for you first statement to be true, H(D,D) must be
asking about the behavior of the ACTUAL machine given a representation
of itself.

Then you turn around and say that H(D,D) CAN'T mean that, so you are
admitting that you are just a stupid liar that can't recognize that you
just contradicted yourself and inserted a contradiction into your logic
system.

No wonder you want to remove the principle of explosion from logic, your
whole basis of logic seems to be based on inserting false statements and
trusting that this doesn't actually break the logic system.

Your whole arguement is based on a contradiction. H(D,D) must be asking
about the behavior of the program D(D) to build D by the rules, but it
also must not be asking about that, or it is wrong.

The truth is, your whole argument is based on LIES and ignorance,
showing how little you understand about what you are talking about, and
your failure to even try to learn show how little you care about truth.

You have just FAILED at your goal.

On 8/15/2023 6:07 AM, Mikko wrote:
> On 2023-08-14 14:01:14 +0000, olcott said:
>
>> My point is that the correct behavior to measure is the *input* D
>> correctly simulated by H. For this simulation to be correct it must
>> account for the pathological relationship between D and H.
>
> Looks like an unjusufied minorty opinion. The really correct thing
> to measure is what the problem statement requires to be measured.

Prior to Pythagoras there was a universal consensus that the Earth
was flat.

"A decision problem is a yes-or-no question on an infinite set of
inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

199 of my 200 reviewers disagree with the above verified fact.
They believe that deciders must operate on non-inputs.

>
>> The makes the behavior of D correctly simulated by H different than
>> the behavior of of the *non input* D(D) directly executed in main().
>
> If the beharioour of the simulated D(D) is different from the behaviour
> of real D(D) then the it is not correctly simulated.

It is a verified fact that D is correctly simulated by H because
everyone sufficiently competent with C can directly see that the
simulation is correct as a verified fact.

// 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 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.

People that are only interested in rebuttal often directly contradict
the verified fact of the above *Simulation invariant*

>
> Mikko
>

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

On 8/16/23 11:21 AM, olcott wrote:
> On 8/15/2023 6:07 AM, Mikko wrote:
>> On 2023-08-14 14:01:14 +0000, olcott said:
>>
>>> My point is that the correct behavior to measure is the *input* D
>>> correctly simulated by H. For this simulation to be correct it must
>>> account for the pathological relationship between D and H.
>>
>> Looks like an unjusufied minorty opinion. The really correct thing
>> to measure is what the problem statement requires to be measured.
>
> Prior to Pythagoras there was a universal consensus that the Earth
> was flat.

So?

>
> "A decision problem is a yes-or-no question on an infinite set of
> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
>
> 199 of my 200 reviewers disagree with the above verified fact.
> They believe that deciders must operate on non-inputs.

No, NO ONE has said that a decision problem isn't a problem of mapping
an (infinite) set if inputs to a yes or no answer.

Can you provide ANY example of someone saying that?

The problem is the decider needs to answer the ACTUAL QUESTION given.

How is "Does the program described by the input halt?" change into "does
the simulation of the input by the decider complete with out it
aborting?", when you definition of a "correct simulation" doesn't need
to match to the behavior of tha actual machine.

That is like being asked what it 2 + 3? and you answer the correct
answer is 8, because 2 * 2 * 2 is 8.

>
>>
>>> The makes the behavior of D correctly simulated by H different than
>>> the behavior of of the *non input* D(D) directly executed in main().
>>
>> If the beharioour of the simulated D(D) is different from the behaviour
>> of real D(D) then the it is not correctly simulated.
>
> It is a verified fact that D is correctly simulated by H because
> everyone sufficiently competent with C can directly see that the
> simulation is correct as a verified fact.

No, we can see that H "simulates" a call to H(D,D) is non-halting when
we also see that H(D,D) returns 0.

Thus, the simulation is INCORRECT.

You clearly don't understand what "Correct" means.

>
> // 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   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.

So? Since this H DOESN'T correctluy simulate this input, the statement
is ill-formed.

An ACTUAL correct simulation of this input will reach line 9, and thus
show that D()D does halt, and that H is just incorrrect.

>
> People that are only interested in rebuttal often directly contradict
> the verified fact of the above *Simulation invariant*
>

No, you have the veracity of Trump, maybe even less, because it seems
like you actually believe your own lies.

The fact that even you have verified is that the CORRECT simulation of
this input halts. (Do I need to post that trace that YOU posted again?)

You are just proving that you are a pathological liar.

>>
>> Mikko
>>
>

On 8/15/2023 6:07 AM, Mikko wrote:
> On 2023-08-14 14:01:14 +0000, olcott said:
>
>> My point is that the correct behavior to measure is the *input* D
>> correctly simulated by H. For this simulation to be correct it must
>> account for the pathological relationship between D and H.
>
> Looks like an unjusufied minorty opinion. The really correct thing
> to measure is what the problem statement requires to be measured.
>
>> The makes the behavior of D correctly simulated by H different than
>> the behavior of of the *non input* D(D) directly executed in main().
>
> If the beharioour of the simulated D(D) is different from the behaviour
> of real D(D) then the it is not correctly simulated.
>
> Mikko
>

// 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 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.

When I prove that you are wrong you simply stop talking because you
never wanted 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 2023-08-17 14:59:45 +0000, olcott said:

> When I prove that you are wrong you simply stop talking because you
> never wanted any honest dialogue.

You can't know that until you prove me wrong.

Mikko

On 8/17/2023 10:04 AM, Mikko wrote:
> On 2023-08-17 14:59:45 +0000, olcott said:
>
>> When I prove that you are wrong you simply stop talking because you
>> never wanted any honest dialogue.
>
> You can't know that until you prove me wrong.
>
> Mikko
>

I just did prove you wrong by showing the actual execution trace
of D correctly simulated by H cannot possibly terminate normally.

That you believe there is some kind of magical power to overcome
this is ridiculous.

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

On 8/17/2023 10:04 AM, Mikko wrote:
> On 2023-08-17 14:59:45 +0000, olcott said:
>
>> When I prove that you are wrong you simply stop talking because you
>> never wanted any honest dialogue.
>
> You can't know that until you prove me wrong.
>
> Mikko
>

// 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 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.

The lack of a reply showing how D correctly simulated by H can
terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*

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

On 8/17/23 11:29 AM, olcott wrote:
> On 8/17/2023 10:04 AM, Mikko wrote:
>> On 2023-08-17 14:59:45 +0000, olcott said:
>>
>>> When I prove that you are wrong you simply stop talking because you
>>> never wanted any honest dialogue.
>>
>> You can't know that until you prove me wrong.
>>
>> Mikko
>>
>
> I just did prove you wrong by showing the actual execution trace
> of D correctly simulated by H cannot possibly terminate normally.
>
> That you believe there is some kind of magical power to overcome
> this is ridiculous.
>

No, the CORRECT simulation of D, as YOU have previously publish, which
shiws that a CORRECT simulation of D (which back the you called H_Hat)
will halt, is:

On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
> u32 Input_Halts = Halts(P, P);
> if (Input_Halts)
> HERE: goto HERE;
> }
>
>
> int main()
> {
> H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01) 55 push ebp
> [00000b99](02) 8bec mov ebp,esp
>
[00000b9b](01) 51 push ecx
> [00000b9c](03) 8b4508 mov eax,[ebp+08]
> [00000b9f](01) 50 push eax
> [00000ba0](03) 8b4d08 mov ecx,[ebp+08]
> [00000ba3](01) 51 push ecx
> [00000ba4](05) e88ffdffff call 00000938
> [00000ba9](03) 83c408 add esp,+08
> [00000bac](03) 8945fc mov [ebp-04],eax
> [00000baf](04) 837dfc00 cmp dword [ebp-04],+00
> [00000bb3](02) 7402 jz 00000bb7
> [00000bb5](02) ebfe jmp 00000bb5
> [00000bb7](02) 8be5 mov esp,ebp
> [00000bb9](01) 5d pop ebp
> [00000bba](01) c3 ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01) 55 push ebp
> [00000bc9](02) 8bec mov ebp,esp
> [00000bcb](05) 68980b0000 push 00000b98
> [00000bd0](05) e8c3ffffff call 00000b98
> [00000bd5](03) 83c404 add esp,+04
> [00000bd8](02) 33c0 xor eax,eax
> [00000bda](01) 5d pop ebp
> [00000bdb](01) c3 ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01) 55 push ebp
> ...[00000bc9][001015d4][00000000](02) 8bec mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05) 68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05) e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01) 55 push ebp
> ...[00000b99][001015c8][001015d4](02) 8bec mov ebp,esp
> ...[00000b9b][001015c4][00000000](01) 51 push ecx
> ...[00000b9c][001015c4][00000000](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01) 50 push eax
> ...[00000ba0][001015c0][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01) 51 push ecx
> ...[00000ba4][001015b8][00000ba9](05) e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01) 55 push ebp
> ...[00000b99][00211674][00211678](02) 8bec mov ebp,esp
> ...[00000b9b][00211670][00201644](01) 51 push ecx
> ...[00000b9c][00211670][00201644](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01) 50 push eax
> ...[00000ba0][0021166c][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01) 51 push ecx
> ...[00000ba4][00211664][00000ba9](05) e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01) 55 push ebp
> ...[00000b99][0025c09c][0025c0a0](02) 8bec mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01) 51 push ecx
> ...[00000b9c][0025c098][0024c06c](03) 8b4508 mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01) 50 push eax
> ...[00000ba0][0025c094][00000b98](03) 8b4d08 mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01) 51 push ecx
> ...[00000ba4][0025c08c][00000ba9](05) e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03) 83c408 add esp,+08
> ...[00000bac][001015c4][00000000](03) 8945fc mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)

On 8/17/23 12:18 PM, olcott wrote:
> On 8/17/2023 10:04 AM, Mikko wrote:
>> On 2023-08-17 14:59:45 +0000, olcott said:
>>
>>> When I prove that you are wrong you simply stop talking because you
>>> never wanted any honest dialogue.
>>
>> You can't know that until you prove me wrong.
>>
>> Mikko
>>
>
> // 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   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.
>
> The lack of a reply showing how D correctly simulated by H can
> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>

So, I guess the fact that you haven't answered MY corrections to you
proves that *I* am right and *YOU* are proven wrong.

THANKS for the admission that you have been a LIAR.

On 2023-08-17 15:29:46 +0000, olcott said:

> On 8/17/2023 10:04 AM, Mikko wrote:
>> On 2023-08-17 14:59:45 +0000, olcott said:
>>
>>> When I prove that you are wrong you simply stop talking because you
>>> never wanted any honest dialogue.
>>
>> You can't know that until you prove me wrong.
>>
>> Mikko
>>
>
> I just did prove you wrong by showing the actual execution trace
> of D correctly simulated by H cannot possibly terminate normally.

No, you did not. In particular, you did not prove that I had said
the opposite.

Mikko

On 2023-08-17 16:18:36 +0000, olcott said:

> On 8/17/2023 10:04 AM, Mikko wrote:
>> On 2023-08-17 14:59:45 +0000, olcott said:
>>
>>> When I prove that you are wrong you simply stop talking because you
>>> never wanted any honest dialogue.
>>
>> You can't know that until you prove me wrong.
>>
>> Mikko
>>
>
> // 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 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.
>
> The lack of a reply showing how D correctly simulated by H can
> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*

It is obvious that D cannot be correctly simuated ad infinitum or to
its termination.

Mikko

On 2023-08-18 07:10:39 +0000, Mikko said:

> On 2023-08-17 16:18:36 +0000, olcott said:
>
>> On 8/17/2023 10:04 AM, Mikko wrote:
>>> On 2023-08-17 14:59:45 +0000, olcott said:
>>>
>>>> When I prove that you are wrong you simply stop talking because you
>>>> never wanted any honest dialogue.
>>>
>>> You can't know that until you prove me wrong.
>>>
>>> Mikko
>>>
>>
>> // 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 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.
>>
>> The lack of a reply showing how D correctly simulated by H can
>> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>
> It is obvious that D cannot be correctly simuated ad infinitum or to
> its termination.

By H. By a better simulator it is possible, e.g., by UTM.

Mikko

On 8/18/2023 2:10 AM, Mikko wrote:
> On 2023-08-17 16:18:36 +0000, olcott said:
>
>> On 8/17/2023 10:04 AM, Mikko wrote:
>>> On 2023-08-17 14:59:45 +0000, olcott said:
>>>
>>>> When I prove that you are wrong you simply stop talking because you
>>>> never wanted any honest dialogue.
>>>
>>> You can't know that until you prove me wrong.
>>>
>>> Mikko
>>>
>>
>> // 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   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.
>>
>> The lack of a reply showing how D correctly simulated by H can
>> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>
> It is obvious that D cannot be correctly simuated ad infinitum or to
> its termination.
>
> Mikko
>

*Thus you agree with this*
D correctly simulated by H cannot possibly reach past its own line 06.

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

On 8/18/23 10:18 AM, olcott wrote:
> On 8/18/2023 2:10 AM, Mikko wrote:
>> On 2023-08-17 16:18:36 +0000, olcott said:
>>
>>> On 8/17/2023 10:04 AM, Mikko wrote:
>>>> On 2023-08-17 14:59:45 +0000, olcott said:
>>>>
>>>>> When I prove that you are wrong you simply stop talking because you
>>>>> never wanted any honest dialogue.
>>>>
>>>> You can't know that until you prove me wrong.
>>>>
>>>> Mikko
>>>>
>>>
>>> // 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   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.
>>>
>>> The lack of a reply showing how D correctly simulated by H can
>>> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>>
>> It is obvious that D cannot be correctly simuated ad infinitum or to
>> its termination.
>>
>> Mikko
>>
>
> *Thus you agree with this*
> D correctly simulated by H cannot possibly reach past its own line 06.
>
>

Only because there does not exist an H that gives a correct answer and
also correctly simulates the input.

Remember, the ACTUAL question, and not the strawman question you pose,
is about the actual behavior of the machine described by the input. Yes,
that behavior can be shown by an ACTUAL "Correct Simulation" (which
takes infinite time for a non-halting input).

Since every H that gives an answer for this input failed to correctly
simulate its input (since it stops before reaching a final state, and
thus is BY DEFINITION incorrect), and any H that does correctly simulate
this input (and never stops by your argument) fails to give an answer,
no H was able to answer based on ITS "correct simulation"

Since every H just talked about is different, every D that it was
deciding on was different, and thus none of the problems say anything
about any of the other problems you are looking out.

Not unless you are going to try to stipulate that two different things
are actually the same thing, which makes your logic inconsistent (and
exploded).

You are just asserting that you can correctly answer a question about
cats by answering about dogs.

YOU FAIL

On 8/18/2023 2:14 AM, Mikko wrote:
> On 2023-08-18 07:10:39 +0000, Mikko said:
>
>> On 2023-08-17 16:18:36 +0000, olcott said:
>>
>>> On 8/17/2023 10:04 AM, Mikko wrote:
>>>> On 2023-08-17 14:59:45 +0000, olcott said:
>>>>
>>>>> When I prove that you are wrong you simply stop talking because you
>>>>> never wanted any honest dialogue.
>>>>
>>>> You can't know that until you prove me wrong.
>>>>
>>>> Mikko
>>>>
>>>
>>> // 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   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.
>>>
>>> The lack of a reply showing how D correctly simulated by H can
>>> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>>
>> It is obvious that D cannot be correctly simuated ad infinitum or to
>> its termination.
>
> By H. By a better simulator it is possible, e.g., by UTM.
>
> Mikko
>

The behavior of D correctly simulated by H must include thus
cannot ignore the pathological relationship between D and H.

The behavior of D correctly simulated by H does provide the
behavior of the actual input to H(D,D).

The behavior of D(D) directly executed in main() does *NOT*
provide the behavior of the actual input to H(D,D).

"A decision problem is a yes-or-no question on an infinite
set of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Requires that H report on the actual behavior of its input
and is forbidden from reporting on any behavior that differs
from this.

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

On 8/18/23 11:48 AM, olcott wrote:
> On 8/18/2023 2:14 AM, Mikko wrote:
>> On 2023-08-18 07:10:39 +0000, Mikko said:
>>
>>> On 2023-08-17 16:18:36 +0000, olcott said:
>>>
>>>> On 8/17/2023 10:04 AM, Mikko wrote:
>>>>> On 2023-08-17 14:59:45 +0000, olcott said:
>>>>>
>>>>>> When I prove that you are wrong you simply stop talking because
>>>>>> you never wanted any honest dialogue.
>>>>>
>>>>> You can't know that until you prove me wrong.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> // 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   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.
>>>>
>>>> The lack of a reply showing how D correctly simulated by H can
>>>> terminate normally *WILL BE CONSTRUED AS ADMISSION THAT YOU ARE WRONG*
>>>
>>> It is obvious that D cannot be correctly simuated ad infinitum or to
>>> its termination.
>>
>> By H. By a better simulator it is possible, e.g., by UTM.
>>
>> Mikko
>>
>
> The behavior of D correctly simulated by H must include thus
> cannot ignore the pathological relationship between D and H.

The behavior of D correctly simulated --PERIOD-- must include that
relationship. which means must include what ever behavior the actual H
actually does.

The "Pathology" of that

>
> The behavior of D correctly simulated by H does provide the
> behavior of the actual input to H(D,D).

Only if H actually DOES "Correctly Simulate" the input, which means it
sees the behavior of the actual machine.

You are just so stupid, you don't seem to understand that H doesn't
actally o

>
> The behavior of D(D) directly executed in main() does *NOT*
> provide the behavior of the actual input to H(D,D).

Why? Isn't that what that call means?

Or, are you just admitting that your whole proof is based on a lie that
you are actually working on the real halting problem and the actual
proof you claim to be refuting.

If the behavior of D(D) is NOT the behavior that H(D,D) is specified to
look at, your D is just NOT the "pathological" program of the proof,
since BY DEFINITION, it needs to call the decider to ask it about the
behavior of itself applied to its input, which in this case happens to
be a descriptipn of itself.

Thus, you statement is just an ADMISSION that you have been a LIAR for
all these years,

Either your "D" isn't the pathological program, or more likely, H isn't
even meeting the definition of a Halt Decider.

All you are doing is PROVING your stupidity and that you are a LIAR

>
> "A decision problem is a yes-or-no question on an infinite
> set of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition

Right, and a "X" decider needs to decide about the "X" mapping. So a
Halt Decider needs to decide on the Halt Mapping.

>
> Requires that H report on the actual behavior of its input
> and is forbidden from reporting on any behavior that differs
> from this.
>

And if that "actual behavior" of its input isn't the behavior obtained
by simulating the input with a UTM, or running the machine described by
the input, H just simply isn't a "Halt Decider".

So, you are just admitting that your H isn't actually a Halt Decider,
just a POOP decider, and all your claims are lies.

On 2023-08-18 14:18:55 +0000, olcott said:

> *Thus you agree with this*
> D correctly simulated by H cannot possibly reach past its own line 06.

I'm mot sure it is correct English to use "D" as a subject to an active
verb "reach" as D is not present and therefore cannot actively do anything.
Anyway, one can say that H cannot correctly simulate D(D) past line 6,
which apparently is what you try to express with that sentence.

Mikko

On 2023-08-18 15:48:09 +0000, olcott said:

> The behavior of D(D) directly executed in main() does *NOT*
> provide the behavior of the actual input to H(D,D).

Of course not. The actual input to H(D,D) is just a text string
that has no behaviour. It can be interpreted to specify a behaviour
but it iself does not behave.

The actual behaviour of D(D) is merely a reference for determination
of the orrectness of the answer given by H(D,D).

Mikko

On 8/18/2023 11:54 AM, Mikko wrote:
> On 2023-08-18 14:18:55 +0000, olcott said:
>
>> *Thus you agree with this*
>> D correctly simulated by H cannot possibly reach past its own line 06.
>
> I'm mot sure it is correct English to use "D" as a subject to an active
> verb "reach" as D is not present and therefore cannot actively do anything.
> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
> which apparently is what you try to express with that sentence.
>
> Mikko
>

It is not an error of H that prevents the correct simulation of G past
line 06, it is the pathological relationship that D defines with H that
makes this impossible.

D correctly simulated by H cannot possibly terminate normally thus from
the frame-of-reference of H the simulation of this input must be aborted
proving that this input is non-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 8/18/2023 12:03 PM, Mikko wrote:
> On 2023-08-18 15:48:09 +0000, olcott said:
>
>> The behavior of D(D) directly executed in main() does *NOT*
>> provide the behavior of the actual input to H(D,D).
>
> Of course not. The actual input to H(D,D) is just a text string
> that has no behaviour. It can be interpreted to specify a behaviour
> but it iself does not behave.
>
> The actual behaviour of D(D) is merely a reference for determination
> of the orrectness of the answer given by H(D,D).
>
> Mikko
>

The notion of a UTM proves that D correctly simulated by H does provide
the behavior that H must report on.

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

On 8/18/23 1:08 PM, olcott wrote:
> On 8/18/2023 12:03 PM, Mikko wrote:
>> On 2023-08-18 15:48:09 +0000, olcott said:
>>
>>> The behavior of D(D) directly executed in main() does *NOT*
>>> provide the behavior of the actual input to H(D,D).
>>
>> Of course not. The actual input to H(D,D) is just a text string
>> that has no behaviour. It can be interpreted to specify a behaviour
>> but it iself does not behave.
>>
>> The actual behaviour of D(D) is merely a reference for determination
>> of the orrectness of the answer given by H(D,D).
>>
>> Mikko
>>
>
> The notion of a UTM proves that D correctly simulated by H does provide
> the behavior that H must report on.
>

The notion of a UTM says that the "Correct Simulation" of an input
exactly matches the behavior of the machine the input describes.

Thus, your H does NOT do a "Correct Simulation", since you claim that
H's simulation doesn't (or doesn't need to) match the behavior of the
actual machine described by the input.

Since you claim:

>>> The behavior of D(D) directly executed in main() does *NOT*
>>> provide the behavior of the actual input to H(D,D).

Then H is NOT actually a Halt Decider, as a Halt Decider DOES look at
the bevhaior of the machine described by its input, an not some other
processing that it does on it.

On 8/18/23 1:07 PM, olcott wrote:
> On 8/18/2023 11:54 AM, Mikko wrote:
>> On 2023-08-18 14:18:55 +0000, olcott said:
>>
>>> *Thus you agree with this*
>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>
>> I'm mot sure it is correct English to use "D" as a subject to an active
>> verb "reach" as D is not present and therefore cannot actively do
>> anything.
>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>> which apparently is what you try to express with that sentence.
>>
>> Mikko
>>
>
> It is not an error of H that prevents the correct simulation of G past
> line 06, it is the pathological relationship that D defines with H that
> makes this impossible.

But if H claims to do a "correct simulation" then it IS its
responcibility to do so.

H (or actually its designer) has made the error of commiting to do
something they could not do.

>
> D correctly simulated by H cannot possibly terminate normally thus from
> the frame-of-reference of H the simulation of this input must be aborted
> proving that this input is non-halting.
>

D is NOT correctly simulated by H, so you are just using FALSE
statements to make your arguement.

H is DEFINED, and that H doesn't do a correct simulation.

You talk about another hypothetical machine by the same name (which is a
logic error to do) and looking at the results of that hypotectical H
looking at a DIFFERENT hypotectical D, is illrelevent to thing problem.

In fact, if give this hypothetical variation of H, the actual input D
here (which calls the ACTUAL H, not the Hypothetical H) then this
hypothetical H will show that the real H is just wrong, as it can
simulate the input all the way to the final state, as it simulated the
behavior of the real H, and see it abort its simulation and return.

The "pathological" relationship doesn't give licenese to false logic, or
change the correct answer, it just make it so that it is impossible to
design an H that actually gives the right answer for the D built on it.

On 2023-08-18 17:07:09 +0000, olcott said:

> On 8/18/2023 11:54 AM, Mikko wrote:
>> On 2023-08-18 14:18:55 +0000, olcott said:
>>
>>> *Thus you agree with this*
>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>
>> I'm mot sure it is correct English to use "D" as a subject to an active
>> verb "reach" as D is not present and therefore cannot actively do anything.
>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>> which apparently is what you try to express with that sentence.
>>
>> Mikko
>>
>
> It is not an error of H that prevents the correct simulation of G past
> line 06, it is the pathological relationship that D defines with H that
> makes this impossible.

If H(D,D) says "does not halt" but D(D) halts then H is not a halt decider
because it does not satisfy the definition of "halt decider".
Whether that is an error depends on whether H is claimed or required to be
a halt decider.

Mikko

On 8/19/2023 3:38 AM, Mikko wrote:
> On 2023-08-18 17:07:09 +0000, olcott said:
>
>> On 8/18/2023 11:54 AM, Mikko wrote:
>>> On 2023-08-18 14:18:55 +0000, olcott said:
>>>
>>>> *Thus you agree with this*
>>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>>
>>> I'm mot sure it is correct English to use "D" as a subject to an active
>>> verb "reach" as D is not present and therefore cannot actively do
>>> anything.
>>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>>> which apparently is what you try to express with that sentence.
>>>
>>> Mikko
>>>
>>
>> It is not an error of H that prevents the correct simulation of G past
>> line 06, it is the pathological relationship that D defines with H that
>> makes this impossible.
>
> If H(D,D) says "does not halt" but D(D) halts then H is not a halt decider

If Bill's identical twin brother robs a liquor store and Mary said that
Bill did it Mary is wrong. The instance of D that H determines does not
halt is a different instance than the one that halts.

The one that halts only halts because the other different one has been
aborted.

> because it does not satisfy the definition of "halt decider".

Every halt decider must map its actual input to its own accept or reject
state on the basis of the actual behavior of this actual input and is
not allowed to report on the differing behavior of any non-input such as
D(D) directly executed in main().

You admitted that the input to H(D,D) cannot possibly terminate
normally. This proves that it is correctly determined to be non-halting.

> Whether that is an error depends on whether H is claimed or required to be
> a halt decider.
>
> Mikko
>

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