Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.

Both H and Ĥ.H use the same algorithm that correctly detects
whether or not a correct simulation of their input would cause
their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ
applied to ⟨Ĥ⟩ halts.

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

On 3/03/24 18:00, olcott wrote:
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.

in other words: no Turing machine solves the halting problem

On 3/3/24 6:21 PM, immibis wrote:
> On 3/03/24 18:00, olcott wrote:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>
> in other words: no Turing machine solves the halting problem

Yea, only Olcott machines that have some magical property that copies of
themselves act differently even though they are supposed to be the same.

We have no idea what Olcott machine are good for.

On 3/3/2024 5:21 PM, immibis wrote:
> On 3/03/24 18:00, olcott wrote:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>
> in other words: no Turing machine solves the halting problem

*Not in the least little bit*
No Turing machine that has been intentionally broken so that it always
gets the wrong answer on its own machine description ever gets the
right answer on its own machine description.

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

On 3/3/24 7:16 PM, olcott wrote:
> On 3/3/2024 5:21 PM, immibis wrote:
>> On 3/03/24 18:00, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>>
>> in other words: no Turing machine solves the halting problem
>
> *Not in the least little bit*
> No Turing machine that has been intentionally broken so that it always
> gets the wrong answer on its own machine description ever gets the
> right answer on its own machine description.
>

But H^.H wasn't "broken" as its code wasn't changed in a way that affect it.

You just don't get that fact, that ALL COPIES of a Turing Machine ALWAYS
do the same thing given the same input

If you want to claim differently, show two copies of an ACTUAL Turing
Machine (not just a "verbal description" [that just lies]) that does
what you claim, acts differently.

Your problem is that you just don't understand what a Turing Machine
actual is, as you will admit by not showing the "simple" case that
proves your claim.

It HAS to be a simple case, as since they start in the same state, and
if they end up in a different state, there must a first transition where
things started in the same state, but the next state has a difference in
current state or tape contents, so you only need to show that one
instruction.

Of course, you have already admitted that you have been lying about
working in the actual field of Computation Theory (and don't actually
know what it is about), so you are just going to further prove this by
ignoring this call.

You are just sealing your reputation as an ignorant pathological lying
idiot.

On 3/3/2024 5:29 PM, Richard Damon wrote:
> On 3/3/24 6:21 PM, immibis wrote:
>> On 3/03/24 18:00, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>>
>> in other words: no Turing machine solves the halting problem
>
> Yea, only Olcott machines that have some magical property that copies of
> themselves act differently even though they are supposed to be the same.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

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

On 3/3/2024 6:27 PM, Richard Damon wrote:
> On 3/3/24 7:16 PM, olcott wrote:
>> On 3/3/2024 5:21 PM, immibis wrote:
>>> On 3/03/24 18:00, olcott wrote:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>>>
>>> in other words: no Turing machine solves the halting problem
>>
>> *Not in the least little bit*
>> No Turing machine that has been intentionally broken so that it always
>> gets the wrong answer on its own machine description ever gets the
>> right answer on its own machine description.
>>
>
> But H^.H wasn't "broken" as its code wasn't changed in a way that affect
> it.

That Ĥ ⟨Ĥ⟩ contradicts both values that Ĥ.H returns is the
only reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot return a correct value.

If you want to call this "fixes", or "pats on the head"
it is still true that Ĥ breaks Ĥ.H.

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

On 3/3/24 8:03 PM, olcott wrote:
> On 3/3/2024 6:27 PM, Richard Damon wrote:
>> On 3/3/24 7:16 PM, olcott wrote:
>>> On 3/3/2024 5:21 PM, immibis wrote:
>>>> On 3/03/24 18:00, olcott wrote:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> can derive that corresponds to the actual behavior of Ĥ applied to
>>>>> ⟨Ĥ⟩.
>>>>
>>>> in other words: no Turing machine solves the halting problem
>>>
>>> *Not in the least little bit*
>>> No Turing machine that has been intentionally broken so that it always
>>> gets the wrong answer on its own machine description ever gets the
>>> right answer on its own machine description.
>>>
>>
>> But H^.H wasn't "broken" as its code wasn't changed in a way that
>> affect it.
>
> That Ĥ ⟨Ĥ⟩ contradicts both values that Ĥ.H returns is the
> only reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot return a correct value.
>
> If you want to call this "fixes", or "pats on the head"
> it is still true that Ĥ breaks Ĥ.H.
>
>

It generates an input that shows it is not a Halt Decider.

It doesn't change the code in it to "break" it.

Thus ALL COPIES of H, that will ALWAYS return the same value for a given
input are "broken" because it has been shown they return the wrong value.

Thus, YOUR LIE that H can still be correct,, is just that, A LIE.

Since we can build an H^ input for ANY machine that we might think is a
Halt Decider, no machine can actually BE a Halt Decider, as we can make
an input by the ^ template that shows it to be wrong.

On 3/3/24 7:54 PM, olcott wrote:
> On 3/3/2024 5:29 PM, Richard Damon wrote:
>> On 3/3/24 6:21 PM, immibis wrote:
>>> On 3/03/24 18:00, olcott wrote:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> can derive that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.
>>>
>>> in other words: no Turing machine solves the halting problem
>>
>> Yea, only Olcott machines that have some magical property that copies
>> of themselves act differently even though they are supposed to be the
>> same.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.
>
> Humans can see that this criteria derives different answers
> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>

Right, Humans, and many other Deciders can see this.

But H is stuck, whatever its design generates for the answer will be
wrong. (and there is a right answer to the question, so it is valid)

If H and H^.H generate different answers, then you are just admitting to
LYING aobut H^.H, as it is REQUIRED to be an exact copy of the algoritm
of H, and thus will generate the exact same result for the exact input.

Thus, you are proved to be an ignorant pathological lying idiot.

On 3/3/2024 7:16 PM, Richard Damon wrote:
> On 3/3/24 7:54 PM, olcott wrote:
>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>> On 3/3/24 6:21 PM, immibis wrote:
>>>> On 3/03/24 18:00, olcott wrote:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> can derive that corresponds to the actual behavior of Ĥ applied to
>>>>> ⟨Ĥ⟩.
>>>>
>>>> in other words: no Turing machine solves the halting problem
>>>
>>> Yea, only Olcott machines that have some magical property that copies
>>> of themselves act differently even though they are supposed to be the
>>> same.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> Both H and Ĥ.H transition to their NO state when a correct and
>> complete simulation of their input would cause their own infinite
>> execution and otherwise transition to their YES state.
>>
>> Humans can see that this criteria derives different answers
>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> Right, Humans, and many other Deciders can see this.
>

Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

It is by this single consistent criterion measure that
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.

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

On 3/3/24 10:59 PM, olcott wrote:
> On 3/3/2024 7:16 PM, Richard Damon wrote:
>> On 3/3/24 7:54 PM, olcott wrote:
>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> can derive that corresponds to the actual behavior of Ĥ applied to
>>>>>> ⟨Ĥ⟩.
>>>>>
>>>>> in other words: no Turing machine solves the halting problem
>>>>
>>>> Yea, only Olcott machines that have some magical property that
>>>> copies of themselves act differently even though they are supposed
>>>> to be the same.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> Both H and Ĥ.H transition to their NO state when a correct and
>>> complete simulation of their input would cause their own infinite
>>> execution and otherwise transition to their YES state.
>>>
>>> Humans can see that this criteria derives different answers
>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> Right, Humans, and many other Deciders can see this.
>>
>
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.
>
> It is by this single consistent criterion measure that
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>

So, you have been LYING that you have been working on the Halting Problem!

On 3/3/2024 10:30 PM, Richard Damon wrote:
> On 3/3/24 10:59 PM, olcott wrote:
>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>> On 3/3/24 7:54 PM, olcott wrote:
>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> can derive that corresponds to the actual behavior of Ĥ applied
>>>>>>> to ⟨Ĥ⟩.
>>>>>>
>>>>>> in other words: no Turing machine solves the halting problem
>>>>>
>>>>> Yea, only Olcott machines that have some magical property that
>>>>> copies of themselves act differently even though they are supposed
>>>>> to be the same.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>> complete simulation of their input would cause their own infinite
>>>> execution and otherwise transition to their YES state.
>>>>
>>>> Humans can see that this criteria derives different answers
>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>
>>> Right, Humans, and many other Deciders can see this.
>>>
>>
>> Both H and Ĥ.H transition to their NO state when a correct and
>> complete simulation of their input would cause their own infinite
>> execution and otherwise transition to their YES state.
>>
>> It is by this single consistent criterion measure that
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>
>
> So, you have been LYING that you have been working on the Halting Problem!
>
>

Mike agreed that machines can examine every internal
detail of their simulated machines.

This means that Ĥ.H can see that an identical copy of its
simulated input pair is about to be simulated with an
identical its simulated input pair.

That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
"abort simulation" criterion measure has been met.

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

On 3/4/24 12:35 AM, olcott wrote:
> On 3/3/2024 10:30 PM, Richard Damon wrote:
>> On 3/3/24 10:59 PM, olcott wrote:
>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> can derive that corresponds to the actual behavior of Ĥ applied
>>>>>>>> to ⟨Ĥ⟩.
>>>>>>>
>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>
>>>>>> Yea, only Olcott machines that have some magical property that
>>>>>> copies of themselves act differently even though they are supposed
>>>>>> to be the same.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>> complete simulation of their input would cause their own infinite
>>>>> execution and otherwise transition to their YES state.
>>>>>
>>>>> Humans can see that this criteria derives different answers
>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>
>>>> Right, Humans, and many other Deciders can see this.
>>>>
>>>
>>> Both H and Ĥ.H transition to their NO state when a correct and
>>> complete simulation of their input would cause their own infinite
>>> execution and otherwise transition to their YES state.
>>>
>>> It is by this single consistent criterion measure that
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>
>>
>> So, you have been LYING that you have been working on the Halting
>> Problem!
>>
>>
>
> Mike agreed that machines can examine every internal
> detail of their simulated machines.
>
> This means that Ĥ.H can see that an identical copy of its
> simulated input pair is about to be simulated with an
> identical its simulated input pair.
>
> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
> "abort simulation" criterion measure has been met.
>

Yep, and since its "abort simulation" critera has false positive for the
ACTUAL QUESTION that it is deciding, it gets the wrong answer.

Since H^ (H^) Halts, H (H^) (H^), or H^,H (H^) (H^) should have gone to
qy for H to have been correct, but it doesn't, so it is just wrong.

You have just lied to yourself so much you don't believe the truth anymore.

On 3/4/2024 6:51 AM, Richard Damon wrote:
> On 3/4/24 12:35 AM, olcott wrote:
>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>> On 3/3/24 10:59 PM, olcott wrote:
>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>>
>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ applied
>>>>>>>>> to ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>
>>>>>>> Yea, only Olcott machines that have some magical property that
>>>>>>> copies of themselves act differently even though they are
>>>>>>> supposed to be the same.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>> complete simulation of their input would cause their own infinite
>>>>>> execution and otherwise transition to their YES state.
>>>>>>
>>>>>> Humans can see that this criteria derives different answers
>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>
>>>>> Right, Humans, and many other Deciders can see this.
>>>>>
>>>>
>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>> complete simulation of their input would cause their own infinite
>>>> execution and otherwise transition to their YES state.
>>>>
>>>> It is by this single consistent criterion measure that
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>
>>>
>>> So, you have been LYING that you have been working on the Halting
>>> Problem!
>>>
>>>
>>
>> Mike agreed that machines can examine every internal
>> detail of their simulated machines.
>>
>> This means that Ĥ.H can see that an identical copy of its
>> simulated input pair is about to be simulated with an
>> identical its simulated input pair.
>>
>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>> "abort simulation" criterion measure has been met.
>>
>
> Yep, and since its "abort simulation" critera has false positive for the
> ACTUAL QUESTION that it is deciding, it gets the wrong answer.

*It is not a false positive for whether it needs to abort or not*

Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

Because it gets this "abort criteria" aspect correctly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
correctly transitions to Ĥ.Hqn indicating that it just aborted the
simulation of its input.

Thus you and I and surprisingly Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ can all see that the
directly executed Ĥ ⟨Ĥ⟩ halts.

> Since H^ (H^) Halts, H (H^) (H^), or H^,H (H^) (H^) should have gone to
> qy for H to have been correct, but it doesn't, so it is just wrong.
>
> You have just lied to yourself so much you don't believe the truth anymore.
>
>

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

On 3/4/24 3:30 PM, olcott wrote:
> On 3/4/2024 6:51 AM, Richard Damon wrote:
>> On 3/4/24 12:35 AM, olcott wrote:
>>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>>> On 3/3/24 10:59 PM, olcott wrote:
>>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>> not halt
>>>>>>>>>>
>>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ
>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>>
>>>>>>>> Yea, only Olcott machines that have some magical property that
>>>>>>>> copies of themselves act differently even though they are
>>>>>>>> supposed to be the same.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>
>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>
>>>>>>> Humans can see that this criteria derives different answers
>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>
>>>>>> Right, Humans, and many other Deciders can see this.
>>>>>>
>>>>>
>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>> complete simulation of their input would cause their own infinite
>>>>> execution and otherwise transition to their YES state.
>>>>>
>>>>> It is by this single consistent criterion measure that
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>>
>>>>
>>>> So, you have been LYING that you have been working on the Halting
>>>> Problem!
>>>>
>>>>
>>>
>>> Mike agreed that machines can examine every internal
>>> detail of their simulated machines.
>>>
>>> This means that Ĥ.H can see that an identical copy of its
>>> simulated input pair is about to be simulated with an
>>> identical its simulated input pair.
>>>
>>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>>> "abort simulation" criterion measure has been met.
>>>
>>
>> Yep, and since its "abort simulation" critera has false positive for
>> the ACTUAL QUESTION that it is deciding, it gets the wrong answer.
>
> *It is not a false positive for whether it needs to abort or not*

But it IS, as since the algorithm said to stop simulating, but if we
continue the simulation with an ideal simulator (and don't change the
input) then we find that we reach a final state, so H did not NEED to
abort, but it did.

You can't ignore the reality that the input is based on the actual
machine that gives the answer, not the hypothetical one that shows that
the actual answer was wrong.

>
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.
>
> Because it gets this "abort criteria" aspect correctly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> correctly transitions to Ĥ.Hqn indicating that it just aborted the
> simulation of its input.

Which is just a strawman, as that actual question is does this exact
input Halt when run

>
> Thus you and I and surprisingly Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ can all see that the
> directly executed Ĥ ⟨Ĥ⟩ halts.

Right, but ONLY if H (H^) (H^) says it doesn't.

After all, if you change H (H^) (H^) (and thus H^.H (H^) (H^) ) to
abort and return Halting, then it is clear that this NEW H^ will not
halt, so that alternate H is also wrong.

You need to look at the machine that you are actually using, not the
fantasy in your mind that breaks the rules.

You are just showing you mental processes don't understand what is true,
which is what is making you into that ignorant pathological lying idiot.

>
>> Since H^ (H^) Halts, H (H^) (H^), or H^,H (H^) (H^) should have gone
>> to qy for H to have been correct, but it doesn't, so it is just wrong.
>>
>> You have just lied to yourself so much you don't believe the truth
>> anymore.
>>
>>
>

On 3/4/2024 7:44 PM, Richard Damon wrote:
> On 3/4/24 3:30 PM, olcott wrote:
>> On 3/4/2024 6:51 AM, Richard Damon wrote:
>>> On 3/4/24 12:35 AM, olcott wrote:
>>>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>>>> On 3/3/24 10:59 PM, olcott wrote:
>>>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>> not halt
>>>>>>>>>>>
>>>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>>>
>>>>>>>>> Yea, only Olcott machines that have some magical property that
>>>>>>>>> copies of themselves act differently even though they are
>>>>>>>>> supposed to be the same.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>> to ⟨Ĥ⟩
>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>
>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>
>>>>>>>> Humans can see that this criteria derives different answers
>>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>
>>>>>>> Right, Humans, and many other Deciders can see this.
>>>>>>>
>>>>>>
>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>> complete simulation of their input would cause their own infinite
>>>>>> execution and otherwise transition to their YES state.
>>>>>>
>>>>>> It is by this single consistent criterion measure that
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>>>
>>>>>
>>>>> So, you have been LYING that you have been working on the Halting
>>>>> Problem!
>>>>>
>>>>>
>>>>
>>>> Mike agreed that machines can examine every internal
>>>> detail of their simulated machines.
>>>>
>>>> This means that Ĥ.H can see that an identical copy of its
>>>> simulated input pair is about to be simulated with an
>>>> identical its simulated input pair.
>>>>
>>>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>>>> "abort simulation" criterion measure has been met.
>>>>
>>>
>>> Yep, and since its "abort simulation" critera has false positive for
>>> the ACTUAL QUESTION that it is deciding, it gets the wrong answer.
>>
>> *It is not a false positive for whether it needs to abort or not*
>
> But it IS, as since the algorithm said to stop simulating, but if we
> continue the simulation with an ideal simulator (and don't change the
> input) then we find that we reach a final state, so H did not NEED to
> abort, but it did.
>

It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees the it must abort
its simulation when Ĥ.H is a P in the RASP model where every
P knows its own machine address.

> You can't ignore the reality that the input is based on the actual
> machine that gives the answer, not the hypothetical one that shows that
> the actual answer was wrong.
>

Do I need to repeat this a few hundred times?
Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

>>
>> Both H and Ĥ.H transition to their NO state when a correct and
>> complete simulation of their input would cause their own infinite
>> execution and otherwise transition to their YES state.
>>
>> Because it gets this "abort criteria" aspect correctly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> correctly transitions to Ĥ.Hqn indicating that it just aborted the
>> simulation of its input.
>
> Which is just a strawman, as that actual question is does this exact
> input Halt when run

*When every H correctly answers*
Do you need to abort your simulation to prevent your own
infinite execution? Then only the broken ones get the wrong answer.

>>
>> Thus you and I and surprisingly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can all see that the
>> directly executed Ĥ ⟨Ĥ⟩ halts.
>
> Right, but ONLY if H (H^) (H^) says it doesn't.
>

H is at a different memory address than Ĥ.H thus cannot
possibly be contradicted by Ĥ.

> After all, if you change H (H^) (H^)  (and thus H^.H (H^) (H^) ) to
> abort and return Halting, then it is clear that this NEW H^ will not
> halt, so that alternate H is also wrong.

*Do I need to repeat this a few hundred times*
Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

> You need to look at the machine that you are actually using, not the
> fantasy in your mind that breaks the rules.
>
> You are just showing you mental processes don't understand what is true,
> which is what is making you into that ignorant pathological lying idiot.
>

You already admitted that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its
simulation and transition to Ĥ.Hqn.

You already admitted that when Ĥ.H does this then Ĥ
halts.

Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

Those admissions prove that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the above
"abort simulation" criteria thus H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to H.qy.

>>
>>> Since H^ (H^) Halts, H (H^) (H^), or H^,H (H^) (H^) should have gone
>>> to qy for H to have been correct, but it doesn't, so it is just wrong.
>>>
>>> You have just lied to yourself so much you don't believe the truth
>>> anymore.
>>>
>>>
>>
>

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

On 3/5/24 12:20 AM, olcott wrote:
> On 3/4/2024 7:44 PM, Richard Damon wrote:
>> On 3/4/24 3:30 PM, olcott wrote:
>>> On 3/4/2024 6:51 AM, Richard Damon wrote:
>>>> On 3/4/24 12:35 AM, olcott wrote:
>>>>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>>>>> On 3/3/24 10:59 PM, olcott wrote:
>>>>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>> does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ
>>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>>>>
>>>>>>>>>> Yea, only Olcott machines that have some magical property that
>>>>>>>>>> copies of themselves act differently even though they are
>>>>>>>>>> supposed to be the same.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>>
>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>>
>>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>>
>>>>>>>>> Humans can see that this criteria derives different answers
>>>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, Humans, and many other Deciders can see this.
>>>>>>>>
>>>>>>>
>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>
>>>>>>> It is by this single consistent criterion measure that
>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>>>>
>>>>>>
>>>>>> So, you have been LYING that you have been working on the Halting
>>>>>> Problem!
>>>>>>
>>>>>>
>>>>>
>>>>> Mike agreed that machines can examine every internal
>>>>> detail of their simulated machines.
>>>>>
>>>>> This means that Ĥ.H can see that an identical copy of its
>>>>> simulated input pair is about to be simulated with an
>>>>> identical its simulated input pair.
>>>>>
>>>>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>>>>> "abort simulation" criterion measure has been met.
>>>>>
>>>>
>>>> Yep, and since its "abort simulation" critera has false positive for
>>>> the ACTUAL QUESTION that it is deciding, it gets the wrong answer.
>>>
>>> *It is not a false positive for whether it needs to abort or not*
>>
>> But it IS, as since the algorithm said to stop simulating, but if we
>> continue the simulation with an ideal simulator (and don't change the
>> input) then we find that we reach a final state, so H did not NEED to
>> abort, but it did.
>>
>
> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees the it must abort
> its simulation when Ĥ.H is a P in the RASP model where every
> P knows its own machine address.

So?

That means that the machine it is simulating does that, and will go to
the same answer as H does, and thus H will be wrong.

>
>> You can't ignore the reality that the input is based on the actual
>> machine that gives the answer, not the hypothetical one that shows
>> that the actual answer was wrong.
>>
>
> Do I need to repeat this a few hundred times?
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.

And thus, H is WRONG as a Halt Decider

You are just admitting that you are using a strawman, and to bthus being
a liar.

>
>>>
>>> Both H and Ĥ.H transition to their NO state when a correct and
>>> complete simulation of their input would cause their own infinite
>>> execution and otherwise transition to their YES state.
>>>
>>> Because it gets this "abort criteria" aspect correctly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> correctly transitions to Ĥ.Hqn indicating that it just aborted the
>>> simulation of its input.
>>
>> Which is just a strawman, as that actual question is does this exact
>> input Halt when run
>
> *When every H correctly answers*
> Do you need to abort your simulation to prevent your own
> infinite execution? Then only the broken ones get the wrong answer.

Which isn't the Halting Question, so you are just admitting to lying by
using a strawman
>
>>>
>>> Thus you and I and surprisingly Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can all see that the
>>> directly executed Ĥ ⟨Ĥ⟩ halts.
>>
>> Right, but ONLY if H (H^) (H^) says it doesn't.
>>
>
> H is at a different memory address than Ĥ.H thus cannot
> possibly be contradicted by Ĥ.

Only by admitting that you lied by not having H be a computation. It
seems the problem is you are ignorant of what that is, and just don't
care about what is truth.

>
>> After all, if you change H (H^) (H^)  (and thus H^.H (H^) (H^) ) to
>> abort and return Halting, then it is clear that this NEW H^ will not
>> halt, so that alternate H is also wrong.
>
> *Do I need to repeat this a few hundred times*
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.

And thus you have repeated a few hunderd times that admission that you
have been lying about working on the Halting problem.

You can't prove something with lies.

>
>> You need to look at the machine that you are actually using, not the
>> fantasy in your mind that breaks the rules.
>>
>> You are just showing you mental processes don't understand what is
>> true, which is what is making you into that ignorant pathological
>> lying idiot.
>>
>
> You already admitted that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its
> simulation and transition to Ĥ.Hqn.
>
> You already admitted that when Ĥ.H does this then Ĥ
> halts.
>
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.
>
> Those admissions prove that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the above
> "abort simulation" criteria thus H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to H.qy.

On 3/5/2024 5:33 AM, Richard Damon wrote:
> On 3/5/24 12:20 AM, olcott wrote:
>> On 3/4/2024 7:44 PM, Richard Damon wrote:
>>> On 3/4/24 3:30 PM, olcott wrote:
>>>> On 3/4/2024 6:51 AM, Richard Damon wrote:
>>>>> On 3/4/24 12:35 AM, olcott wrote:
>>>>>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>>>>>> On 3/3/24 10:59 PM, olcott wrote:
>>>>>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ
>>>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>>>>>
>>>>>>>>>>> Yea, only Olcott machines that have some magical property
>>>>>>>>>>> that copies of themselves act differently even though they
>>>>>>>>>>> are supposed to be the same.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>> not halt
>>>>>>>>>>
>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process
>>>>>>>>>>
>>>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>>>
>>>>>>>>>> Humans can see that this criteria derives different answers
>>>>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, Humans, and many other Deciders can see this.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>
>>>>>>>> It is by this single consistent criterion measure that
>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>>>>>
>>>>>>>
>>>>>>> So, you have been LYING that you have been working on the Halting
>>>>>>> Problem!
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Mike agreed that machines can examine every internal
>>>>>> detail of their simulated machines.
>>>>>>
>>>>>> This means that Ĥ.H can see that an identical copy of its
>>>>>> simulated input pair is about to be simulated with an
>>>>>> identical its simulated input pair.
>>>>>>
>>>>>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>>>>>> "abort simulation" criterion measure has been met.
>>>>>>
>>>>>
>>>>> Yep, and since its "abort simulation" critera has false positive
>>>>> for the ACTUAL QUESTION that it is deciding, it gets the wrong answer.
>>>>
>>>> *It is not a false positive for whether it needs to abort or not*
>>>
>>> But it IS, as since the algorithm said to stop simulating, but if we
>>> continue the simulation with an ideal simulator (and don't change the
>>> input) then we find that we reach a final state, so H did not NEED to
>>> abort, but it did.
>>>
>>
>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees the it must abort
>> its simulation when Ĥ.H is a P in the RASP model where every
>> P knows its own machine address.
>
> So?
>
> That means that the machine it is simulating does that, and will go to
> the same answer as H does, and thus H will be wrong.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent
its own infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt.
This entails that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
*This is a verified fact that you have agreed to*

Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.

When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would
transition to H.qy
*This is a verified fact entailed by what you have agreed to*

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

On 3/5/24 3:11 PM, olcott wrote:
> On 3/5/2024 5:33 AM, Richard Damon wrote:
>> On 3/5/24 12:20 AM, olcott wrote:
>>> On 3/4/2024 7:44 PM, Richard Damon wrote:
>>>> On 3/4/24 3:30 PM, olcott wrote:
>>>>> On 3/4/2024 6:51 AM, Richard Damon wrote:
>>>>>> On 3/4/24 12:35 AM, olcott wrote:
>>>>>>> On 3/3/2024 10:30 PM, Richard Damon wrote:
>>>>>>>> On 3/3/24 10:59 PM, olcott wrote:
>>>>>>>>> On 3/3/2024 7:16 PM, Richard Damon wrote:
>>>>>>>>>> On 3/3/24 7:54 PM, olcott wrote:
>>>>>>>>>>> On 3/3/2024 5:29 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/3/24 6:21 PM, immibis wrote:
>>>>>>>>>>>>> On 3/03/24 18:00, olcott wrote:
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> ⟨Ĥ⟩
>>>>>>>>>>>>>> can derive that corresponds to the actual behavior of Ĥ
>>>>>>>>>>>>>> applied to ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> in other words: no Turing machine solves the halting problem
>>>>>>>>>>>>
>>>>>>>>>>>> Yea, only Olcott machines that have some magical property
>>>>>>>>>>>> that copies of themselves act differently even though they
>>>>>>>>>>>> are supposed to be the same.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>> not halt
>>>>>>>>>>>
>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>> process
>>>>>>>>>>>
>>>>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>>>>> complete simulation of their input would cause their own
>>>>>>>>>>> infinite
>>>>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>>>>
>>>>>>>>>>> Humans can see that this criteria derives different answers
>>>>>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, Humans, and many other Deciders can see this.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Both H and Ĥ.H transition to their NO state when a correct and
>>>>>>>>> complete simulation of their input would cause their own infinite
>>>>>>>>> execution and otherwise transition to their YES state.
>>>>>>>>>
>>>>>>>>> It is by this single consistent criterion measure that
>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ derive their differing results.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you have been LYING that you have been working on the
>>>>>>>> Halting Problem!
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Mike agreed that machines can examine every internal
>>>>>>> detail of their simulated machines.
>>>>>>>
>>>>>>> This means that Ĥ.H can see that an identical copy of its
>>>>>>> simulated input pair is about to be simulated with an
>>>>>>> identical its simulated input pair.
>>>>>>>
>>>>>>> That means that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does see that its:
>>>>>>> "abort simulation" criterion measure has been met.
>>>>>>>
>>>>>>
>>>>>> Yep, and since its "abort simulation" critera has false positive
>>>>>> for the ACTUAL QUESTION that it is deciding, it gets the wrong
>>>>>> answer.
>>>>>
>>>>> *It is not a false positive for whether it needs to abort or not*
>>>>
>>>> But it IS, as since the algorithm said to stop simulating, but if we
>>>> continue the simulation with an ideal simulator (and don't change
>>>> the input) then we find that we reach a final state, so H did not
>>>> NEED to abort, but it did.
>>>>
>>>
>>> It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ sees the it must abort
>>> its simulation when Ĥ.H is a P in the RASP model where every
>>> P knows its own machine address.
>>
>> So?
>>
>> That means that the machine it is simulating does that, and will go to
>> the same answer as H does, and thus H will be wrong.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> It is true that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition to Ĥ.Hqn to prevent
> its own infinite execution. It is true that this makes Ĥ ⟨Ĥ⟩ halt.
> This entails that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy.
> *This is a verified fact that you have agreed to*
>
> Both H and Ĥ.H transition to their NO state when a correct and
> complete simulation of their input would cause their own infinite
> execution and otherwise transition to their YES state.
>
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly apply the above criteria
> then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to Ĥ.Hqn and H ⟨Ĥ⟩ ⟨Ĥ⟩ would
> transition to H.qy
> *This is a verified fact entailed by what you have agreed to*
>

But for H to go to qy while H^.H goes to qn means that H fails to be the
computation requied of it, so it isn't a Halt Decider.

Note, Computations do NOT "apply" the correct answer conditions to
arivve at the answer they need to get to be right, they apply the
pre-defined fixed and determinisitic instructions of their algorithm to
the data (and ONLY that data) provided by their input and reach the
answer they are programmed to get to.

You do not seem to understad this, thus proving you are just totally
IGNORANT of the field you are trying to talk about.

You seem to think that made up fantasies are true, and facts don't matter.

That is what has made you into the biggest ignorant pathological lying
idiot around.

Yes, to get the right answer H needs to go to the opposite results that
H^.H did for the same input.

BUT, they also are both the IDENTICAL algorithm, on the IDENTICAL input,
so must do the same thing.

So, by your logic, doing the same thing means getting the opposite resuts.

In other words, your "world" is built on logic that says the Liars
Paradox is ok and a valid condition. I guess that is just because you
are innately a LIAR.