H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt

Because H is required to always halt we can know that
Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
thus H merely needs to report on that.

// Ĥ.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 6:46 PM, olcott wrote:
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>
> Because H is required to always halt we can know that
> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
> thus H merely needs to report on that.
>
> // Ĥ.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 6:46 PM, olcott wrote:
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>
>> Because H is required to always halt we can know that
>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>> thus H merely needs to report on that.
>>
>> // Ĥ.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.

In the same way that D did not contradict H1
Ĥ does not contradict H. Ĥ only contradicts its own
internal copy of Ĥ.H, this has no effect on the actual H
which has no reason to get the wrong answer.

If H goes by the rule: *if you can't correctly say yes then say no*
then H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ would correctly transition to H.qy as
soon as H sees Ĥ.Hq0 transition to Ĥ.Hqn.

Even though H goes by a heuristic that in theory can provide
an answer that does not correspond to the behavior of its
input in practice there may be no actual examples of this.

Thus even the heuristic: *if you can't correctly say yes then say no*
would always mean that "no" means the input does not halt for any input
to the actual H itself.

--
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 7:47 PM, olcott wrote:
> On 2/28/2024 6:27 PM, Richard Damon wrote:
>> On 2/28/24 6:46 PM, olcott wrote:
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>
>>> Because H is required to always halt we can know that
>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>> thus H merely needs to report on that.
>>>
>>> // Ĥ.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.
>
> In the same way that D did not contradict H1
> Ĥ does not contradict H. Ĥ only contradicts its own
> internal copy of Ĥ.H, this has no effect on the actual H
> which has no reason to get the wrong answer.

No, it contraidicts ALL copies of H.

The fact that H1 gives a different answer then H shows that it is a
different computaiton (if they are computations at all).

>
> If H goes by the rule: *if you can't correctly say yes then say no*
> then H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ would correctly transition to H.qy as
> soon as H sees Ĥ.Hq0 transition to Ĥ.Hqn.

But that isn't a computable rule, and you are just proving your
stupidity, and that you are just a ignorant pathological liar.

>
> Even though H goes by a heuristic that in theory can provide
> an answer that does not correspond to the behavior of its
> input in practice there may be no actual examples of this.

H, to be a computation, must go by an ALGORITHM. A fixed set of steps
(possible with conditional branches) based solely on the input, and
values computated from that input.

"Heuristics" tend to not be well enough defined to be an algorithm that
always gets the right answer.

>
> Thus even the heuristic: *if you can't correctly say yes then say no*
> would always mean that "no" means the input does not halt for any input
> to the actual H itself.
>

Yes, that is the problem with a Heuristic. Just because it didn't find a
right answer doesn't normally show that there isn't one. It tends to be
a non-exhaustive search over a space, ruling out a number of
possibilities, but still leaving a lot of esoteric cases left, which
could have either answer.

They can be starting points to see if you get a quick lucky answer, or
maybe get you a probable good starting point.

On 2/28/2024 9:06 PM, Richard Damon wrote:
> On 2/28/24 7:47 PM, olcott wrote:
>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>> On 2/28/24 6:46 PM, olcott wrote:
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>
>>>> Because H is required to always halt we can know that
>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>> thus H merely needs to report on that.
>>>>
>>>> // Ĥ.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.
>>
>> In the same way that D did not contradict H1
>> Ĥ does not contradict H. Ĥ only contradicts its own
>> internal copy of Ĥ.H, this has no effect on the actual H
>> which has no reason to get the wrong answer.
>
> No, it contraidicts ALL copies of H.
>
> The fact that H1 gives a different answer then H shows that it is a
> different computaiton (if they are computations at all).
>

Ĥ only contradicts its own internal Ĥ.H and can have no effect
on the external H.

>>
>> If H goes by the rule: *if you can't correctly say yes then say no*
>> then H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ would correctly transition to H.qy as
>> soon as H sees Ĥ.Hq0 transition to Ĥ.Hqn.
>
> But that isn't a computable rule, and you are just proving your
> stupidity, and that you are just a ignorant pathological liar.
>

Linz calls this a membership algorithm. Because Ĥ.Hq0 gets the
wrong answer this causes H to get the correct answer.

*As soon as any H determines that YES is the wrong answer it says NO*
This causes Ĥ.Hq0 to get the wrong answer that causes H to get the
correct answer.

*It has always been a toggle for each recursive invocation*
"This sentence is not true" is not true
that makes it true
that makes it not true
that makes it not not true (AKA true)

Ĥ.Hq0 gets the wrong answer
that causes H to get the right answer.

--
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 10:54 PM, olcott wrote:
> On 2/28/2024 9:06 PM, Richard Damon wrote:
>> On 2/28/24 7:47 PM, olcott wrote:
>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Because H is required to always halt we can know that
>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>> thus H merely needs to report on that.
>>>>>
>>>>> // Ĥ.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.
>>>
>>> In the same way that D did not contradict H1
>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>> internal copy of Ĥ.H, this has no effect on the actual H
>>> which has no reason to get the wrong answer.
>>
>> No, it contraidicts ALL copies of H.
>>
>> The fact that H1 gives a different answer then H shows that it is a
>> different computaiton (if they are computations at all).
>>
>
> Ĥ only contradicts its own internal Ĥ.H and can have no effect
> on the external H.

But the MUST act the same.

If you disagree, then you are admitting that you don't understand what a
computation actually is.

>
>>>
>>> If H goes by the rule: *if you can't correctly say yes then say no*
>>> then H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ would correctly transition to H.qy as
>>> soon as H sees Ĥ.Hq0 transition to Ĥ.Hqn.
>>
>> But that isn't a computable rule, and you are just proving your
>> stupidity, and that you are just a ignorant pathological liar.
>>
>
> Linz calls this a membership algorithm. Because Ĥ.Hq0 gets the
> wrong answer this causes H to get the correct answer.

How? All copies of H are identical, and thus all do the same thing.

>
> *As soon as any H determines that YES is the wrong answer it says NO*
> This causes Ĥ.Hq0 to get the wrong answer that causes H to get the
> correct answer.

How?

H is a SPECIFIC machine, thus all copies behav ethe sme

>
> *It has always been a toggle for each recursive invocation*
> "This sentence is not true" is not true
> that makes it true
> that makes it not true
> that makes it not not true (AKA true)
>
> Ĥ.Hq0 gets the wrong answer
> that causes H to get the right answer.
>

Your smoking something.

I don't thibk you are quoting Linz right, and are just back to your
pathologival lies again.

On 2/28/2024 10:12 PM, Richard Damon wrote:
> On 2/28/24 10:54 PM, olcott wrote:
>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>> On 2/28/24 7:47 PM, olcott wrote:
>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Because H is required to always halt we can know that
>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>> thus H merely needs to report on that.
>>>>>>
>>>>>> // Ĥ.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.
>>>>
>>>> In the same way that D did not contradict H1
>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>> which has no reason to get the wrong answer.
>>>
>>> No, it contraidicts ALL copies of H.
>>>
>>> The fact that H1 gives a different answer then H shows that it is a
>>> different computaiton (if they are computations at all).
>>>
>>
>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>> on the external H.
>
> But the MUST act the same.
>
> If you disagree, then you are admitting that you don't understand what a
> computation actually is.
>

The exact same way that H1 gets the correct answer on D
even when H1 is a verbatim identical copy of H and it
is the very same D in both cases H would get a correct
answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.

When the machine language of H and H1 are identical and
they both process the same machine language of D then
the fact that H1 and H are in a different memory space
is the same as Linz H and Ĥ.H are in a different memory
space such that neither H1 nor Linz H can be contradicted
by its input.

*I think that we may be finally getting to closure on this*

--
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 00:46, olcott wrote:
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>
> Because H is required to always halt we can know that
> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
> thus H merely needs to report on that.
>
> // Ĥ.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.
>

If it's self-contradictory how can it get the correct answer?

On 29/02/24 01:47, olcott wrote:
> In the same way that D did not contradict H1
> Ĥ does not contradict H. Ĥ only contradicts its own
> internal copy of Ĥ.H, this has no effect on the actual H
> which has no reason to get the wrong answer.

It is impossible for a copy of H to get a different result than H.

On 2/28/24 11:26 PM, olcott wrote:
> On 2/28/2024 10:12 PM, Richard Damon wrote:
>> On 2/28/24 10:54 PM, olcott wrote:
>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> Because H is required to always halt we can know that
>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>> thus H merely needs to report on that.
>>>>>>>
>>>>>>> // Ĥ.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.
>>>>>
>>>>> In the same way that D did not contradict H1
>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>> which has no reason to get the wrong answer.
>>>>
>>>> No, it contraidicts ALL copies of H.
>>>>
>>>> The fact that H1 gives a different answer then H shows that it is a
>>>> different computaiton (if they are computations at all).
>>>>
>>>
>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>> on the external H.
>>
>> But the MUST act the same.
>>
>> If you disagree, then you are admitting that you don't understand what
>> a computation actually is.
>>
>
> The exact same way that H1 gets the correct answer on D
> even when H1 is a verbatim identical copy of H and it
> is the very same D in both cases H would get a correct
> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>

Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
Equivalent (TME) sense, in part because your H isn't a TME of the H
descirbed, becausee it takes and processes its input in an incorrect
manner.

> When the machine language of H and H1 are identical and
> they both process the same machine language of D then
> the fact that H1 and H are in a different memory space
> is the same as Linz H and Ĥ.H are in a different memory
> space such that neither H1 nor Linz H can be contradicted
> by its input.

Except they use a hidden input, and thus are not Computations.

>
> *I think that we may be finally getting to closure on this*
>

You think your startig to understand how you are wrong?

I don't think so, the way you said it, but we will see.

So far you are just continuing to prove that you are just the same
ignorant pathological lying idiot you have revealed yourself to be over
the last decades.

On 2/28/2024 10:26 PM, olcott wrote:
> On 2/28/2024 10:12 PM, Richard Damon wrote:
>> On 2/28/24 10:54 PM, olcott wrote:
>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> Because H is required to always halt we can know that
>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>> thus H merely needs to report on that.
>>>>>>>
>>>>>>> // Ĥ.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.
>>>>>
>>>>> In the same way that D did not contradict H1
>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>> which has no reason to get the wrong answer.
>>>>
>>>> No, it contraidicts ALL copies of H.
>>>>
>>>> The fact that H1 gives a different answer then H shows that it is a
>>>> different computaiton (if they are computations at all).
>>>>
>>>
>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>> on the external H.
>>
>> But the MUST act the same.
>>
>> If you disagree, then you are admitting that you don't understand what
>> a computation actually is.
>>
>
> The exact same way that H1 gets the correct answer on D
> even when H1 is a verbatim identical copy of H and it
> is the very same D in both cases H would get a correct
> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>
> When the machine language of H and H1 are identical and
> they both process the same machine language of D then
> the fact that H1 and H are in a different memory space
> is the same as Linz H and Ĥ.H are in a different memory
> space such that neither H1 nor Linz H can be contradicted
> by its input.
>
> *I think that we may be finally getting to closure on this*
>
test2
--
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/2024 4:51 AM, immibis wrote:
> On 29/02/24 00:46, olcott wrote:
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>
>> Because H is required to always halt we can know that
>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>> thus H merely needs to report on that.
>>
>> // Ĥ.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.
>>
>
> If it's self-contradictory how can it get the correct answer?

Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩
Is self contradictory thus answers NO whenever YES is the wrong answer.

H ⟨Ĥ⟩ ⟨Ĥ⟩
Is in a different memory space and can see that Ĥ.Hq0 answers NO
thus answers YES

--
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/2024 4:55 AM, immibis wrote:
> On 29/02/24 01:47, olcott wrote:
>> In the same way that D did not contradict H1
>> Ĥ does not contradict H. Ĥ only contradicts its own
>> internal copy of Ĥ.H, this has no effect on the actual H
>> which has no reason to get the wrong answer.
>
> It is impossible for a copy of H to get a different result than H.
>

Because *H and Ĥ are in different memory spaces* Ĥ can only
contradict itself and cannot contradict H. H and Ĥ.H always
only report on what they see. Ĥ.H sees that YES is the wrong
answer so it says NO by default. H sees that Ĥ said NO so it
says YES.

--
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/2024 6:32 AM, Richard Damon wrote:
> On 2/28/24 11:26 PM, olcott wrote:
>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>> On 2/28/24 10:54 PM, olcott wrote:
>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>
>>>>>>>> Because H is required to always halt we can know that
>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>> thus H merely needs to report on that.
>>>>>>>>
>>>>>>>> // Ĥ.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.
>>>>>>
>>>>>> In the same way that D did not contradict H1
>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>> which has no reason to get the wrong answer.
>>>>>
>>>>> No, it contraidicts ALL copies of H.
>>>>>
>>>>> The fact that H1 gives a different answer then H shows that it is a
>>>>> different computaiton (if they are computations at all).
>>>>>
>>>>
>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>> on the external H.
>>>
>>> But the MUST act the same.
>>>
>>> If you disagree, then you are admitting that you don't understand
>>> what a computation actually is.
>>>
>>
>> The exact same way that H1 gets the correct answer on D
>> even when H1 is a verbatim identical copy of H and it
>> is the very same D in both cases H would get a correct
>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>
>
> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
> Equivalent (TME) sense, in part because your H isn't a TME of the H
> descirbed, becausee it takes and processes its input in an incorrect
> manner.
>

What are all of the details of the "incorrect manner" that you are
referring to?

>> When the machine language of H and H1 are identical and
>> they both process the same machine language of D then
>> the fact that H1 and H are in a different memory space
>> is the same as Linz H and Ĥ.H are in a different memory
>> space such that neither H1 nor Linz H can be contradicted
>> by its input.
>
> Except they use a hidden input, and thus are not Computations.

The simple fact that H and Ĥ.H are in different memory spaces makes it
impossible for Ĥ to contradict H. When we hypothesize that H is based
on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.

--
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 15:58, olcott wrote:
> On 2/29/2024 6:32 AM, Richard Damon wrote:
>> On 2/28/24 11:26 PM, olcott wrote:
>>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>>> On 2/28/24 10:54 PM, olcott wrote:
>>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>>
>>>>>>>>> Because H is required to always halt we can know that
>>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>>> thus H merely needs to report on that.
>>>>>>>>>
>>>>>>>>> // Ĥ.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.
>>>>>>>
>>>>>>> In the same way that D did not contradict H1
>>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>>> which has no reason to get the wrong answer.
>>>>>>
>>>>>> No, it contraidicts ALL copies of H.
>>>>>>
>>>>>> The fact that H1 gives a different answer then H shows that it is
>>>>>> a different computaiton (if they are computations at all).
>>>>>>
>>>>>
>>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>>> on the external H.
>>>>
>>>> But the MUST act the same.
>>>>
>>>> If you disagree, then you are admitting that you don't understand
>>>> what a computation actually is.
>>>>
>>>
>>> The exact same way that H1 gets the correct answer on D
>>> even when H1 is a verbatim identical copy of H and it
>>> is the very same D in both cases H would get a correct
>>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>>
>>
>> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
>> Equivalent (TME) sense, in part because your H isn't a TME of the H
>> descirbed, becausee it takes and processes its input in an incorrect
>> manner.
>>
>
> What are all of the details of the "incorrect manner" that you are
> referring to?

There is a global variable which stores the execution log which is
secretly passed from parent machine to child machine in the simulation.
Turing machines don't have global variables that are secretly passed
from one machine to another. Every step of TM execution looks for the
same step already existing in the execution log. This causes one
execution of a "TM" to differ from another which is impossible for an
actual TM.

>
>>> When the machine language of H and H1 are identical and
>>> they both process the same machine language of D then
>>> the fact that H1 and H are in a different memory space
>>> is the same as Linz H and Ĥ.H are in a different memory
>>> space such that neither H1 nor Linz H can be contradicted
>>> by its input.
>>
>> Except they use a hidden input, and thus are not Computations.
>
> The simple fact that H and Ĥ.H are in different memory spaces makes it
> impossible for Ĥ to contradict H. When we hypothesize that H is based
> on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.
>

In your code, Ĥ ⟨Ĥ⟩ halts but H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn which is
incorrect according to the specification.

On 29/02/24 15:48, olcott wrote:
> On 2/29/2024 4:55 AM, immibis wrote:
>> On 29/02/24 01:47, olcott wrote:
>>> In the same way that D did not contradict H1
>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>> internal copy of Ĥ.H, this has no effect on the actual H
>>> which has no reason to get the wrong answer.
>>
>> It is impossible for a copy of H to get a different result than H.
>>
>
> Because *H and Ĥ are in different memory spaces* Ĥ can only
> contradict itself and cannot contradict H. H and Ĥ.H always
> only report on what they see. Ĥ.H sees that YES is the wrong
> answer so it says NO by default. H sees that Ĥ said NO so it
> says YES.
>

It is impossible for a copy of H to get a different result than H.

On 29/02/24 15:42, olcott wrote:
> On 2/29/2024 4:51 AM, immibis wrote:
>> On 29/02/24 00:46, olcott wrote:
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>
>>> Because H is required to always halt we can know that
>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>> thus H merely needs to report on that.
>>>
>>> // Ĥ.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.
>>>
>>
>> If it's self-contradictory how can it get the correct answer?
>
> Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩
> Is self contradictory thus answers NO whenever YES is the wrong answer.
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩
> Is in a different memory space and can see that Ĥ.Hq0 answers NO
> thus answers YES
>
There is no such thing as a memory space when we are talking about
Turing machines.

On 2/29/2024 9:42 AM, immibis wrote:
> On 29/02/24 15:58, olcott wrote:
>> On 2/29/2024 6:32 AM, Richard Damon wrote:
>>> On 2/28/24 11:26 PM, olcott wrote:
>>>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>>>> On 2/28/24 10:54 PM, olcott wrote:
>>>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>>>
>>>>>>>>>> Because H is required to always halt we can know that
>>>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>>>> thus H merely needs to report on that.
>>>>>>>>>>
>>>>>>>>>> // Ĥ.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.
>>>>>>>>
>>>>>>>> In the same way that D did not contradict H1
>>>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>>>> which has no reason to get the wrong answer.
>>>>>>>
>>>>>>> No, it contraidicts ALL copies of H.
>>>>>>>
>>>>>>> The fact that H1 gives a different answer then H shows that it is
>>>>>>> a different computaiton (if they are computations at all).
>>>>>>>
>>>>>>
>>>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>>>> on the external H.
>>>>>
>>>>> But the MUST act the same.
>>>>>
>>>>> If you disagree, then you are admitting that you don't understand
>>>>> what a computation actually is.
>>>>>
>>>>
>>>> The exact same way that H1 gets the correct answer on D
>>>> even when H1 is a verbatim identical copy of H and it
>>>> is the very same D in both cases H would get a correct
>>>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>>>
>>>
>>> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
>>> Equivalent (TME) sense, in part because your H isn't a TME of the H
>>> descirbed, becausee it takes and processes its input in an incorrect
>>> manner.
>>>
>>
>> What are all of the details of the "incorrect manner" that you are
>> referring to?
>
> There is a global variable which stores the execution log which is
> secretly passed from parent machine to child machine in the simulation.

It was not global it was written to a memory location directly in the
machine language function body of H. Not on the stack and not global.
This is the same as a TM writing to its own tape.

UTM H simply allocated this same memory area to the machines that it
was emulating as their own TM tape. A UTM can do that. This version has
been renamed to HH. H was rewritten to not need this memory.

> Turing machines don't have global variables that are secretly passed
> from one machine to another. Every step of TM execution looks for the
> same step already existing in the execution log. This causes one
> execution of a "TM" to differ from another which is impossible for an
> actual TM.
>
>>
>>>> When the machine language of H and H1 are identical and
>>>> they both process the same machine language of D then
>>>> the fact that H1 and H are in a different memory space
>>>> is the same as Linz H and Ĥ.H are in a different memory
>>>> space such that neither H1 nor Linz H can be contradicted
>>>> by its input.
>>>
>>> Except they use a hidden input, and thus are not Computations.
>>
>> The simple fact that H and Ĥ.H are in different memory spaces makes it
>> impossible for Ĥ to contradict H. When we hypothesize that H is based
>> on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.
>>
>
> In your code, Ĥ ⟨Ĥ⟩ halts but H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn which is
> incorrect according to the specification.

*You have that incorrectly*

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

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.

--
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/2024 9:42 AM, immibis wrote:
> On 29/02/24 15:48, olcott wrote:
>> On 2/29/2024 4:55 AM, immibis wrote:
>>> On 29/02/24 01:47, olcott wrote:
>>>> In the same way that D did not contradict H1
>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>> which has no reason to get the wrong answer.
>>>
>>> It is impossible for a copy of H to get a different result than H.
>>>
>>
>> Because *H and Ĥ are in different memory spaces* Ĥ can only
>> contradict itself and cannot contradict H. H and Ĥ.H always
>> only report on what they see. Ĥ.H sees that YES is the wrong
>> answer so it says NO by default. H sees that Ĥ said NO so it
>> says YES.
>>
>
> It is impossible for a copy of H to get a different result than H.

False assumption.
H(D,D) gets a different answer than H1(D,D) because
H/DD has a pathological self-reference relationship
and H1/DD does not.

This is because H is in a different memory space than
H1 the same way that Linz H is in a different memory
space than Linz Ĥ.
D can contradict H yet cannot contradict H1.
Ĥ can contradict Ĥ.H yet cannot contradict Linz 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 2/29/2024 9:43 AM, immibis wrote:
> On 29/02/24 15:42, olcott wrote:
>> On 2/29/2024 4:51 AM, immibis wrote:
>>> On 29/02/24 00:46, olcott wrote:
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>
>>>> Because H is required to always halt we can know that
>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>> thus H merely needs to report on that.
>>>>
>>>> // Ĥ.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.
>>>>
>>>
>>> If it's self-contradictory how can it get the correct answer?
>>
>> Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩
>> Is self contradictory thus answers NO whenever YES is the wrong answer.
>>
>> H ⟨Ĥ⟩ ⟨Ĥ⟩
>> Is in a different memory space and can see that Ĥ.Hq0 answers NO
>> thus answers YES
>>
> There is no such thing as a memory space when we are talking about
> Turing machines.

Sure there is. This is especially true for the tape locations
of a Turing machine description that is being simulated.

That Turing machines are imaginary allows us to ignore where
and how its states are stored. (Somehow and somewhere is close
enough for imaginary machines).

When this vagueness is made concrete then this entails the
equivalent of machine memory.

--
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 9:58 AM, olcott wrote:
> On 2/29/2024 6:32 AM, Richard Damon wrote:
>> On 2/28/24 11:26 PM, olcott wrote:
>>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>>> On 2/28/24 10:54 PM, olcott wrote:
>>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>>
>>>>>>>>> Because H is required to always halt we can know that
>>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>>> thus H merely needs to report on that.
>>>>>>>>>
>>>>>>>>> // Ĥ.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.
>>>>>>>
>>>>>>> In the same way that D did not contradict H1
>>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>>> which has no reason to get the wrong answer.
>>>>>>
>>>>>> No, it contraidicts ALL copies of H.
>>>>>>
>>>>>> The fact that H1 gives a different answer then H shows that it is
>>>>>> a different computaiton (if they are computations at all).
>>>>>>
>>>>>
>>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>>> on the external H.
>>>>
>>>> But the MUST act the same.
>>>>
>>>> If you disagree, then you are admitting that you don't understand
>>>> what a computation actually is.
>>>>
>>>
>>> The exact same way that H1 gets the correct answer on D
>>> even when H1 is a verbatim identical copy of H and it
>>> is the very same D in both cases H would get a correct
>>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>>
>>
>> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
>> Equivalent (TME) sense, in part because your H isn't a TME of the H
>> descirbed, becausee it takes and processes its input in an incorrect
>> manner.
>>
>
> What are all of the details of the "incorrect manner" that you are
> referring to?

They use differing information that is not part of the input, namely
their own address.

>
>>> When the machine language of H and H1 are identical and
>>> they both process the same machine language of D then
>>> the fact that H1 and H are in a different memory space
>>> is the same as Linz H and Ĥ.H are in a different memory
>>> space such that neither H1 nor Linz H can be contradicted
>>> by its input.
>>
>> Except they use a hidden input, and thus are not Computations.
>
> The simple fact that H and Ĥ.H are in different memory spaces makes it
> impossible for Ĥ to contradict H. When we hypothesize that H is based
> on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.
>

Nope.

Since BY SIMPLE PROOF, all identical copies of a computation produce the
same results from the same input, it just needs to contradict its own
copy to contradict all copies.

THe fact that you don't understand that simple fact, that comes directly
from the definition of a Computation means your argument fails.

Remember, a "Computation" is a specific algorithm applied to a specific
finite set of data.

The Algorithm is a finite set of specific deterministic instructions
whose results only depend on the data given to them.

Two identical copies of an algorithm and data set, will always at each
step produce the exact same result for each step, and thus end up with
teh exact same answer.

On 2/29/24 9:36 AM, olcott wrote:
> On 2/28/2024 10:26 PM, olcott wrote:
>> *I think that we may be finally getting to closure on this*
>>
> test2

FAILURE 2

On 2/29/2024 8:54 PM, Richard Damon wrote:
> On 2/29/24 9:58 AM, olcott wrote:
>> On 2/29/2024 6:32 AM, Richard Damon wrote:
>>> On 2/28/24 11:26 PM, olcott wrote:
>>>> On 2/28/2024 10:12 PM, Richard Damon wrote:
>>>>> On 2/28/24 10:54 PM, olcott wrote:
>>>>>> On 2/28/2024 9:06 PM, Richard Damon wrote:
>>>>>>> On 2/28/24 7:47 PM, olcott wrote:
>>>>>>>> On 2/28/2024 6:27 PM, Richard Damon wrote:
>>>>>>>>> On 2/28/24 6:46 PM, olcott wrote:
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ halts
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn   // H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not halt
>>>>>>>>>>
>>>>>>>>>> Because H is required to always halt we can know that
>>>>>>>>>> Ĥ.Hq0 applied to ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.Hqy or Ĥ.Hqn
>>>>>>>>>> thus H merely needs to report on that.
>>>>>>>>>>
>>>>>>>>>> // Ĥ.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.
>>>>>>>>
>>>>>>>> In the same way that D did not contradict H1
>>>>>>>> Ĥ does not contradict H. Ĥ only contradicts its own
>>>>>>>> internal copy of Ĥ.H, this has no effect on the actual H
>>>>>>>> which has no reason to get the wrong answer.
>>>>>>>
>>>>>>> No, it contraidicts ALL copies of H.
>>>>>>>
>>>>>>> The fact that H1 gives a different answer then H shows that it is
>>>>>>> a different computaiton (if they are computations at all).
>>>>>>>
>>>>>>
>>>>>> Ĥ only contradicts its own internal Ĥ.H and can have no effect
>>>>>> on the external H.
>>>>>
>>>>> But the MUST act the same.
>>>>>
>>>>> If you disagree, then you are admitting that you don't understand
>>>>> what a computation actually is.
>>>>>
>>>>
>>>> The exact same way that H1 gets the correct answer on D
>>>> even when H1 is a verbatim identical copy of H and it
>>>> is the very same D in both cases H would get a correct
>>>> answer for ⟨Ĥ⟩ ⟨Ĥ⟩ even though Ĥ.H cannot.
>>>>
>>>
>>> Except H1 is NOT a "Verbatim Identical Copy" in the Turing Machine
>>> Equivalent (TME) sense, in part because your H isn't a TME of the H
>>> descirbed, becausee it takes and processes its input in an incorrect
>>> manner.
>>>
>>
>> What are all of the details of the "incorrect manner" that you are
>> referring to?
>
> They use differing information that is not part of the input, namely
> their own address.
>

I think it was Andre that said that was OK.

The original design is the same as a UTM sharing
a portion of its own tape with its simulated input
this is always the way that this works that UTMs work.
This aspect of the design may be moot now.

>>
>>>> When the machine language of H and H1 are identical and
>>>> they both process the same machine language of D then
>>>> the fact that H1 and H are in a different memory space
>>>> is the same as Linz H and Ĥ.H are in a different memory
>>>> space such that neither H1 nor Linz H can be contradicted
>>>> by its input.
>>>
>>> Except they use a hidden input, and thus are not Computations.
>>
>> The simple fact that H and Ĥ.H are in different memory spaces makes it
>> impossible for Ĥ to contradict H. When we hypothesize that H is based
>> on a UTM then it can see that ⟨Ĥ⟩ ⟨Ĥ⟩ halts or fails to halt.
>>
>
> Nope.
>
> Since BY SIMPLE PROOF, all identical copies of a computation produce the
> same results from the same input, it just needs to contradict its own
> copy to contradict all copies.
>

*In other word you can't understand this simple reasoning*
*So you use dogma instead of reasoning as a rebuttal*

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

> THe fact that you don't understand that simple fact, that comes directly
> from the definition of a Computation means your argument fails.
>

It is not so simply of a fact.
Unless I saw it with my own eyes I would have believed as you believe.
Your reasoning seems to be sound yet actual reality contradicts this.

You may not know enough about the x86 language to understand that it
is proven that both H and H1 do simulated D correctly. I began with
the x86 language back when it was new. Segmentation was a real pain.
Flat address space was wonderful.

>
> Remember, a "Computation" is a specific algorithm applied to a specific
> finite set of data.
>
> The Algorithm is a finite set of specific deterministic instructions
> whose results only depend on the data given to them.
>
> Two identical copies of an algorithm and data set, will always at each
> step produce the exact same result for each step, and thus end up with
> teh exact same answer.

I believed that was true until I saw it contradicted by reality.
Unless I made the problem 100% concrete I would never know that
that halting problem proofs have behavior different than expected.

Since I know the principle that you said is correct then there
must be some difference to explain the difference in behavior.

A key difference is that every value that Ĥ.H returns is contradicted
and no value that H returns is contradicted. This seems to make
them different machines.

Another difference is that these two computations on the same data
are out-of-sync so that one of these two computations is in a more
advanced state than the other. Ĥ.H is many steps ahead of H.

This allows H to simply watch and see what Ĥ.H does before H has
to do anything besides watch.

It is also the case that the appended infinite loop to Ĥ.H
makes Ĥ.H a different computation than H. So the two machines
are not identical for this reason.

--
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 17:34, olcott wrote:
> On 2/29/2024 9:43 AM, immibis wrote:
>> There is no such thing as a memory space when we are talking about
>> Turing machines.
>
> Sure there is.

5+1=6

5+1=7

This is ok because they are two different 5s in two different memory
locations.

On 29/02/24 17:19, olcott wrote:
> On 2/29/2024 9:42 AM, immibis wrote:
>> In your code, Ĥ ⟨Ĥ⟩ halts but H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to H.qn which is
>> incorrect according to the specification.
>
> *You have that incorrectly*

Run your code and find out.