// Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
// Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
// H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
// ∞ means an infinite loop has been appended to the Ĥ.Hqy state
//
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
returns making Ĥ self-contradictory.

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

On 2/28/24 5:18 PM, olcott wrote:
> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
> //
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
> returns making Ĥ self-contradictory.
>

So, I guess you are just your bowels, which is why you are always
talking about your POOP.

Ye, H^ contradicts *H* of which it has a copy as PART of itself.

Things are ALL of themselves, not just parts.

On 2/28/2024 6:27 PM, Richard Damon wrote:
> On 2/28/24 5:18 PM, olcott wrote:
>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>> //
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>> returns making Ĥ self-contradictory.
>>
>
> So, I guess you are just your bowels, which is why you are always
> talking about your POOP.
>
> Ye, H^ contradicts *H* of which it has a copy as PART of itself.
>
> Things are ALL of themselves, not just parts.

So when you stab yourself in the leg you did not stab yourself?

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

On 2/28/24 9:39 PM, olcott wrote:
> On 2/28/2024 6:27 PM, Richard Damon wrote:
>> On 2/28/24 5:18 PM, olcott wrote:
>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>> //
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>> halt
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>> returns making Ĥ self-contradictory.
>>>
>>
>> So, I guess you are just your bowels, which is why you are always
>> talking about your POOP.
>>
>> Ye, H^ contradicts *H* of which it has a copy as PART of itself.
>>
>> Things are ALL of themselves, not just parts.
>
> So when you stab yourself in the leg you did not stab yourself?
>

Of course I do, because I exist.

If we postulate the Easter Bunny stabbing himself in the leg, it doesn't
actually happen because there is no Easter Bunny.

If you postulate an H^ that actually meets your requirements, it doesn't
exist so it doen't contradict itself.

If you jus postulate an H^, and are asking if it got the right answer,
the answer is NO. Not because it "Contradicted itself", since it isn't a
decider and doesn't actually answer a question, but it contradicted the
H it was built on which did.

You just don't seem to have a grasp on what "Reality" is, and why it
matters.

Not even the "theoretical" reality of a Formal System.

Your just repeating the same error, without even trying to refute the
probelm pointed out, just prvoves that you are incapable of learning.

On 2/28/24 9:39 PM, olcott wrote:
> On 2/28/2024 6:27 PM, Richard Damon wrote:
>> On 2/28/24 5:18 PM, olcott wrote:
>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>> //
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>> halt
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>> returns making Ĥ self-contradictory.
>>>
>>
>> So, I guess you are just your bowels, which is why you are always
>> talking about your POOP.
>>
>> Ye, H^ contradicts *H* of which it has a copy as PART of itself.
>>
>> Things are ALL of themselves, not just parts.
>
> So when you stab yourself in the leg you did not stab yourself?
>

I answer

On 28/02/24 23:18, olcott wrote:
> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
> //
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
> returns making Ĥ self-contradictory.
>

Turing machine/input pairs are never self-contradictory. Ĥ is only
contradictory with its intended specification, which is not itself.

On 2/29/2024 4:31 AM, immibis wrote:
> On 28/02/24 23:18, olcott wrote:
>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>> //
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>> returns making Ĥ self-contradictory.
>>
>
>
> Turing machine/input pairs are never self-contradictory. Ĥ is only
> contradictory with its intended specification, which is not itself.

The only reason that the specification cannot be fulfilled by Ĥ is
that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
reports.

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

On 29/02/24 16:37, olcott wrote:
> On 2/29/2024 4:31 AM, immibis wrote:
>> On 28/02/24 23:18, olcott wrote:
>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>> //
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>> halt
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>> returns making Ĥ self-contradictory.
>>>
>>
>>
>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>> contradictory with its intended specification, which is not itself.
>
> The only reason that the specification cannot be fulfilled by Ĥ is
> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
> reports.
>
Yeah. That's the point. The only reason that the specification "x=1-x"
cannot be fulfilled by 2 is that 2 contradicts x=1-x by not being equal
to 1 minus itself.

On 2/29/2024 9:56 AM, immibis wrote:
> On 29/02/24 16:37, olcott wrote:
>> On 2/29/2024 4:31 AM, immibis wrote:
>>> On 28/02/24 23:18, olcott wrote:
>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>> //
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>>> halt
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>> returns making Ĥ self-contradictory.
>>>>
>>>
>>>
>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>> contradictory with its intended specification, which is not itself.
>>
>> The only reason that the specification cannot be fulfilled by Ĥ is
>> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
>> reports.
>>
> Yeah. That's the point.

The coherence theory of truth rejects this as unsound.
This brings us back to this quote:

"The halting problem cannot be solved because there is
something wrong with it."

The error stated by professor Hehner
...is a consistent, satisfiable specification for some
agent (anyone other than Carol), and an inconsistent,
unsatisfiable specification for some agent (Carol). (Hehner:2017)
https://www.cs.toronto.edu/~hehner/OSS.pdf

Is translated into simpler language is:
Carol's question is self-contradictory for Carol and not
self-contradictory for anyone else.

Applying this directly to the halting problem proofs
without the isomorphism of Carol's question:

The error of the halting problem specification is that it
expects self-contradictory questions to have a correct answer.

The above quote is made obsolete by this:
H ⟨Ĥ⟩ ⟨Ĥ⟩ (in a separate memory space) merely needs to report on
the actual behavior of Ĥ ⟨Ĥ⟩. We already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must
transition to Ĥ.Hqy or Ĥ.Hqn, H merely needs to see which one.

The updated position is that: "The halting problem proofs
do not prove that halting is undecidable. They only prove
that an otherwise correct halt decider can be changed so
that it is no longer correct."

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

On 2/29/24 10:37 AM, olcott wrote:
> On 2/29/2024 4:31 AM, immibis wrote:
>> On 28/02/24 23:18, olcott wrote:
>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>> //
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>> halt
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>> returns making Ĥ self-contradictory.
>>>
>>
>>
>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>> contradictory with its intended specification, which is not itself.
>
> The only reason that the specification cannot be fulfilled by Ĥ is
> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
> reports.
>

But the problem space ALLOWS that to happen, so it is valid.

On 2/29/2024 8:47 PM, Richard Damon wrote:
> On 2/29/24 10:37 AM, olcott wrote:
>> On 2/29/2024 4:31 AM, immibis wrote:
>>> On 28/02/24 23:18, olcott wrote:
>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>> //
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does not
>>>> halt
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>> returns making Ĥ self-contradictory.
>>>>
>>>
>>>
>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>> contradictory with its intended specification, which is not itself.
>>
>> The only reason that the specification cannot be fulfilled by Ĥ is
>> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
>> reports.
>>
>
> But the problem space ALLOWS that to happen, so it is valid.

*I have updated this reasoning*

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

Ĥ contradicts Ĥ.H and does not contradict H, thus H
is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.

H simply looks for whatever wrong answer that Ĥ.H
returns and reports on the halting or not halting
behavior of that.

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

On 2/29/24 11:30 PM, olcott wrote:
> On 2/29/2024 8:47 PM, Richard Damon wrote:
>> On 2/29/24 10:37 AM, olcott wrote:
>>> On 2/29/2024 4:31 AM, immibis wrote:
>>>> On 28/02/24 23:18, olcott wrote:
>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>> //
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>> not halt
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>> returns making Ĥ self-contradictory.
>>>>>
>>>>
>>>>
>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>> contradictory with its intended specification, which is not itself.
>>>
>>> The only reason that the specification cannot be fulfilled by Ĥ is
>>> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
>>> reports.
>>>
>>
>> But the problem space ALLOWS that to happen, so it is valid.
>
> *I have updated this reasoning*
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ contradicts Ĥ.H and does not contradict H, thus H
> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> H simply looks for whatever wrong answer that Ĥ.H
> returns and reports on the halting or not halting
> behavior of that.
>

Excpet that the fundamental property of Turing Machines is that since
Ĥ.H is a copy of the exact algorithm of H, that both will give the exact
same answer for the same input.

FUNDAMENTAL PROPERTY.

Your claiming otherwise just proves you are a ignorant pathological
lying idiot, that seems incapable of actually learning something true.

On 2/29/2024 10:41 PM, Richard Damon wrote:
> On 2/29/24 11:30 PM, olcott wrote:
>> On 2/29/2024 8:47 PM, Richard Damon wrote:
>>> On 2/29/24 10:37 AM, olcott wrote:
>>>> On 2/29/2024 4:31 AM, immibis wrote:
>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>> //
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>>> not halt
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>> returns making Ĥ self-contradictory.
>>>>>>
>>>>>
>>>>>
>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>>> contradictory with its intended specification, which is not itself.
>>>>
>>>> The only reason that the specification cannot be fulfilled by Ĥ is
>>>> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
>>>> reports.
>>>>
>>>
>>> But the problem space ALLOWS that to happen, so it is valid.
>>
>> *I have updated this reasoning*
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> H simply looks for whatever wrong answer that Ĥ.H
>> returns and reports on the halting or not halting
>> behavior of that.
>>
>
> Excpet that the fundamental property of Turing Machines is that since
> Ĥ.H is a copy of the exact algorithm of H, that both will give the exact
> same answer for the same input.
>

They are not the same machine Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ is always
contradicted and Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ is never contradicted.

If you believe that H is ever contradicted you
must show the detailed steps dogma carries no weight.

> FUNDAMENTAL PROPERTY.
>
> Your claiming otherwise just proves you are a ignorant pathological
> lying idiot, that seems incapable of actually learning something true.

--
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/1/24 1:47 AM, olcott wrote:
> On 2/29/2024 10:41 PM, Richard Damon wrote:
>> On 2/29/24 11:30 PM, olcott wrote:
>>> On 2/29/2024 8:47 PM, Richard Damon wrote:
>>>> On 2/29/24 10:37 AM, olcott wrote:
>>>>> On 2/29/2024 4:31 AM, immibis wrote:
>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>> //
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>> not halt
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>>>> contradictory with its intended specification, which is not itself.
>>>>>
>>>>> The only reason that the specification cannot be fulfilled by Ĥ is
>>>>> that Ĥ contradicts its own Ĥ.H by doing the opposite of whatever it
>>>>> reports.
>>>>>
>>>>
>>>> But the problem space ALLOWS that to happen, so it is valid.
>>>
>>> *I have updated this reasoning*
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ contradicts Ĥ.H and does not contradict H, thus H
>>> is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> H simply looks for whatever wrong answer that Ĥ.H
>>> returns and reports on the halting or not halting
>>> behavior of that.
>>>
>>
>> Excpet that the fundamental property of Turing Machines is that since
>> Ĥ.H is a copy of the exact algorithm of H, that both will give the
>> exact same answer for the same input.
>>
>
> They are not the same machine Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ is always
> contradicted and Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ is never contradicted.
>
> If you believe that H is ever contradicted you
> must show the detailed steps dogma carries no weight.

In other words, you think the same algorithm (Turing Machine) can give
different answers to the same input?

Or Determinism is non-Deterministic?

You prove your stupidity.

>
>
>> FUNDAMENTAL PROPERTY.
>>
>> Your claiming otherwise just proves you are a ignorant pathological
>> lying idiot, that seems incapable of actually learning something true.
>

Again, you don't understand this fundamental property.

On 3/1/2024 5:36 AM, Mikko wrote:
> On 2024-02-29 20:08:01 +0000, olcott said:
>
>> On 2/29/2024 1:28 PM, Mikko wrote:
>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>
>>>> On 28/02/24 23:18, olcott wrote:
>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>> //
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>> not halt
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>> returns making Ĥ self-contradictory.
>>>>
>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>> contradictory with its intended specification, which is not itself.
>>>
>>> There is no intended specification of Ĥ.
>>>
>>
>> Assuming that Peter Linz has a mind then he intended this specification
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Maybe he can but he doesn't.
>

His paper proves that he does. (page 3)
https://www.liarparadox.org/Linz_Proof.pdf

*Here is my notation of the Linz H that Ben verified on comp.theory*
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt

On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
>
> Linz tells us that "<M> w" is accepted by H
> (i.e. H transitions to qy) if M halts on input w.
> Therefore Linz is telling us that H accepts "<H> <H>"
> if H applied to <H> halts. All PO has done is
> substitute H for M and <H> for w. That's valid,
> even in Linz's rather vague notion of the exact
> strings involved. M is any TM, so substituting H
> (were it to exist) is a reasonable thing to do.
> And w can be any string, so there is nothing to
> stop PO substituting <H> for w.

--
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/1/24 12:24 PM, olcott wrote:
> On 3/1/2024 5:36 AM, Mikko wrote:
>> On 2024-02-29 20:08:01 +0000, olcott said:
>>
>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>
>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>> //
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>>> not halt
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>> returns making Ĥ self-contradictory.
>>>>>
>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>>> contradictory with its intended specification, which is not itself.
>>>>
>>>> There is no intended specification of Ĥ.
>>>>
>>>
>>> Assuming that Peter Linz has a mind then he intended this specification
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Maybe he can but he doesn't.
>>
>
> His paper proves that he does. (page 3)
> https://www.liarparadox.org/Linz_Proof.pdf
>
> *Here is my notation of the Linz H that Ben verified on comp.theory*
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt

Note, the comments you have are the conditions that carry over from H,
not the specifications on H^.

The "Specification" on H^ is that it:
1) Duplicates its input on the tape
2) Uses its copy of H to determine what H will decide about this input
3) Then do the opposite of that decision.

The criteria you list are from the specification of H.

H^ isn't correct/incorrect based on its answer, just fulfilles its
specification by doing the opposite of what H says the input would do.

Note, H^ doesn't even know if the input represents itself, but its
acting contray when it does happens to show that H (if we put in a
realization of some claimed decider) can not be a correct halt decider.

You don't seem to understand the meaning of specifications, or how the
ASSUMPTION of something existing propagates requirements.

THe specificataion for H^ would be:

H^ (P) goes to qy, and loops forever if H (P) (P) goes to qy and
predicts that P (P) will halt

H^ (P) goes to qn, and halts, if H (P) (P) goes to qn and predicts that
P (P) will never halt

Only by propagating the specification of H, by assuming that H meets its
specification, (which the proof does) do you get you comments.

>
> On 2/18/2024 5:47 PM, Ben Bacarisse wrote:
> >
> > Linz tells us that "<M> w" is accepted by H
> > (i.e. H transitions to qy) if M halts on input w.
> > Therefore Linz is telling us that H accepts "<H> <H>"
> > if H applied to <H> halts.  All PO has done is
> > substitute H for M and <H> for w.  That's valid,
> > even in Linz's rather vague notion of the exact
> > strings involved.  M is any TM, so substituting H
> > (were it to exist) is a reasonable thing to do.
> > And w can be any string, so there is nothing to
> > stop PO substituting <H> for w.
>
>
>

On 3/1/2024 11:44 AM, Richard Damon wrote:
> On 3/1/24 12:24 PM, olcott wrote:
>> On 3/1/2024 5:36 AM, Mikko wrote:
>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>
>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>
>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>> //
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>> not halt
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>> returns making Ĥ self-contradictory.
>>>>>>
>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is only
>>>>>> contradictory with its intended specification, which is not itself.
>>>>>
>>>>> There is no intended specification of Ĥ.
>>>>>
>>>>
>>>> Assuming that Peter Linz has a mind then he intended this specification
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Maybe he can but he doesn't.
>>>
>>
>> His paper proves that he does. (page 3)
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>
> Note, the comments you have are the conditions that carry over from H,
> not the specifications on H^.
>
> The "Specification" on H^ is that it:
> 1) Duplicates its input on the tape
> 2) Uses its copy of H to determine what H will decide about this input

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

Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
on its input it has no access to and cannot in any way
effect or examine the return values of the external 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/1/24 3:41 PM, olcott wrote:
> On 3/1/2024 11:44 AM, Richard Damon wrote:
>> On 3/1/24 12:24 PM, olcott wrote:
>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>
>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>
>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>>> //
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>
>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is
>>>>>>> only contradictory with its intended specification, which is not
>>>>>>> itself.
>>>>>>
>>>>>> There is no intended specification of Ĥ.
>>>>>>
>>>>>
>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>> specification
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Maybe he can but he doesn't.
>>>>
>>>
>>> His paper proves that he does. (page 3)
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>
>> Note, the comments you have are the conditions that carry over from H,
>> not the specifications on H^.
>>
>> The "Specification" on H^ is that it:
>> 1) Duplicates its input on the tape
>> 2) Uses its copy of H to determine what H will decide about this input
>
> Wrong.
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
> on its input it has no access to and cannot in any way
> effect or examine the return values of the external H.
>

Except for the FACT that all H's return the same value when given the
same input.

You don't seem to believe that Truth Actually exists.

And are just proving your utter stupidity and ignorance of what you talk
about.

On 3/1/2024 3:00 PM, Richard Damon wrote:
> On 3/1/24 3:41 PM, olcott wrote:
>> On 3/1/2024 11:44 AM, Richard Damon wrote:
>>> On 3/1/24 12:24 PM, olcott wrote:
>>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>>
>>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>>
>>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>>>> //
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> does not halt
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>
>>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is
>>>>>>>> only contradictory with its intended specification, which is not
>>>>>>>> itself.
>>>>>>>
>>>>>>> There is no intended specification of Ĥ.
>>>>>>>
>>>>>>
>>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>>> specification
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> Maybe he can but he doesn't.
>>>>>
>>>>
>>>> His paper proves that he does. (page 3)
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>
>>> Note, the comments you have are the conditions that carry over from
>>> H, not the specifications on H^.
>>>
>>> The "Specification" on H^ is that it:
>>> 1) Duplicates its input on the tape
>>> 2) Uses its copy of H to determine what H will decide about this input
>>
>> Wrong.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
>> on its input it has no access to and cannot in any way
>> effect or examine the return values of the external H.
>>
>
> Except for the FACT that all H's return the same value when given the
> same input.
>

Not when one of them can wait and see what the other one said.
The self contradictory input is a toggle just like the Liar Paradox.
Thus the outer H will report the opposite of what the inner one
reported.

"This sentence is not true"
is not true
which makes it true
which makes it not true

With the halting problem this may only go two levels:
H reporting on the behavior of Ĥ.H.
There are no more levels of toggling because H is not contradicted.

--
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/1/24 5:45 PM, olcott wrote:
> On 3/1/2024 3:00 PM, Richard Damon wrote:
>> On 3/1/24 3:41 PM, olcott wrote:
>>> On 3/1/2024 11:44 AM, Richard Damon wrote:
>>>> On 3/1/24 12:24 PM, olcott wrote:
>>>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>>>
>>>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>>>
>>>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt decider
>>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>>>>> //
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>> does not halt
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>>
>>>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is
>>>>>>>>> only contradictory with its intended specification, which is
>>>>>>>>> not itself.
>>>>>>>>
>>>>>>>> There is no intended specification of Ĥ.
>>>>>>>>
>>>>>>>
>>>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>>>> specification
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Maybe he can but he doesn't.
>>>>>>
>>>>>
>>>>> His paper proves that he does. (page 3)
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>
>>>> Note, the comments you have are the conditions that carry over from
>>>> H, not the specifications on H^.
>>>>
>>>> The "Specification" on H^ is that it:
>>>> 1) Duplicates its input on the tape
>>>> 2) Uses its copy of H to determine what H will decide about this input
>>>
>>> Wrong.
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
>>> on its input it has no access to and cannot in any way
>>> effect or examine the return values of the external H.
>>>
>>
>> Except for the FACT that all H's return the same value when given the
>> same input.
>>
>
> Not when one of them can wait and see what the other one said.
> The self contradictory input is a toggle just like the Liar Paradox.
> Thus the outer H will report the opposite of what the inner one
> reported.

How does it wait longer than the version that H^ uses? If it tries to
wait out the version that H^ uses, then the one that H^ uses will wait
out the one that its simulation uses, and no one answers.

>
> "This sentence is not true"
> is not true
> which makes it true
> which makes it not true
>
> With the halting problem this may only go two levels:

Why? The H^.H faces exactly the same question, and will do exactly the
same thing.

Or, you are just admitting that you are an ignorant Pathological Liar.

> H reporting on the behavior of Ĥ.H.
> There are no more levels of toggling because H is not contradicted.
>

But the H that H^ calls will simulate its input, and will wait for it to
finish.

You get to the quesiton,

is 1 + 1 + 1 + 1 ... even or odd?

On 3/1/2024 5:39 PM, Richard Damon wrote:
> On 3/1/24 5:45 PM, olcott wrote:
>> On 3/1/2024 3:00 PM, Richard Damon wrote:
>>> On 3/1/24 3:41 PM, olcott wrote:
>>>> On 3/1/2024 11:44 AM, Richard Damon wrote:
>>>>> On 3/1/24 12:24 PM, olcott wrote:
>>>>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>>>>
>>>>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>>>>
>>>>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt
>>>>>>>>>>> decider
>>>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy state
>>>>>>>>>>> //
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> does not halt
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>>>
>>>>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is
>>>>>>>>>> only contradictory with its intended specification, which is
>>>>>>>>>> not itself.
>>>>>>>>>
>>>>>>>>> There is no intended specification of Ĥ.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>>>>> specification
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>
>>>>>>> Maybe he can but he doesn't.
>>>>>>>
>>>>>>
>>>>>> His paper proves that he does. (page 3)
>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>
>>>>>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>
>>>>> Note, the comments you have are the conditions that carry over from
>>>>> H, not the specifications on H^.
>>>>>
>>>>> The "Specification" on H^ is that it:
>>>>> 1) Duplicates its input on the tape
>>>>> 2) Uses its copy of H to determine what H will decide about this input
>>>>
>>>> Wrong.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
>>>> on its input it has no access to and cannot in any way
>>>> effect or examine the return values of the external H.
>>>>
>>>
>>> Except for the FACT that all H's return the same value when given the
>>> same input.
>>>
>>
>> Not when one of them can wait and see what the other one said.
>> The self contradictory input is a toggle just like the Liar Paradox.
>> Thus the outer H will report the opposite of what the inner one
>> reported.
>
> How does it wait longer than the version that H^ uses?

H cannot see that there is a reason to abort its own simulation
and Ĥ.H can see that there is a reason to abort its own simulation.

Because Mike verified that a UTM can pass a portion of its own tape
to its simulated machine this means that the inner instances of Ĥ.H
can pass their execution trace data back up to the outermost Ĥ.H.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specifies nested simulation that is matched by the
infinite recursion behavior pattern.

H ⟨Ĥ⟩ ⟨Ĥ⟩ does not specify the nested simulation.

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

On 2024-03-01 17:07, olcott wrote:

> Because Mike verified that a UTM can pass a portion of its own tape
> to its simulated machine this means that the inner instances of Ĥ.H
> can pass their execution trace data back up to the outermost Ĥ.H.

You need to read your responses more carefully. This is precisely what
Mike states you CANNOT do.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 3/1/2024 7:12 PM, André G. Isaak wrote:
> On 2024-03-01 17:07, olcott wrote:
>
>> Because Mike verified that a UTM can pass a portion of its own tape
>> to its simulated machine this means that the inner instances of Ĥ.H
>> can pass their execution trace data back up to the outermost Ĥ.H.
>
> You need to read your responses more carefully. This is precisely what
> Mike states you CANNOT do.
>
> André
>

*I am very surprised that you got this wrong*
I am however very happy that you are reviewing my work.

On 3/1/2024 12:41 PM, Mike Terry wrote:
> On 01/03/2024 17:55, olcott wrote:
>> ... The original H was renamed to HH.
>> Because a UTM actually can share a portion of its own
>> tape with the machine it is simulating HH may actually
>> be the preferred version.
>
> Obviously a simulator has access to the internal state
> (tape contents etc.) of the simulated machine. No
> problem there.
>
> What isn't allowed is the simulated machine altering its
> own behaviour by accessing data outside of its own state.
> (I.e. accessing data from its parent simulators state.)

--
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/1/24 7:07 PM, olcott wrote:
> On 3/1/2024 5:39 PM, Richard Damon wrote:
>> On 3/1/24 5:45 PM, olcott wrote:
>>> On 3/1/2024 3:00 PM, Richard Damon wrote:
>>>> On 3/1/24 3:41 PM, olcott wrote:
>>>>> On 3/1/2024 11:44 AM, Richard Damon wrote:
>>>>>> On 3/1/24 12:24 PM, olcott wrote:
>>>>>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>>>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>>>>>
>>>>>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt
>>>>>>>>>>>> decider
>>>>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not halt
>>>>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy
>>>>>>>>>>>> state
>>>>>>>>>>>> //
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>> does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that Ĥ.H
>>>>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>>>>
>>>>>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ is
>>>>>>>>>>> only contradictory with its intended specification, which is
>>>>>>>>>>> not itself.
>>>>>>>>>>
>>>>>>>>>> There is no intended specification of Ĥ.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>>>>>> specification
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Maybe he can but he doesn't.
>>>>>>>>
>>>>>>>
>>>>>>> His paper proves that he does. (page 3)
>>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>>
>>>>>>> *Here is my notation of the Linz H that Ben verified on comp.theory*
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>>
>>>>>> Note, the comments you have are the conditions that carry over
>>>>>> from H, not the specifications on H^.
>>>>>>
>>>>>> The "Specification" on H^ is that it:
>>>>>> 1) Duplicates its input on the tape
>>>>>> 2) Uses its copy of H to determine what H will decide about this
>>>>>> input
>>>>>
>>>>> Wrong.
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
>>>>> on its input it has no access to and cannot in any way
>>>>> effect or examine the return values of the external H.
>>>>>
>>>>
>>>> Except for the FACT that all H's return the same value when given
>>>> the same input.
>>>>
>>>
>>> Not when one of them can wait and see what the other one said.
>>> The self contradictory input is a toggle just like the Liar Paradox.
>>> Thus the outer H will report the opposite of what the inner one
>>> reported.
>>
>> How does it wait longer than the version that H^ uses?
>
> H cannot see that there is a reason to abort its own simulation
> and Ĥ.H can see that there is a reason to abort its own simulation.

What instruction in H gets a difference between the two cases?

Same Machine code, same input, every step will be the same.

>
> Because Mike verified that a UTM can pass a portion of its own tape
> to its simulated machine this means that the inner instances of Ĥ.H
> can pass their execution trace data back up to the outermost Ĥ.H.

No, it can NOT. It can use part of the tape for its own purposes, but
the simulated machine can have no access to that, as it doesn't exist
when the machine is run not under simulation.

You are just being STUPID again, proving you don't understand even the
basics of what you are talking about and obvious errors just go above
your head.

>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specifies nested simulation that is matched by the
> infinite recursion behavior pattern.
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ does not specify the nested simulation.
>
>

Nope, both specify EXACTLY the same thing,
the behavior of H^ applied to (H^).

You are just proving your utter stupidity again, showing yourself to be
just a pathological liar since you have nothing to compare with to
understand what is true.

You have been told this, and ignored it, showing it isn't an "Inocent
Mistake" but a deliberate action.

On 3/1/2024 8:15 PM, Richard Damon wrote:
> On 3/1/24 7:07 PM, olcott wrote:
>> On 3/1/2024 5:39 PM, Richard Damon wrote:
>>> On 3/1/24 5:45 PM, olcott wrote:
>>>> On 3/1/2024 3:00 PM, Richard Damon wrote:
>>>>> On 3/1/24 3:41 PM, olcott wrote:
>>>>>> On 3/1/2024 11:44 AM, Richard Damon wrote:
>>>>>>> On 3/1/24 12:24 PM, olcott wrote:
>>>>>>>> On 3/1/2024 5:36 AM, Mikko wrote:
>>>>>>>>> On 2024-02-29 20:08:01 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 2/29/2024 1:28 PM, Mikko wrote:
>>>>>>>>>>> On 2024-02-29 10:31:13 +0000, immibis said:
>>>>>>>>>>>
>>>>>>>>>>>> On 28/02/24 23:18, olcott wrote:
>>>>>>>>>>>>> // Ĥ.q0 ⟨Ĥ⟩ copies its input then transitions to Ĥ.Hq0
>>>>>>>>>>>>> // Ĥ.Hq0 is the first state of The Linz hypothetical halt
>>>>>>>>>>>>> decider
>>>>>>>>>>>>> // H transitions to Ĥ.Hqy for halts and Ĥ.Hqn for does not
>>>>>>>>>>>>> halt
>>>>>>>>>>>>> // ∞ means an infinite loop has been appended to the Ĥ.Hqy
>>>>>>>>>>>>> state
>>>>>>>>>>>>> //
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy  ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn      // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩ it contradicts whatever value that
>>>>>>>>>>>>> Ĥ.H
>>>>>>>>>>>>> returns making Ĥ self-contradictory.
>>>>>>>>>>>>
>>>>>>>>>>>> Turing machine/input pairs are never self-contradictory. Ĥ
>>>>>>>>>>>> is only contradictory with its intended specification, which
>>>>>>>>>>>> is not itself.
>>>>>>>>>>>
>>>>>>>>>>> There is no intended specification of Ĥ.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Assuming that Peter Linz has a mind then he intended this
>>>>>>>>>> specification
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>> not halt
>>>>>>>>>
>>>>>>>>> Maybe he can but he doesn't.
>>>>>>>>>
>>>>>>>>
>>>>>>>> His paper proves that he does. (page 3)
>>>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>>>
>>>>>>>> *Here is my notation of the Linz H that Ben verified on
>>>>>>>> comp.theory*
>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
>>>>>>>> H.q0 ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>>>>>>>
>>>>>>> Note, the comments you have are the conditions that carry over
>>>>>>> from H, not the specifications on H^.
>>>>>>>
>>>>>>> The "Specification" on H^ is that it:
>>>>>>> 1) Duplicates its input on the tape
>>>>>>> 2) Uses its copy of H to determine what H will decide about this
>>>>>>> input
>>>>>>
>>>>>> Wrong.
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Ĥ applied to ⟨Ĥ⟩ uses Ĥ.H to determine what Ĥ.H will do
>>>>>> on its input it has no access to and cannot in any way
>>>>>> effect or examine the return values of the external H.
>>>>>>
>>>>>
>>>>> Except for the FACT that all H's return the same value when given
>>>>> the same input.
>>>>>
>>>>
>>>> Not when one of them can wait and see what the other one said.
>>>> The self contradictory input is a toggle just like the Liar Paradox.
>>>> Thus the outer H will report the opposite of what the inner one
>>>> reported.
>>>
>>> How does it wait longer than the version that H^ uses?
>>
>> H cannot see that there is a reason to abort its own simulation
>> and Ĥ.H can see that there is a reason to abort its own simulation.
>
> What instruction in H gets a difference between the two cases?
>
> Same Machine code, same input, every step will be the same.
>

H sees that D is calling its own machine address.
H1 does not see that D is calling its own machine address.

HH(DD,DD) sees that its simulation of DD results in
a repeated state exactly like infinite recursion.

>>
>> Because Mike verified that a UTM can pass a portion of its own tape
>> to its simulated machine this means that the inner instances of Ĥ.H
>> can pass their execution trace data back up to the outermost Ĥ.H.
>
> No, it can NOT. It can use part of the tape for its own purposes, but
> the simulated machine can have no access to that, as it doesn't exist
> when the machine is run not under simulation.

On 3/1/2024 12:41 PM, Mike Terry wrote:
> On 01/03/2024 17:55, olcott wrote:
>> ... The original H was renamed to HH.
>> Because a UTM actually can share a portion of its own
>> tape with the machine it is simulating HH may actually
>> be the preferred version.
>
> Obviously a simulator has access to the internal state
> (tape contents etc.) of the simulated machine. No
> problem there.
>
> What isn't allowed is the simulated machine altering its
> own behaviour by accessing data outside of its own state.
> (I.e. accessing data from its parent simulators state.)

> You are just being STUPID again, proving you don't understand even the
> basics of what you are talking about and obvious errors just go above
> your head.
>
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specifies nested simulation that is matched by the
>> infinite recursion behavior pattern.
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ does not specify the nested simulation.
>>
>>
>
> Nope, both specify EXACTLY the same thing,
> the behavior of H^ applied to (H^).
>
> You are just proving your utter stupidity again, showing yourself to be
> just a pathological liar since you have nothing to compare with to
> understand what is true.
>
> You have been told this, and ignored it, showing it isn't an "Inocent
> Mistake" but a deliberate action.

When all you have for rebuttal is insults and dogma
I know that I proved my point.

I proved that you are factually incorrect about what
Mike said. I expect that you will probably acknowledge
this.

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