On 1/2/24 19:22, olcott wrote:
> On 1/2/2024 9:37 AM, immibis wrote:
>> On 1/2/24 05:10, olcott wrote:
>>> Everyone here (out of their ignorance) makes sure to
>>> ignore the fact that both Boolean return values from H(D,D)
>>> are incorrect and the return value of 1 from H1(D,D > correct
>>
>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>
>
> You know that this would cause D to go into an infinite loop
> so why lie?
>

No it wouldn't. D has no reference to H. If you change H so that it
returns the correct answer of 1, then it would return the correct value.
However, I could write a new program it would get wrong.

On 1/2/2024 2:29 PM, immibis wrote:
> On 1/2/24 19:22, olcott wrote:
>> On 1/2/2024 9:37 AM, immibis wrote:
>>> On 1/2/24 05:10, olcott wrote:
>>>> Everyone here (out of their ignorance) makes sure to
>>>> ignore the fact that both Boolean return values from H(D,D)
>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>
>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>
>>
>> You know that this would cause D to go into an infinite loop
>> so why lie?
>>
>
> No it wouldn't. D has no reference to H.
int D(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

Troll !!!

--
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/2/24 21:59, olcott wrote:
> On 1/2/2024 2:29 PM, immibis wrote:
>> On 1/2/24 19:22, olcott wrote:
>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>> On 1/2/24 05:10, olcott wrote:
>>>>> Everyone here (out of their ignorance) makes sure to
>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>
>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>
>>>
>>> You know that this would cause D to go into an infinite loop
>>> so why lie?
>>>
>>
>> No it wouldn't. D has no reference to H.
> int D(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> Troll !!!
>
Then D is not a program so the halting problem doesn't apply.

On 1/2/2024 3:23 PM, immibis wrote:
> On 1/2/24 21:59, olcott wrote:
>> On 1/2/2024 2:29 PM, immibis wrote:
>>> On 1/2/24 19:22, olcott wrote:
>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>
>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>
>>>>
>>>> You know that this would cause D to go into an infinite loop
>>>> so why lie?
>>>>
>>>
>>> No it wouldn't. D has no reference to H.
>> int D(ptr x)
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> Troll !!!
>>
> Then D is not a program so the halting problem doesn't apply.

When one believes that isomorphisms are fairy tales this
might seem to be true. Anyone that knows the meaning of
the term {isomorphism} knows that they are not fairy tales.

--
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/2/24 22:40, olcott wrote:
> On 1/2/2024 3:23 PM, immibis wrote:
>> On 1/2/24 21:59, olcott wrote:
>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>> On 1/2/24 19:22, olcott wrote:
>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>
>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>
>>>>>
>>>>> You know that this would cause D to go into an infinite loop
>>>>> so why lie?
>>>>>
>>>>
>>>> No it wouldn't. D has no reference to H.
>>> int D(ptr x)
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> Troll !!!
>>>
>> Then D is not a program so the halting problem doesn't apply.
>
> When one believes that isomorphisms are fairy tales this
> might seem to be true. Anyone that knows the meaning of
> the term {isomorphism} knows that they are not fairy tales.
>

Specify the isomorphism between programs and whatever D is.

On 1/2/2024 3:46 PM, immibis wrote:
> On 1/2/24 22:40, olcott wrote:
>> On 1/2/2024 3:23 PM, immibis wrote:
>>> On 1/2/24 21:59, olcott wrote:
>>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>>> On 1/2/24 19:22, olcott wrote:
>>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>>
>>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>>
>>>>>>
>>>>>> You know that this would cause D to go into an infinite loop
>>>>>> so why lie?
>>>>>>
>>>>>
>>>>> No it wouldn't. D has no reference to H.
>>>> int D(ptr x)
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> Troll !!!
>>>>
>>> Then D is not a program so the halting problem doesn't apply.
>>
>> When one believes that isomorphisms are fairy tales this
>> might seem to be true. Anyone that knows the meaning of
>> the term {isomorphism} knows that they are not fairy tales.
>>
>
> Specify the isomorphism between programs and whatever D is.

If you don't already know then you don't know enough
to have it explained to you.

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

On 1/2/24 23:16, olcott wrote:
> On 1/2/2024 3:46 PM, immibis wrote:
>> On 1/2/24 22:40, olcott wrote:
>>> On 1/2/2024 3:23 PM, immibis wrote:
>>>> On 1/2/24 21:59, olcott wrote:
>>>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>>>> On 1/2/24 19:22, olcott wrote:
>>>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>>>
>>>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>>>
>>>>>>>
>>>>>>> You know that this would cause D to go into an infinite loop
>>>>>>> so why lie?
>>>>>>>
>>>>>>
>>>>>> No it wouldn't. D has no reference to H.
>>>>> int D(ptr x)
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> Troll !!!
>>>>>
>>>> Then D is not a program so the halting problem doesn't apply.
>>>
>>> When one believes that isomorphisms are fairy tales this
>>> might seem to be true. Anyone that knows the meaning of
>>> the term {isomorphism} knows that they are not fairy tales.
>>>
>>
>> Specify the isomorphism between programs and whatever D is.
>
> If you don't already know then you don't know enough
> to have it explained to you.
>
You don't know enough to explain it.

On 1/2/2024 4:26 PM, immibis wrote:
> On 1/2/24 23:16, olcott wrote:
>> On 1/2/2024 3:46 PM, immibis wrote:
>>> On 1/2/24 22:40, olcott wrote:
>>>> On 1/2/2024 3:23 PM, immibis wrote:
>>>>> On 1/2/24 21:59, olcott wrote:
>>>>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>>>>> On 1/2/24 19:22, olcott wrote:
>>>>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>>>>
>>>>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>>>>
>>>>>>>>
>>>>>>>> You know that this would cause D to go into an infinite loop
>>>>>>>> so why lie?
>>>>>>>>
>>>>>>>
>>>>>>> No it wouldn't. D has no reference to H.
>>>>>> int D(ptr x)
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> Troll !!!
>>>>>>
>>>>> Then D is not a program so the halting problem doesn't apply.
>>>>
>>>> When one believes that isomorphisms are fairy tales this
>>>> might seem to be true. Anyone that knows the meaning of
>>>> the term {isomorphism} knows that they are not fairy tales.
>>>>
>>>
>>> Specify the isomorphism between programs and whatever D is.
>>
>> If you don't already know then you don't know enough
>> to have it explained to you.
>>
> You don't know enough to explain it.

Troll !!!

--
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/3/24 00:09, olcott wrote:
> On 1/2/2024 4:26 PM, immibis wrote:
>> On 1/2/24 23:16, olcott wrote:
>>> On 1/2/2024 3:46 PM, immibis wrote:
>>>> On 1/2/24 22:40, olcott wrote:
>>>>> On 1/2/2024 3:23 PM, immibis wrote:
>>>>>> On 1/2/24 21:59, olcott wrote:
>>>>>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>>>>>> On 1/2/24 19:22, olcott wrote:
>>>>>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>>>>>
>>>>>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You know that this would cause D to go into an infinite loop
>>>>>>>>> so why lie?
>>>>>>>>>
>>>>>>>>
>>>>>>>> No it wouldn't. D has no reference to H.
>>>>>>> int D(ptr x)
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> Troll !!!
>>>>>>>
>>>>>> Then D is not a program so the halting problem doesn't apply.
>>>>>
>>>>> When one believes that isomorphisms are fairy tales this
>>>>> might seem to be true. Anyone that knows the meaning of
>>>>> the term {isomorphism} knows that they are not fairy tales.
>>>>>
>>>>
>>>> Specify the isomorphism between programs and whatever D is.
>>>
>>> If you don't already know then you don't know enough
>>> to have it explained to you.
>>>
>> You don't know enough to explain it.
>
> Troll !!!
>
It's not a magic spell you can use to hide the fact you don't know the
isomorphism.

On 1/2/24 2:11 PM, olcott wrote:
> On 1/2/2024 12:27 PM, immibis wrote:
>> On 1/2/24 19:18, olcott wrote:
>>> On 1/2/2024 9:35 AM, immibis wrote:
>>>> On 1/2/24 04:59, olcott wrote:
>>>>> On 1/1/2024 9:47 PM, immibis wrote:
>>>>>> On 1/2/24 00:42, Richard Damon wrote:
>>>>>>> Part of Olcotts problem seems to be that he thinks that the input
>>>>>>> "D" doesn't change as he mainpulates "the" H.
>>>>>>
>>>>>> It doesn't. You don't change D, you make a new D. Nor do you
>>>>>> change H.
>>>>>
>>>>>
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>>> It is always this same D.
>>>>>
>>>>> _D()
>>>>> [00001c72] 55             push ebp
>>>>> [00001c73] 8bec           mov ebp,esp
>>>>> [00001c75] 51             push ecx
>>>>> [00001c76] 8b4508         mov eax,[ebp+08]
>>>>> [00001c79] 50             push eax
>>>>> [00001c7a] 8b4d08         mov ecx,[ebp+08]
>>>>> [00001c7d] 51             push ecx
>>>>> [00001c7e] e8bff8ffff     call 00001542
>>>>> [00001c83] 83c408         add esp,+08
>>>>> [00001c86] 8945fc         mov [ebp-04],eax
>>>>> [00001c89] 837dfc00       cmp dword [ebp-04],+00
>>>>> [00001c8d] 7402           jz 00001c91
>>>>> [00001c8f] ebfe           jmp 00001c8f
>>>>> [00001c91] 8b45fc         mov eax,[ebp-04]
>>>>> [00001c94] 8be5           mov esp,ebp
>>>>> [00001c96] 5d             pop ebp
>>>>> [00001c97] c3             ret
>>>>> Size in bytes:(0038) [00001c97]
>>>>>
>>>>
>>>> This isn't a program. It's only half a program. The address 00001542
>>>> which is part of the program code is missing from the listing.
>>>
>>> D correctly simulated by H at machine address 00001542
>>> cannot possibly reach past its own machine address 00001c7e.
>>> The above is verified as completely true entirely on the
>>> basis of the meaning of the above code.
>>>
>>
>> Rejected due to not addressing the complaint.
>>
>> This isn't a program. It's only half a program. The address 00001542
>> which is part of the program code is missing from the listing.
>
> *I never claimed that D is a program, thus strawman error*
>
> It is an easily verified fact that D correctly simulated
> by H cannot possibly reach past its own machine address
> 00001c7e.
>
>

So, you are admitting that H isn't a "Halt Decider"?

As Halt Decider decide on PROGRAMS represeted by their input.

Also, you are admitting that you are lying that D is the "pathological
PROGRAM" from the proof, as that was most definitely a PROGRAM.

Thus, you have just admitted that your whole argument is based on FRAUD.

On 1/2/24 1:20 PM, olcott wrote:
> On 1/2/2024 9:36 AM, immibis wrote:
>> On 1/2/24 05:05, olcott wrote:
>>>
>>> H Simulates D on input D and as soon as H detects
>>> that D is calling H, H correctly determines that D
>>> would continue to simulate D without ever terminating
>>> normally.
>>
>> so it infers that H(D,D) doesn't halt
>>
>> then H(D,D) halts
>>
>> an incorrect inference
>>
>
> H correctly determines that D correctly simulated
> by H cannot possibly reach any point in its own
> execution trace past D's call to H.
>

But that isn't the Halting Question.

The Halting Question is about the direct execution of the program
represented by the input.

Yes, with a proper definition of "Correct Simulation", namely that of a
UTM, or a simulation that exactly matches the results of a direct
executin, you can substitute a "Correct Simulation" for the Direct
Execution, but ONLY if the simulation matchs that definition of "Correct".

Since a real UTM never aborts its simulation, any aborted simulation
proves itself not to be "Correct" by this definition, you have just
admitted that your H doesn't "Correctly Simulate" its input, so you
can't base its answer on a condition that doesn't actually happen.

On 1/2/24 1:22 PM, olcott wrote:
> On 1/2/2024 9:37 AM, immibis wrote:
>> On 1/2/24 05:10, olcott wrote:
>>> Everyone here (out of their ignorance) makes sure to
>>> ignore the fact that both Boolean return values from H(D,D)
>>> are incorrect and the return value of 1 from H1(D,D > correct
>>
>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>
>
> You know that this would cause D to go into an infinite loop
> so why lie?
>
>

But this H can't do that.

You are basing your logic on Unicorns again, showing your ignorance of
the subject.

What matters isn't what some other D based on a different H does, but
what this D based on the H you started with claiming it was correct,
since that H returns 0, then D calls it, gets the 0, and then halts.

Now, if you want to say that your D is something differenent, and not
actually the program defined in the proof, then you are just admitting
that you are a FRAUD, having claimed that you are working on the case of
the proof when you weren't.

On 1/2/24 4:40 PM, olcott wrote:
> On 1/2/2024 3:23 PM, immibis wrote:
>> On 1/2/24 21:59, olcott wrote:
>>> On 1/2/2024 2:29 PM, immibis wrote:
>>>> On 1/2/24 19:22, olcott wrote:
>>>>> On 1/2/2024 9:37 AM, immibis wrote:
>>>>>> On 1/2/24 05:10, olcott wrote:
>>>>>>> Everyone here (out of their ignorance) makes sure to
>>>>>>> ignore the fact that both Boolean return values from H(D,D)
>>>>>>> are incorrect and the return value of 1 from H1(D,D > correct
>>>>>>
>>>>>> if D(D) halts then the return value of 1 from H(D,D) is correct
>>>>>>
>>>>>
>>>>> You know that this would cause D to go into an infinite loop
>>>>> so why lie?
>>>>>
>>>>
>>>> No it wouldn't. D has no reference to H.
>>> int D(ptr x)
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> Troll !!!
>>>
>> Then D is not a program so the halting problem doesn't apply.
>
> When one believes that isomorphisms are fairy tales this
> might seem to be true. Anyone that knows the meaning of
> the term {isomorphism} knows that they are not fairy tales.
>

Things that give different results than the original are NOT
"isomophisms" but STRAWMEN.

Your argument IS a fairy tales, it is about fairy dust powered unicorns
that make program change their behavior by their magic.

You KNOW your argument is full of holes, or you are just admiting tha
tyou are mentally incompetent (or both).