On 12/13/2021 7:55 PM, Richard Damon wrote:
> On 12/13/21 8:49 PM, olcott wrote:
>> On 12/13/2021 7:36 PM, André G. Isaak wrote:
>>> On 2021-12-13 18:09, olcott wrote:
>>>> On 12/13/2021 5:40 PM, André G. Isaak wrote:
>>>>> On 2021-12-13 16:25, olcott wrote:
>>>>>> On 12/13/2021 2:10 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-13 11:37, olcott wrote:
>>>>>>>> On 12/13/2021 12:20 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-12-13 11:10, olcott wrote:
>>>>>>>>>> On 12/13/2021 11:33 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-12-13 09:33, olcott wrote:
>>>>>>>>>>>> On 12/13/2021 10:22 AM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-12-13 08:50, olcott wrote:
>>>>>>>>>>>>>> On 12/13/2021 9:24 AM, André G. Isaak wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your problem is that, despite the fact that you are
>>>>>>>>>>>>>>> talking about a theorem which concerns Turing Machines,
>>>>>>>>>>>>>>> you continue to think about things in terms of C programs
>>>>>>>>>>>>>>> and/or x86 programs which are very different animals from
>>>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As long as a C function is a pure function then it is a
>>>>>>>>>>>>>> computable function through the RASP model of computation
>>>>>>>>>>>>>> for every input that it derives an output.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No C function is a computable function. Computable
>>>>>>>>>>>>> functions are a subset of *mathematical* functions. The
>>>>>>>>>>>>> word 'function' in C means something entirely different
>>>>>>>>>>>>> than the word 'function' in maths.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A function f with domain D is said to be Turing-computable
>>>>>>>>>>>> or just computable if there exists some Turing machine
>>>>>>>>>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>>>>>>>>>> for all w ∈ D (Linz:1990:243)
>>>>>>>>>>>
>>>>>>>>>>> Which perfectly agrees with what I just said.
>>>>>>>>>>>
>>>>>>>>>>>> Olcott paraphrase of above machine definition: Machine M
>>>>>>>>>>>> begins at start state q0 on input w and transitions to qf as
>>>>>>>>>>>> a function of input w.
>>>>>>>>>>>
>>>>>>>>>>> Which is not a paraphrase of the above.
>>>>>>>>>>>
>>>>>>>>>>>> Linz says that machine M computes the function f(w).
>>>>>>>>>>> Yes, machine M *computes* function f(w). This does not mean
>>>>>>>>>>> that machine M is a function. It is not. It is an algorithm.
>>>>>>>>>>> The whole point of my post was to try to get you to actually
>>>>>>>>>>> grasp the distinction between a function and an algorithm
>>>>>>>>>>> which computes that function. The two are not the same thing.
>>>>>>>>>>> The terms are not interchangeable. There isn't a one-to-one
>>>>>>>>>>> correspondence between the two.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When H(P,P) computes the halting function it is only the
>>>>>>>>>> behavior of the actual sequence of configurations specified by
>>>>>>>>>> (P,P) as if H was a UTM and not a halt decider that provides
>>>>>>>>>> the correct basis for the halt status decision. This is
>>>>>>>>>> consistently always the case for every input.
>>>>>>>>>
>>>>>>>>> So we're back to the "I don't understand what you wrote so I'll
>>>>>>>>> respond with something completely unrelated" approach. Do you
>>>>>>>>> know understand the difference between a function and an
>>>>>>>>> algorithm? If so, will you stop misusing them in future?
>>>>>>>>>
>>>>>>>>
>>>>>>>> H is not a computable function H computes the halting function.
>>>>>>>
>>>>>>> OK. So now you've finally gotten that part right.
>>>>>>>
>>>>>>> But now you need to think about what that actually *means*
>>>>>>>
>>>>>>> The halting function maps every member of the set of all possible
>>>>>>> computation to either 'HALTS' or 'DOESN'T HALT'. Note that this
>>>>>>> is simply a mapping. It exists independently of any algorithm
>>>>>>> (i.e. halt decider). It has a domain and a codomain. It has no
>>>>>>> 'inputs' since it is not an algorithm.
>>>>>>>
>>>>>>
>>>>>> H(P,P) computes the halting function for a domain that includes P.
>>>>>
>>>>> What on earth does that mean?
>>>>
>>>> You don't know what the domain of a function is?
>>>
>>> Yes, I do. And P isn't in the domain of the halting function. P(P) is
>>> in its domain but P is not.
>>>
>>>>> The domain of the halting function is the set of all possible
>>>>> computations.
>>>>
>>>> How many hundreds of times do I have to repeat that I am not solving
>>>> the halting problem merely refuting the conventional proofs???
>>>>
>>>> To refute the conventional proofs only requires correctly deciding
>>>> the halt status of a single element of the domain of a universal
>>>> halt function.
>>>
>>> And both P(P) and H_Hat(<H_Hat) *are* in the domain of the halting
>>> function and those are the two elements you claim to be concerned with.
>>>
>>> Both of these are mapped to 'HALTS' by the halting function because
>>> the halting function is concerned with how computations behave when
>>> they are actually run.
>>>
>>>>> A computation is a pair of a Turing Machine and an input string. P
>>>>> isn't such a pair.
>>>>>
>>>>
>>>> H does correctly compute the halt function of its domain and it need
>>>> not be a TM.
>>>>
>>>>>>> Because we've observed that P(P) and H_Hat(H_Hat) both halt when
>>>>>>> run, it will include P(P) -> HALTS and H_Hat(H_Hat) -> HALTS as
>>>>>>> part of its
>>>>>>
>>>>>> Neither of those are ACTUAL INPUTS in the domain.
>>>>>
>>>>> You may think this means something but I can't for the life of me
>>>>> figure out what it could be. Functions have domains. Turing
>>>>> Machines have inputs.
>>>>>
>>>>
>>>> Linz says input w is in the domain of f:
>>>> A function f with domain D is said to be Turing-computable
>>>> or just computable if there exists some Turing machine
>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>> for all w ∈ D (Linz:1990:243)
>>>>
>>>> Sipser says functions have inputs:
>>>> A Turing machine computes a function by starting with the input to
>>>> the function on the tape and halting with the output of the function
>>>> on the tape (Sipser:1997:190).
>>>>
>>>> So when I say that int main() { P(P); } is outside the scope of
>>>> computable function H because it is not an input to H I am correct.
>>>
>>> Again, what you write is nonsense. P(P) *is* in the domain of the
>>
>> It looks like both Sipser and Linz correct your "corrections", thus
>> proving that your "corrections" are incorrect.
>>
>> The C code that computes the halting function for a domain including
>> the x86 machine code of the following:
>>
>> void P(u32 x)
>> {
>>    if (H(x, x))
>>      HERE: goto HERE;
>> }
>>
>> void Infinite_Loop(int N)
>> {
>>    HERE: goto HERE;
>> }
>>
>> void Infinite_Recursion(int N)
>> {
>>    Infinite_Recursion(N);
>> }
>>
>> correctly determines that none of the above inputs ever stops running
>> without being aborted
>
> Except the P(P) does Halt if H(P,P) returns 0.

On 12/15/2021 10:49 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> No matter how you slice it the behavior of Ĥ depends on the decision
>> of Ĥ.qx
>
> You are talking about TM's again... Let's take a look:
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Yup. Since Ĥ.q0 ⟨Ĥ⟩ transitions to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩, what transmissions
> follow Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is indeed key (but Ĥ is not a decider, remember).
> All you need to do now is explain under which conditions each line
> applies and you are done:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> To quote Linz, "this is clearly nonsense".
>

We begin with the assumption that H is a simulating halt decider.

A Turing machine computes a function by starting with the input to the
function on the tape and halting with the output of the function on the
tape (Sipser:1997:190).

Linz (and everyone else) erroneously conflates the execution of Ĥ
applied to ⟨Ĥ⟩ with the simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx.

(1) The simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx is one level of
indirect reference away from Ĥ applied to ⟨Ĥ⟩. Ĥ.qx is not deciding
whether or not itself halts. It is only deciding whether or not the
simulation of its input ever reaches the final state of this input.

(2) The fact that Ĥ applied to ⟨Ĥ⟩ would halt if Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
transitions to Ĥ.qn has no bearing on whether or not this transition is
correct because the computable function at Ĥ.qx is only accountable for
the behavior of its actual inputs. It is not accountable for the
behavior it itself because itself its not an actual input.

(3) Ĥ applied to ⟨Ĥ⟩ has a one-way dependency on Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
that does not exist in the reverse.

(4) It is the case that when H is based on a simulating halt decider
that Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would remain in infinitely nested
simulation unless and until Ĥ.qx would abort the simulation of its
input. This conclusively proves that the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.

I repeat that the behavior of Ĥ applied to ⟨Ĥ⟩ has no bearing in the
halt status decision of Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ because the computable
function at Ĥ.qx only applies to its actual inputs and does not apply to
itself: Ĥ applied to ⟨Ĥ⟩ is an earlier part of Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/17/2021 3:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> A function f with domain D is said to be Turing-computable
>>>> or just computable if there exists some Turing machine
>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>> for all w ∈ D (Linz:1990:243)
>>>
>>> We all know your cut and paste skills are top notch.
>>>
>>>> Olcott paraphrase of above machine definition: Machine M begins at
>>>> start state q0 on input w and transitions to qf as a function of input
>>>> w.
>>>
>>> But that's not a correct paraphrase.
>>
>> A Turing machine computes a function by starting with the input to the
>> function on the tape and halting with the output of the function on
>> the tape (Sipser:1997:190).
>>
>> Within the context of the Sipser and Kozen quotes that you erased
>> exactly how is my paraphrase of Linz incorrect?
>
> Your paraphrase was of the Linz definition. If not, its reference to
> q0, qf and w are all wrong. As a paraphrase of Linz, it's wrong because
> it substitutes ambiguity for clarity.

> To say that M "transitions to qf
> as a function of w" is pure waffle.

q0 w ⊢* M qf f(w), qf ∈ F // I added a little spacing.

M is the machine
q0 is the initial state
qf is the final state
w is the input
f is the function name
D is the domain of the function

What do you think that f(w) means?

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/17/2021 3:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> A function f with domain D is said to be Turing-computable
>>>> or just computable if there exists some Turing machine
>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* M qf f(w), qf ∈ F
>>>> for all w ∈ D (Linz:1990:243)
>>>
>>> We all know your cut and paste skills are top notch.
>>>
>>>> Olcott paraphrase of above machine definition: Machine M begins at
>>>> start state q0 on input w and transitions to qf as a function of input
>>>> w.
>>>
>>> But that's not a correct paraphrase.
>>
>> A Turing machine computes a function by starting with the input to the
>> function on the tape and halting with the output of the function on
>> the tape (Sipser:1997:190).
>>
>> Within the context of the Sipser and Kozen quotes that you erased
>> exactly how is my paraphrase of Linz incorrect?
>
> Your paraphrase was of the Linz definition. If not, its reference to
> q0, qf and w are all wrong. As a paraphrase of Linz, it's wrong because
> it substitutes ambiguity for clarity. To say that M "transitions to qf
> as a function of w" is pure waffle.
>
> And you don't say what qf is. If you mention it, you should say why it
> matters. But you don't need to mention q0. That's just noise, as all
> TMs start in their start state, and what it's called it irrelevant to
> the paraphrase.
>
> Here's a better paraphrase:
>
> M, given w on its tape, halts with f(w) on the tape, for every string w
> in the domain of f.
>

It is not a better paraphrase because Linz specifies that the accept /
reject decision is specified by a state transition.

On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
> To say that M "transitions to qf as a function of w" is pure waffle.

Because M does transition to qf and
it is common knowledge that f(w) means w is a function of f.
you know that your "correction" is incorrect.

Why lie?

> But you probably still plan to misuse the term "computable function".
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/20/2021 9:50 PM, Richard Damon wrote:
>
> On 12/20/21 10:16 PM, olcott wrote:
>> On 12/20/2021 8:44 PM, Richard Damon wrote:
>>> On 12/20/21 9:19 PM, olcott wrote:
>>>> On 12/20/2021 8:02 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/17/2021 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> A function f with domain D is said to be Turing-computable
>>>>>>>>>> or just computable if there exists some Turing machine
>>>>>>>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* M qf f(w), qf ∈ F
>>>>>>>>>> for all w ∈ D (Linz:1990:243)
>>>>>>>>>
>>>>>>>>> We all know your cut and paste skills are top notch.
>>>>>>>>>
>>>>>>>>>> Olcott paraphrase of above machine definition: Machine M
>>>>>>>>>> begins at
>>>>>>>>>> start state q0 on input w and transitions to qf as a function
>>>>>>>>>> of input
>>>>>>>>>> w.
>>>>>>>>>
>>>>>>>>> But that's not a correct paraphrase.
>>>>>>>>
>>>>>>>> A Turing machine computes a function by starting with the input
>>>>>>>> to the
>>>>>>>> function on the tape and halting with the output of the function on
>>>>>>>> the tape (Sipser:1997:190).
>>>>>>>>
>>>>>>>> Within the context of the Sipser and Kozen quotes that you erased
>>>>>>>> exactly how is my paraphrase of Linz incorrect?
>>>>>>>
>>>>>>> Your paraphrase was of the Linz definition.  If not, its
>>>>>>> reference to
>>>>>>> q0, qf and w are all wrong.  As a paraphrase of Linz, it's wrong
>>>>>>> because
>>>>>>> it substitutes ambiguity for clarity.  To say that M "transitions
>>>>>>> to qf
>>>>>>> as a function of w" is pure waffle.
>>>>>>>
>>>>>>> And you don't say what qf is.  If you mention it, you should say
>>>>>>> why it
>>>>>>> matters.  But you don't need to mention q0.  That's just noise,
>>>>>>> as all
>>>>>>> TMs start in their start state, and what it's called it
>>>>>>> irrelevant to
>>>>>>> the paraphrase.
>>>>>>>
>>>>>>> Here's a better paraphrase:
>>>>>>>
>>>>>>> M, given w on its tape, halts with f(w) on the tape, for every
>>>>>>> string w
>>>>>>> in the domain of f.
>>>>>>
>>>>>> It is not a better paraphrase because Linz specifies that the
>>>>>> accept /
>>>>>> reject decision is specified by a state transition.
>>>>>
>>>>> Gosh.  I had no idea you were so confused by Linz's simple definition.
>>>>> In short, no it does not.  I suspect you have not even read the proper
>>>>> definition in a TM.  Oh well, it's all details, but you really should
>>>>> not try to pick holes in what I say by bringing up details.  I am a
>>>>> details person.
>>>>>
>>>>>> On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
>>>>>>> To say that M "transitions to qf as a function of w" is pure waffle.
>>>>>>
>>>>>> Because M does transition to qf and
>>>>>> it is common knowledge that f(w) means w is a function of f.
>>>>>> you know that your "correction" is incorrect.
>>>>>>
>>>>>> Why lie?
>>>>>
>>>>> I don't lie.  It's waffle.  You have taken a precise definition and
>>>>> paraphrased it to say almost nothing.  All TMs (that halt)
>>>>> transition to
>>>>> a halting state "as a function of" their input.  You have replaced
>>>>> everything that matters by vague waffle.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. // Linz says this
>>>>
>>>> Because you have a dogmatic brain incapable of reasoning on its own
>>>> you are incapable of directly seeing that Linz's words are not
>>>> infallible.
>>>>
>>>> It is not the case that Ĥ has Ĥ as its input so it is not the case
>>>> that Ĥ.qx computes the halt status of Ĥ applied to ⟨Ĥ⟩.
>>>>
>>>
>>> H^ has <H^> as its input, which is what H^ applied to <H^> means, thus
>>
>> Yes this is exactly correct.
>>
>>> it IS the case we hit a contradiction.
>> No because Ĥ.qx reports on the behavior specified by the simulation of
>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩.
>>
>
> It must report on what it derived from that, but if H claims to be a
> CORRECT Halt Decider, then that answer MUST match the answer from the
> defintion of the Problem.
>
> If H is a correct Halt Decider, H(<x>, y) returns Halting if x(y) Halts
> and Non-Halting if x(y) never halts. (Not the simulation by H of this,
> but the actual computation).
>

No you are wrong. H is only allowed to map the behavior of its actual
inputs to an accept / reject state and it can only correctly determine
the behavior of its actual inputs by actually simulating these actual
inputs.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/17/2021 3:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> A function f with domain D is said to be Turing-computable
>>>> or just computable if there exists some Turing machine
>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>> for all w ∈ D (Linz:1990:243)
>>>
>>> We all know your cut and paste skills are top notch.
>>>
>>>> Olcott paraphrase of above machine definition: Machine M begins at
>>>> start state q0 on input w and transitions to qf as a function of input
>>>> w.
>>>
>>> But that's not a correct paraphrase.
>>
>> A Turing machine computes a function by starting with the input to the
>> function on the tape and halting with the output of the function on
>> the tape (Sipser:1997:190).
>>
>> Within the context of the Sipser and Kozen quotes that you erased
>> exactly how is my paraphrase of Linz incorrect?
>
> Your paraphrase was of the Linz definition. If not, its reference to
> q0, qf and w are all wrong. As a paraphrase of Linz, it's wrong because
> it substitutes ambiguity for clarity.

> To say that M "transitions to qf
> as a function of w" is pure waffle.

On 12/17/2021 9:21 AM, olcott wrote:
> A function f with domain D is said to be Turing-computable
> or just computable if there exists some Turing machine
> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* M qf f(w), qf ∈ F
> for all w ∈ D (Linz:1990:243)
>
> Olcott paraphrase of above machine definition:
> Machine M begins at start state q0 on input w and
> transitions to qf as a function of input w.

M = (Q, Σ, Γ, δ, q0, □, F) such that
q0 w ⊢* M qf f(w), qf ∈ F

Machine M
begins a start state q0
on input w
transitions to qf
as a function of w
....

Not really any ambiguity or waffle at all.
Not really any ambiguity or waffle at all.
Not really any ambiguity or waffle at all.
Not really any ambiguity or waffle at all.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/21/2021 8:24 AM, Richard Damon wrote:
> On 12/20/21 11:18 PM, olcott wrote:
>> On 12/20/2021 9:50 PM, Richard Damon wrote:
>>>
>>> On 12/20/21 10:16 PM, olcott wrote:
>>>> On 12/20/2021 8:44 PM, Richard Damon wrote:
>>>>> On 12/20/21 9:19 PM, olcott wrote:
>>>>>> On 12/20/2021 8:02 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 12/17/2021 3:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> A function f with domain D is said to be Turing-computable
>>>>>>>>>>>> or just computable if there exists some Turing machine
>>>>>>>>>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* M qf f(w), qf ∈ F
>>>>>>>>>>>> for all w ∈ D (Linz:1990:243)
>>>>>>>>>>>
>>>>>>>>>>> We all know your cut and paste skills are top notch.
>>>>>>>>>>>
>>>>>>>>>>>> Olcott paraphrase of above machine definition: Machine M
>>>>>>>>>>>> begins at
>>>>>>>>>>>> start state q0 on input w and transitions to qf as a
>>>>>>>>>>>> function of input
>>>>>>>>>>>> w.
>>>>>>>>>>>
>>>>>>>>>>> But that's not a correct paraphrase.
>>>>>>>>>>
>>>>>>>>>> A Turing machine computes a function by starting with the
>>>>>>>>>> input to the
>>>>>>>>>> function on the tape and halting with the output of the
>>>>>>>>>> function on
>>>>>>>>>> the tape (Sipser:1997:190).
>>>>>>>>>>
>>>>>>>>>> Within the context of the Sipser and Kozen quotes that you erased
>>>>>>>>>> exactly how is my paraphrase of Linz incorrect?
>>>>>>>>>
>>>>>>>>> Your paraphrase was of the Linz definition.  If not, its
>>>>>>>>> reference to
>>>>>>>>> q0, qf and w are all wrong.  As a paraphrase of Linz, it's
>>>>>>>>> wrong because
>>>>>>>>> it substitutes ambiguity for clarity.  To say that M
>>>>>>>>> "transitions to qf
>>>>>>>>> as a function of w" is pure waffle.
>>>>>>>>>
>>>>>>>>> And you don't say what qf is.  If you mention it, you should
>>>>>>>>> say why it
>>>>>>>>> matters.  But you don't need to mention q0.  That's just noise,
>>>>>>>>> as all
>>>>>>>>> TMs start in their start state, and what it's called it
>>>>>>>>> irrelevant to
>>>>>>>>> the paraphrase.
>>>>>>>>>
>>>>>>>>> Here's a better paraphrase:
>>>>>>>>>
>>>>>>>>> M, given w on its tape, halts with f(w) on the tape, for every
>>>>>>>>> string w
>>>>>>>>> in the domain of f.
>>>>>>>>
>>>>>>>> It is not a better paraphrase because Linz specifies that the
>>>>>>>> accept /
>>>>>>>> reject decision is specified by a state transition.
>>>>>>>
>>>>>>> Gosh.  I had no idea you were so confused by Linz's simple
>>>>>>> definition.
>>>>>>> In short, no it does not.  I suspect you have not even read the
>>>>>>> proper
>>>>>>> definition in a TM.  Oh well, it's all details, but you really
>>>>>>> should
>>>>>>> not try to pick holes in what I say by bringing up details.  I am a
>>>>>>> details person.
>>>>>>>
>>>>>>>> On 12/17/2021 6:46 PM, Ben Bacarisse wrote:
>>>>>>>>> To say that M "transitions to qf as a function of w" is pure
>>>>>>>>> waffle.
>>>>>>>>
>>>>>>>> Because M does transition to qf and
>>>>>>>> it is common knowledge that f(w) means w is a function of f.
>>>>>>>> you know that your "correction" is incorrect.
>>>>>>>>
>>>>>>>> Why lie?
>>>>>>>
>>>>>>> I don't lie.  It's waffle.  You have taken a precise definition and
>>>>>>> paraphrased it to say almost nothing.  All TMs (that halt)
>>>>>>> transition to
>>>>>>> a halting state "as a function of" their input.  You have replaced
>>>>>>> everything that matters by vague waffle.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. // Linz says this
>>>>>>
>>>>>> Because you have a dogmatic brain incapable of reasoning on its
>>>>>> own you are incapable of directly seeing that Linz's words are not
>>>>>> infallible.
>>>>>>
>>>>>> It is not the case that Ĥ has Ĥ as its input so it is not the case
>>>>>> that Ĥ.qx computes the halt status of Ĥ applied to ⟨Ĥ⟩.
>>>>>>
>>>>>
>>>>> H^ has <H^> as its input, which is what H^ applied to <H^> means, thus
>>>>
>>>> Yes this is exactly correct.
>>>>
>>>>> it IS the case we hit a contradiction.
>>>> No because Ĥ.qx reports on the behavior specified by the simulation
>>>> of ⟨Ĥ⟩ applied to ⟨Ĥ⟩.
>>>>
>>>
>>> It must report on what it derived from that, but if H claims to be a
>>> CORRECT Halt Decider, then that answer MUST match the answer from the
>>> defintion of the Problem.
>>>
>>> If H is a correct Halt Decider, H(<x>, y) returns Halting if x(y)
>>> Halts and Non-Halting if x(y) never halts. (Not the simulation by H
>>> of this, but the actual computation).
>>>
>>
>> No you are wrong. H is only allowed to map the behavior of its actual
>> inputs to an accept / reject state and it can only correctly determine
>> the behavior of its actual inputs by actually simulating these actual
>> inputs.
>>
>
> Wrong. Yes, because H needs to be a finite algorithm can only generate
> an answer based on processing the actual string it was given as an input.
>
> BUT, the REQUIREMENTS on H are based on the Machine that this input
> represents.

This is the persistent misconception.
The actual simulation of the actual input is the
only correct basis for any halt status decision.

Linz is wrong on this key point:
Linz is wrong on this key point:
Linz is wrong on this key point:

<Linz:1990:320>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.
</Linz:1990:320>

Once this single point is understood my
refutation will be understood to be correct:

The actual simulation of the actual input is the
only correct basis for any halt status decision.

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

On 12/21/2021 10:41 AM, André G. Isaak wrote:
> On 2021-12-21 08:56, olcott wrote:
>> On 12/21/2021 8:24 AM, Richard Damon wrote:
>
>>> Wrong. Yes, because H needs to be a finite algorithm can only
>>> generate an answer based on processing the actual string it was given
>>> as an input.
>>>
>>> BUT, the REQUIREMENTS on H are based on the Machine that this input
>>> represents.
>>
>> This is the persistent misconception.
>> The actual simulation of the actual input is the
>> only correct basis for any halt status decision.
>
> A "correct basis" for a decision must be one that corresponds to the
> function which your decider purports to compute.
>
> Now that you've finally figured out that a Turing Machine is *not* a
> computable function, do you actually grasp what the halting FUNCTION is
> and what it means for something to compute a function?

A Turing machine computes a function by starting with the input to the
function on the tape and halting with the output of the function on the
tape (Sipser:1997:190).

A model of computation computes a function by mapping the input to the
function to the output of this function.

> The halting function is simply a mapping from pairs of TMs/input strings
> to either "halts" or "doesn't halt". It is not an algorithm of any sort.
>

No that is totally incorrect. It is never ever the case that any TM has
another TM as its input.

It is a mapping of a pair of finite strings to their corresponding
accept reject state on the basis of the behavior specified by the
simulation this pair of finite strings.

> It maps pairs that halt to "halts" and pairs that don't halt to "doesn't
> halt".
>
> Since H_Hat(H_Hat) halts, it maps (H_Hat, <H_Hat>) to "halts".
>
> Therefore, if your decider actually computes this function, it must
> accept the string which represents this pair. That would be <H_Hat>
> <H_Hat>.
>
>> Linz is wrong on this key point:
>
> No, he is not. His conditions accurately describe the function which the
> decider purports to compute.
>

Because everyone knows that no TM ever has another TM as its input
everyone (including Linz) knows that this does not literally compute
whether or not {Ĥ applied to ⟨Ĥ⟩ does not halt}
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

They use the figurative language that it computes whether
or not {Ĥ applied to ⟨Ĥ⟩ does not halt} because the 100%
perfectly precise language is more clumsy to say.

It actually computes whether or not the finite string
pair ⟨Ĥ⟩ ⟨Ĥ⟩ input to Ĥ.qx specifies a computation that halts.

No one has previously ever bothered to notice that the computation of
the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ (where every nested
Ĥ.qx acts as if it was only a UTM) would never stop running.

I first noticed this in August of 2016.

>> Linz is wrong on this key point:
>> Linz is wrong on this key point:
>>
>> <Linz:1990:320>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>> </Linz:1990:320>
>>
>> Once this single point is understood my
>> refutation will be understood to be correct:
>>
>> The actual simulation of the actual input is the
>> only correct basis for any halt status decision.
>>
>>
>
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/21/2021 11:36 AM, André G. Isaak wrote:
> On 2021-12-21 10:14, olcott wrote:
>> On 12/21/2021 10:41 AM, André G. Isaak wrote:
>>> On 2021-12-21 08:56, olcott wrote:
>>>> On 12/21/2021 8:24 AM, Richard Damon wrote:
>>>
>>>>> Wrong. Yes, because H needs to be a finite algorithm can only
>>>>> generate an answer based on processing the actual string it was
>>>>> given as an input.
>>>>>
>>>>> BUT, the REQUIREMENTS on H are based on the Machine that this input
>>>>> represents.
>>>>
>>>> This is the persistent misconception.
>>>> The actual simulation of the actual input is the
>>>> only correct basis for any halt status decision.
>>>
>>> A "correct basis" for a decision must be one that corresponds to the
>>> function which your decider purports to compute.
>>>
>>> Now that you've finally figured out that a Turing Machine is *not* a
>>> computable function, do you actually grasp what the halting FUNCTION
>>> is and what it means for something to compute a function?
>>
>> A Turing machine computes a function by starting with the input to the
>> function on the tape and halting with the output of the function on
>> the tape (Sipser:1997:190).
>>
>> A model of computation computes a function by mapping the input to the
>> function to the output of this function.
>>
>>> The halting function is simply a mapping from pairs of TMs/input
>>> strings to either "halts" or "doesn't halt". It is not an algorithm
>>> of any sort.
>>>
>>
>> No that is totally incorrect. It is never ever the case that any TM
>> has another TM as its input.
>
> I'm talking about the halting FUNCTION. I'm not talking about a Turing
> machine. Do you still not grasp the distinction?
>
>> It is a mapping of a pair of finite strings to their corresponding
>> accept reject state on the basis of the behavior specified by the
>> simulation this pair of finite strings.
>
> The halting FUNCTION doesn't involve simulation of anything. It is
> simply a mapping from TM/input pairs to 'halts' or 'doesn't halt.
>
> André
>
>

None-the-less the function that the embedded H computes does not map Ĥ
to anything. It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.

When we are talking about this function being computed by an algorithm
then it maps It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state on the basis of
its pure simulation of N steps of ⟨Ĥ⟩ ⟨Ĥ⟩.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/23/2021 12:08 AM, André G. Isaak wrote:
> On 2021-12-22 20:59, olcott wrote:
>> On 12/22/2021 9:42 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> It is not the case that Ĥ has Ĥ as its input
>>>
>>> Indeed.  Did you ever think it did?
>>
>> That is what the if Ĥ applied to <Ĥ> means:
>> Ĥq0 <Ĥ> ⊦* Ĥqx <Ĥ> <Ĥ> ⊦* Ĥqn    if Ĥ applied to <Ĥ> does not halt.
>> You are merely copying the the mistake of Linz verbatim.
>
> That states the *condition* under which Ĥqn is reached.
>
> It makes no claim about Ĥ being an input to Ĥ.
>
> André
>

THE FOLLOWING IS THE PERSISTENT MISCONCEPTION

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

Linz figure 12.2 shows that Ĥ.qy still exists.

The error that Linz makes is saying "if Ĥ applied to ⟨Ĥ⟩ ..."
as if the embedded full copy of H at Ĥ.qx is computing
the mapping from Ĥ ⟨Ĥ⟩ to an accept / reject state.

The embedded full copy of H at Ĥ.qx is actually computing
the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept / reject state.
THIS CHANGES EVERYTHING.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/23/2021 9:01 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/22/2021 9:42 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. // Linz says this
>>> And, more importantly, I say that. I don't want to defend Linz's proof
>>> since we both know it has an error in it (though a minor one). Here's
>>> my proof again:
>>> If a TM, H, existed such that
>>> Hq0 <M> s ⊦* Hqy if M applied to s halts, and
>>> Hq0 <M> s ⊦* Hqn if M applied to s does not halt,
>>> we could construct from it an H' such that
>>> H'q0 <M> s ⊦* oo if M applied to s halts, and
>>> H'q0 <M> s ⊦* H'qn if M applied to s does not halt.
>>> And from that we could construct an Ĥ such that
>>> Ĥq0 <M> ⊦* Ĥqx <M> <M> ⊦* oo if M applied to <M> halts, and
>>> Ĥq0 <M> ⊦* Ĥqx <M> <M> ⊦* Ĥqn if M applied to <M> does not halt.
>>> Setting M to Ĥ, so <M> becomes <Ĥ>, we see that the existence of H (as
>>> Linz defines it) logically entails that a TM Ĥ that does this
>>> Ĥq0 <Ĥ> ⊦* Ĥqx <Ĥ> <Ĥ> ⊦* oo if Ĥ applied to <Ĥ> halts, and
>>> Ĥq0 <Ĥ> ⊦* Ĥqx <Ĥ> <Ĥ> ⊦* Ĥqn if Ĥ applied to <Ĥ> does not halt.
>>> would also have to exist.
>>>
>>>> Because you have a dogmatic brain incapable of reasoning on its own
>>>> you are incapable of directly seeing that Linz's words are not
>>>> infallible.
>>>
>>> Curious then, that I have written about, and agreed with you about, the
>>> mistake in Linz's proof. (I much prefer the real proof in Linz -- the
>>> one you have never even read. Don't try, you won't understand it.)
>>>
>>>> It is not the case that Ĥ has Ĥ as its input
>>>
>>> Indeed. Did you ever think it did?
>>
>> That is what the if Ĥ applied to <Ĥ> means:
>
> No it doesn't. How many years have you been trying to understand this
> simple notation? And, more to the point, why bring this up now? Did you
> think, for the last 15 or so years, the TMs could be given TMs as input?
>
> (These are not rhetorical questions but I don't expect you'll answer
> them. You spend a lot of time avoiding direct questions.)
>
> Anyway, now you have shown that you don't know what the notation means
> you simply can't make any valid comment on the proof. You need to clear
> this up now or everything you write will be bogus.
>
> For a student (one who was interested in learning stuff) I'd give this
> simpler example: a "parity decider" TM could be defined like this:
>
> P.q0 <n> ⊦* P.gy if n is even, and
> P.q0 <n> ⊦* P.gn if n is odd.
>
> See how the condition refers to the number encoded by the string on the
> initial tape but the TM is not given a number, how could it be? All TMs
> operate on string representation of things, with the conditions
> expressed in terms of the things represented.
>
>>> The (near) copy of H embedded at Ĥ.qx goes thought the same transitions
>>> that H will when given the same input. I.e.
>>
>> It is an 100% perfectly exact copy
>
> ... with qy no longer a final state, and ...
>
>> with an infinite loop appended to
>> the Ĥ.qy path. Figure 12.2 shows that the state qy is not removed.
>
> It's an 100% perfectly exact copy except for the differences, yes. It
> hardly matters (since it's the transitions to qy and qn that matter),
> but your refusal to admit you are wrong even, about a trivial detail, is
> very telling.
>
I finally have enough of the proper way to say things to say what I mean
clearly unambiguously:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

Linz figure 12.2 shows that Ĥ.qy still exists.

The embedded full copy of H at Ĥ.qx is actually computing
the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
THIS CHANGES EVERYTHING.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/23/2021 9:26 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/23/2021 9:01 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/22/2021 9:42 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. // Linz says this
>>>>> And, more importantly, I say that. I don't want to defend Linz's proof
>>>>> since we both know it has an error in it (though a minor one). Here's
>>>>> my proof again:
>>>>> If a TM, H, existed such that
>>>>> Hq0 <M> s ⊦* Hqy if M applied to s halts, and
>>>>> Hq0 <M> s ⊦* Hqn if M applied to s does not halt,
>>>>> we could construct from it an H' such that
>>>>> H'q0 <M> s ⊦* oo if M applied to s halts, and
>>>>> H'q0 <M> s ⊦* H'qn if M applied to s does not halt.
>>>>> And from that we could construct an Ĥ such that
>>>>> Ĥq0 <M> ⊦* Ĥqx <M> <M> ⊦* oo if M applied to <M> halts, and
>>>>> Ĥq0 <M> ⊦* Ĥqx <M> <M> ⊦* Ĥqn if M applied to <M> does not halt.
>>>>> Setting M to Ĥ, so <M> becomes <Ĥ>, we see that the existence of H (as
>>>>> Linz defines it) logically entails that a TM Ĥ that does this
>>>>> Ĥq0 <Ĥ> ⊦* Ĥqx <Ĥ> <Ĥ> ⊦* oo if Ĥ applied to <Ĥ> halts, and
>>>>> Ĥq0 <Ĥ> ⊦* Ĥqx <Ĥ> <Ĥ> ⊦* Ĥqn if Ĥ applied to <Ĥ> does not halt.
>>>>> would also have to exist.
>>>>>
>>>>>> Because you have a dogmatic brain incapable of reasoning on its own
>>>>>> you are incapable of directly seeing that Linz's words are not
>>>>>> infallible.
>>>>>
>>>>> Curious then, that I have written about, and agreed with you about, the
>>>>> mistake in Linz's proof. (I much prefer the real proof in Linz -- the
>>>>> one you have never even read. Don't try, you won't understand it.)
>>>>>
>>>>>> It is not the case that Ĥ has Ĥ as its input
>>>>>
>>>>> Indeed. Did you ever think it did?
>>>>
>>>> That is what the if Ĥ applied to <Ĥ> means:
>>> No it doesn't. How many years have you been trying to understand this
>>> simple notation? And, more to the point, why bring this up now? Did you
>>> think, for the last 15 or so years, the TMs could be given TMs as input?
>>> (These are not rhetorical questions but I don't expect you'll answer
>>> them. You spend a lot of time avoiding direct questions.)
>>> Anyway, now you have shown that you don't know what the notation means
>>> you simply can't make any valid comment on the proof. You need to clear
>>> this up now or everything you write will be bogus.
>>> For a student (one who was interested in learning stuff) I'd give this
>>> simpler example: a "parity decider" TM could be defined like this:
>>> P.q0 <n> ⊦* P.gy if n is even, and
>>> P.q0 <n> ⊦* P.gn if n is odd.
>>> See how the condition refers to the number encoded by the string on the
>>> initial tape but the TM is not given a number, how could it be? All TMs
>>> operate on string representation of things, with the conditions
>>> expressed in terms of the things represented.
>>>
>>>>> The (near) copy of H embedded at Ĥ.qx goes thought the same transitions
>>>>> that H will when given the same input. I.e.
>>>>
>>>> It is an 100% perfectly exact copy
>>> ... with qy no longer a final state, and ...
>>>
>>>> with an infinite loop appended to
>>>> the Ĥ.qy path. Figure 12.2 shows that the state qy is not removed.
>>> It's an 100% perfectly exact copy except for the differences, yes. It
>>> hardly matters (since it's the transitions to qy and qn that matter),
>>> but your refusal to admit you are wrong even, about a trivial detail, is
>>> very telling.
>>>
>> I finally have enough of the proper way to say things to say what I
>> mean clearly unambiguously:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if Ĥ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>> Linz figure 12.2 shows that Ĥ.qy still exists.
>>
>> The embedded full copy of H at Ĥ.qx is actually computing
>> the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>
> Yes! Not sure why it took you so long but you did explicitly deny this
> for some time.
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>
> (You are still not stating it entirely property, hence my re-write, but
> talking about the mapping from the input to some state or other is
> relatively clear.)
>
>> THIS CHANGES EVERYTHING.
>
> It does indeed! Congratulations! What do you plan to work on now?
>

Your "correction" is incorrect.

The input to the embedded copy of H at Ĥ.qx has been defined with a
dependency on the behavior of this embedded copy. It has no such
dependency on the original H that is not embedded at Ĥ.qx.

The embedded copy of H at Ĥ.qx computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
or Ĥ.qn.

When the embedded copy of H at Ĥ.qx computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
Ĥ.qy or Ĥ.qn by simulating N steps of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ it determines
that even the simulation of an infinite number of steps of ⟨Ĥ⟩ applied
to ⟨Ĥ⟩ never stops running.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/23/2021 5:18 PM, André G. Isaak wrote:
> On 2021-12-23 15:38, olcott wrote:
>> On 12/23/2021 4:08 PM, André G. Isaak wrote:
>>> On 2021-12-23 14:59, olcott wrote:
>
>>>> The full copy of the H halt decider at Ĥ.qx
>>>> computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn.
>>>>
>>>> This turns out to be entirely different than
>>>> determining whether or not Ĥ applied to ⟨Ĥ⟩ halts.
>>>
>>> Then your algorithm is broken since the copy of H at Ĥ.qx specifies
>>> the *exact* same decision criteria as H does.
>>
>> No it freaking well does not.
>> Ĥ trasitions to its final state on the basis of what Ĥ.qx decides.
>
> And according to the Linz definition of Ĥ, Ĥ.qx transitions to Ĥ.qy iff
> Ĥ applied to ⟨Ĥ⟩ halts, and to Ĥ.qn iff Ĥ applied to ⟨Ĥ⟩ does not halt.
>

How many times do I have to tell you that this is incorrect because it
is not the same thing as the mapping that the full copy of H computes
from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn ???

> If your decider bases its decision on different criteria from these,
> then it is *not* an implementation of the Linz Ĥ.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/23/2021 7:24 PM, André G. Isaak wrote:
> On 2021-12-23 17:37, olcott wrote:
>> On 12/23/2021 5:18 PM, André G. Isaak wrote:
>>> On 2021-12-23 15:38, olcott wrote:
>>>> On 12/23/2021 4:08 PM, André G. Isaak wrote:
>>>>> On 2021-12-23 14:59, olcott wrote:
>>>
>>>>>> The full copy of the H halt decider at Ĥ.qx
>>>>>> computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn.
>>>>>>
>>>>>> This turns out to be entirely different than
>>>>>> determining whether or not Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>
>>>>> Then your algorithm is broken since the copy of H at Ĥ.qx specifies
>>>>> the *exact* same decision criteria as H does.
>>>>
>>>> No it freaking well does not.
>>>> Ĥ trasitions to its final state on the basis of what Ĥ.qx decides.
>>>
>>> And according to the Linz definition of Ĥ, Ĥ.qx transitions to Ĥ.qy
>>> iff Ĥ applied to ⟨Ĥ⟩ halts, and to Ĥ.qn iff Ĥ applied to ⟨Ĥ⟩ does not
>>> halt.
>>>
>>
>> How many times do I have to tell you that this is incorrect because it
>> is not the same thing as the mapping that the full copy of H computes
>> from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn ???
>
> It may be the case that YOUR algorithm computes something different, but
> then your algorithm fails to meet the definition for Linz's Ĥ.
>

It is a verified fact that Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinite
recursion to every simulating halt decider such that Ĥ.qx must abort its
simulation of this input.

Once we comprehend that this is a verified fact then it is also a
verified fact that H need not to abort its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ because
Ĥ.qx has already done that.

I honestly don't see why you keep having difficulty with this.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/24/2021 9:39 PM, André G. Isaak wrote:
> On 2021-12-24 19:49, olcott wrote:
>
>> Because Ben's augmented notation would apply at every nested
>> simulation level it may be a significant increase in clarity.
>>
>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>
> Why are you happy with this, despite the fact that UTM(wM, w) is *not*
> an input to H, but you object to the following
>

Ben provided (credit where credit is due) a key notational convention
that can be used to untangle the fact that the following is not any
matter of { Ĥ applied to ⟨Ĥ⟩ }

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The copy of H at Ĥ.qx computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
on the basis provided by Ben's notational convention.

UTM(wM, w) need not be any input to H. On the basis that UTM(x,y) is
computationally equivalent to the direct execution of x(y) we know that
Ben's notational convention does provide the correct criterion measure.

Finally we get past [Pete's Other Halting Problem] and show that this
criterion measure that I have been using all along has always been correct.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/25/2021 3:17 PM, Richard Damon wrote:
> On 12/25/21 3:41 PM, olcott wrote:
>> On 12/25/2021 2:07 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/24/2021 8:50 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/24/2021 3:29 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/23/2021 7:18 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>>>> I will stick to symbols.  So you think that one or both of
>>>>>>>>>
>>>>>>>>>          Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy  but  H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊬* H.qy
>>>>>>>>> or
>>>>>>>>>          Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn  but  H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊬* H.qn
>>>>>>>>>
>>>>>>>>> is possible?
>>>>> And, much to my surprise, you are clear that you do indeed claim the
>>>>> second of these to be true!
>>>>>
>>>>>>>>> If so, you are wrong.  If you don't, you agree with this:
>>>>>>>>>
>>>>>>>>>          Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy  if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>> H.qy
>>>>>>>>>          Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn  if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>> H.qn
>>>>>>>>
>>>>>>>> Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>      corresponds to
>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy
>>>>> <cut>
>>>>>> The copy of H at Ĥ.qx
>>>>> ... which is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ...
>>>>>
>>>>>> correctly decides that its input never halts.
>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts.
>>>>> I.e.
>>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn  if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> ⊢* H.qn
>>>>> but
>>>>>     H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>
>>>>> which is obviously absurd.  It's logically absurd, but even if you
>>>>> prevent logical deduction by removing the annotations (as you
>>>>> repeatedly
>>>>> do), it's still patently absurd to claim that the same state
>>>>> transition
>>>>> function and input results in different state transitions.
>>>>> At least you are not trying to hide anything.  You explicitly claim an
>>>>> absurdity.  No one can take this seriously.
>>>>
>>>> It is not absurd at all.
>>>
>>> If you can't see it, you are doomed to keep writing absurd things.
>>>
>>> One reason you can't see it is that you think waffle carries the same
>>> weight as logic.  If logic determines that some x must be less than
>>> three and greater than five, you will argue that x can see what it's
>>> being compared to and make itself very small or very big as needed.
>>>
>>
>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>>
>> As soon as H(x,y) knows that UTM(x,y) never halts it is always correct
>> for H to report that its input never halts.  THERE ARE NO EXCEPTIONS
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> NO!!!!

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt

When the copy of H embedded at Ĥ.qx is the above H then

Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ Never Halts Therefore:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

This is a tautology.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/26/2021 3:36 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/25/2021 7:27 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/25/2021 2:07 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/24/2021 8:50 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/24/2021 3:29 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 12/23/2021 7:18 PM, Ben Bacarisse wrote:
>>>>>>>
>>>>>>>>>>> I will stick to symbols. So you think that one or both of
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy but H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊬* H.qy
>>>>>>>>>>> or
>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn but H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊬* H.qn
>>>>>>>>>>>
>>>>>>>>>>> is possible?
>>>>>>> And, much to my surprise, you are clear that you do indeed claim the
>>>>>>> second of these to be true!
>>>>>>>
>>>>>>>>>>> If so, you are wrong. If you don't, you agree with this:
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>>>
>>>>>>>>>> Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>> corresponds to
>>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy
>>>>>>> <cut>
>>>>>>>> The copy of H at Ĥ.qx
>>>>>>> ... which is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ ...
>>>>>>>
>>>>>>>> correctly decides that its input never halts.
>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts.
>>>>>>> I.e.
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>> but
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>
>>>>>>> which is obviously absurd. It's logically absurd, but even if you
>>>>>>> prevent logical deduction by removing the annotations (as you repeatedly
>>>>>>> do), it's still patently absurd to claim that the same state transition
>>>>>>> function and input results in different state transitions.
>>>>>>> At least you are not trying to hide anything. You explicitly claim an
>>>>>>> absurdity. No one can take this seriously.
> <cut diversions>
>
>> H.q0 wM w ⊢* H.qy // iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn // iff UTM(wM, w) does not halt
>
> You are frantically throwing up diversions. You claimed, above, that two
> identical sets of states and transitions can give rise to different
> configuration sequences:
>
> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
> corresponds to
> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>
> and, a little less vaguely:
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts."
>
> Formally, in the context of Linz's H/Ĥ you assert that:
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn but H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>
> You don't want to address this mistake, but it's the elephant in the
> room. If TMs don't act solely on the basis of their tape and state
> transition functions, then they are arbitrary and useless.
>
> It would be dishonest to keep posting other stuff in an attempt to try t
> get people to forget you ever said this. You must address it. But then
> I think you'd have to accept the proof.
>

That you keep ignoring my explanation is not at all the same thing as my
not having provided an explanation.

The embedded copy of H at Ĥ.qx determines that the pure simulation of
its input never halts.

H at determines that the pure simulation of its input halts because the
copy of itself as Ĥ.qx aborts its input.

If you have no interest what-so-ever in the truth and you only care
about forming a rebuttal that gullible fools that are hardly paying
attention will accept then continue on your way.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/27/2021 9:04 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/26/2021 7:44 PM, Ben Bacarisse wrote:
>
>>> The copy of H and H must give rise to exactly the same transitions.
>>> Simply stating otherwise does not address this basic misunderstanding.
>>> Maybe another copy of H can make the tea?
>
>> I think that your confusion may be that: H simulates Ḧ applied to ⟨Ḧ⟩
>> calls embedded_H simulates ⟨Ḧ⟩ ⟨Ḧ⟩ aborts its simulation transitions
>> to Ḧ.qn causing H to transition to H.qy IS A SINGLE COMPUTATION.
>
> I am not confused. Two identical TMs[1] will always go through the same
> state transitions when give identical inputs.
>

Not when the first instance of these is defined to behave differently
on the basis of the behavior of the second instance of these.

> [1] I should really qualify this by referring to isomorphic TMs, but
> that would probably confuse you even more. But I dare say that soon you
> will pull the "they are not identical" line because you do that sort of
> thing when you are stuck.
>

As long as H has a way to distinguish itself from an identical copy of
itself H applied to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to H.qy and embedded_H applied
to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to Ḧ.qn, otherwise they both transition to qn.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/27/2021 9:56 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/26/2021 7:37 PM, Ben Bacarisse wrote:
>
>>> The second point is so significant that you can't say /anything/ about
>>> TMs until you accept that you are wrong. No TM can be built around a
>>> copy of another in any reliable way, because in PO-land identical copies
>>> don't behave identically.
>>>
>>> All statements you make about TMs are simply junk until you accept that
>>> a TM's behaviour is determined slowly by the input and the state
>>> transition function.
>>
>> When we arrange one copy of a computation to change its behavior on
>> the basis of another copy of this computation thus be dependent on the
>> second copy whereas this second copy is not dependent on any other
>> computation then we can correctly expect different results.
>
> If it's a copy it behaves identically. A TM this does not behave like
> the one it is based on is not a copy. To arrange for a copy of a TM to
> behave differently, with the same tape, is just Orwellian double speak.
>
> You just need to put your hand up to the mistake and move on.
>

As long as H has a way to distinguish itself from an identical copy of
itself H applied to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to H.qy and embedded_H applied
to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to Ḧ.qn, otherwise they both transition to qn.

That H and embedded_H have different machine descriptions is how H can
distinguish itself from embedded_H. embedded_H has ∞ appended.

> We know your "two computations" ruse. It's been 100% clear since you
> claimed that Halts(Confound_Halts, Confound_Halts) == false is correct
> because of what Halts would do with line 15 commented out! You moved on
> from that, making Halts sensitive to its execution environment, but you
> can't pull that trick with TMs. The only execution environment a TM has
> is the current state and the tape contents.
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 12/28/2021 8:32 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/28/2021 6:32 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/27/2021 7:31 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/27/2021 9:56 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/26/2021 7:37 PM, Ben Bacarisse wrote:
>>>>>>>
>>>>>>>>> The second point is so significant that you can't say /anything/ about
>>>>>>>>> TMs until you accept that you are wrong. No TM can be built around a
>>>>>>>>> copy of another in any reliable way, because in PO-land identical copies
>>>>>>>>> don't behave identically.
>>>>>>>>>
>>>>>>>>> All statements you make about TMs are simply junk until you accept that
>>>>>>>>> a TM's behaviour is determined slowly by the input and the state
>>>>>>>>> transition function.
>>>>>>>>
>>>>>>>> When we arrange one copy of a computation to change its behavior on
>>>>>>>> the basis of another copy of this computation thus be dependent on the
>>>>>>>> second copy whereas this second copy is not dependent on any other
>>>>>>>> computation then we can correctly expect different results.
>>>>>>>
>>>>>>> If it's a copy it behaves identically. A TM this does not behave like
>>>>>>> the one it is based on is not a copy. To arrange for a copy of a TM to
>>>>>>> behave differently, with the same tape, is just Orwellian double speak.
>>>>>>> You just need to put your hand up to the mistake and move on.
>>>>>>
>>>>>> As long as H has a way to distinguish itself from an identical copy of
>>>>>> itself
>>>>> There is no such way. That's what "identical copy means" for Turing
>>>>> machines.
>>>>>
>>>>>> H applied to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to H.qy and embedded_H applied
>>>>>> to ⟨Ḧ⟩ ⟨Ḧ⟩ transitions to Ḧ.qn, otherwise they both transition to qn.
>>>>> And since there is no way for H to "distinguish itself", both
>>>>> transition to qn (or qy).
>>>>
>>>> Since humans can see that Ḧ applied to ⟨Ḧ⟩ never stops running unless
>>>> embedded_H aborts its simulation of ⟨Ḧ⟩ ⟨Ḧ⟩, humans can see that a
>>>> transition to Ḧ.qn is correct because it does correctly compute the
>>>> mapping from ⟨Ḧ⟩ ⟨Ḧ⟩ to Ḧ.qn on the basis of the behavior of UTM(⟨Ḧ⟩,
>>>> ⟨Ḧ⟩).
>>> Ḧ is built using an identical copy of an other TM (H). Until you
>>> acknowledge that you are wrong about two identical TMs transitioning to
>>> different states despite having identical tapes, it's impossible to
>>> discuss TMs like Ḧ at all.
>>
>> This is a moot point, the key issue is about embedded_H applied to ⟨Ḧ⟩
>> ⟨Ḧ⟩
>
> But while you believe (and assert) nonsense about embedded copies of
> TMs, discussion of them is futile. (Moot has two related meaning these
> days. It's not a good word to use.)
>

Because this is Irrefutable you keep dodging it.
Because this is Irrefutable you keep dodging it.
Because this is Irrefutable you keep dodging it.

Proving that embedded_H at Ĥ.qx correctly maps its inputs ⟨Ĥ⟩ ⟨Ĥ⟩ to
Ĥ.qn on the basis of the behavior of the UTM simulation of these inputs.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

*My criterion measure with Ben's notational conventions*
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

We know that H would correctly decide the halt status of its input on
the basis of correctly deciding the halt status of the UTM simulation of
its input.

We know this because a UTM simulation of the Turing machine description
is computationally equivalent to the direct execution of this same
Turing machine.

We know that the copy of H is at Ĥ.qx (AKA embedded_H) applies this
same criterion measure to every instance of embedded_H to any recursive
depth.

We know that this means that embedded_H is examining the behavior of Ĥ
applied to ⟨Ĥ⟩ as if embedded_H was (hypothetically) replaced by a UTM.

We know that the behavior of this hypothetical machine is the criterion
measure for embedded_H.

We know that Ĥ applied to ⟨Ĥ⟩ would never stop running if embedded_H was
replaced by a UTM because Ĥ applied to ⟨Ĥ⟩ copies its input then UTM ⟨Ĥ⟩
⟨Ĥ⟩ would repeat this cycle ...

We know that this means that when embedded_H computes the mapping from
its input ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the UTM simulation of
this input that its transition to Ĥ.qn is correct.

https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (315-320)

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer