https://www.liarparadox.org/Linz_Proof.pdf

This Turing Machine description at the top of page 3
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2

Is simplified and clarified to this:
when Ĥ is applied to ⟨Ĥ⟩

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

The advantage of the Linz proof is that it simultaneously represents
the entire infinite set of what would otherwise be an infinite set of
H/D pairs by using a single TM template for Ĥ.

*We can say that both yes and no are incorrect answers for every*
*embedded_H that attempts to answer the question*
Does the computation that I am contained within halt?

Any yes/no question that lacks a correct yes/no answer is an incorrect
question. The inability to correctly answer an incorrect question places
no limit on anyone or anything.

On the other hand when embedded_H is trying to answer the question:
Could my input terminate normally?
this question can be answered with a “no”.

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

On 10/25/23 3:25 PM, olcott wrote:
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This Turing Machine description at the top of page 3
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2

No, you are missing key details

q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞ IFF H WM WM went to qy
q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2 IFF H WM WM went to qn

And H WM d is supposed to go to qy if M d will halt, and to qn if it
will not halt in a bounded number of steps to be correct.

>
> Is simplified and clarified to this:
> when Ĥ is applied to ⟨Ĥ⟩
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Again,

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ IFF H ⟨Ĥ⟩ went to qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn IFF H ⟨Ĥ⟩ went to qn

>
> The advantage of the Linz proof is that it simultaneously represents
> the entire infinite set of what would otherwise be an infinite set of
> H/D pairs by using a single TM template for Ĥ.

Not quite, as H is a DEFINED machine, and embedded_H must be a copy of
that H.

>
> *We can say that both yes and no are incorrect answers for every*
> *embedded_H that attempts to answer the question*
> Does the computation that I am contained within halt?

So, that just means H and embedded_H are always wrong, what it the
problem with that.

The question was, can you make an H that was correct.

The question that H needs to answer is "Does the computation described
by the input Halt?", and if H goes to qn, the right answer is yes, and
if H goes to qy, the right answer is No, so there is always a correct
answer, its just that H never gives it for the input built by this formula.

>
> Any yes/no question that lacks a correct yes/no answer is an incorrect
> question. The inability to correctly answer an incorrect question places
> no limit on anyone or anything.

But you are asking the WRONG question.

The question ISN'T what does H / embedded_H need to return to be right,
but what is the correct answer for the given input.

>
> On the other hand when embedded_H is trying to answer the question:
> Could my input terminate normally?
> this question can be answered with a “no”.
>

But that isn't the right question, but a strawman.

In actuality, since your H goes to qn, then the RIGHT answer to the
halting question is YES the input represents a halting computation, so
it should have gone to qn.

You are just continuing to prove your stupidity.

You are just showing that you totally don't understand the nature of the
problem, by the parts you keep leaving out.

On 10/25/2023 5:25 PM, olcott wrote:
> https://www.liarparadox.org/Linz_Proof.pdf
>
> This Turing Machine description at the top of page 3
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>
> Is simplified and clarified to this:
> when Ĥ is applied to ⟨Ĥ⟩
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The advantage of the Linz proof is that it simultaneously represents
> the entire infinite set of what would otherwise be an infinite set of
> H/D pairs by using a single TM template for Ĥ.
>
> *We can say that both yes and no are incorrect answers for every*
> *embedded_H that attempts to answer the question*
> Does the computation that I am contained within halt?

When we accept the idea of a pure function and that computations
must be pure functions then we know that it would be incorrect
for H to report on the computation that itself is contained within.

embedded_H cannot even see the computation that itself is contained
within it can only see the behavior of its actual input.

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

On 10/25/23 4:01 PM, olcott wrote:
> On 10/25/2023 5:25 PM, olcott wrote:
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>> This Turing Machine description at the top of page 3
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>
>> Is simplified and clarified to this:
>> when Ĥ is applied to ⟨Ĥ⟩
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The advantage of the Linz proof is that it simultaneously represents
>> the entire infinite set of what would otherwise be an infinite set of
>> H/D pairs by using a single TM template for Ĥ.
>>
>> *We can say that both yes and no are incorrect answers for every*
>> *embedded_H that attempts to answer the question*
>> Does the computation that I am contained within halt?
>
>
> When we accept the idea of a pure function and that computations
> must be pure functions then we know that it would be incorrect
> for H to report on the computation that itself is contained within.

Right, it is impossible to write an input that tries to actually use the
decider that is deciding on it, as such an input would not represent an
actual computation.

Thus, "the input" that the decider needs to decide on is always the
specific input of that problem, built on a specific decider, and that
input thus always has a defined behavior, and thus a correct answer.

Thus we START choosing a decider, and then we can built an input, and
that input WILL have a correct answer, it just is a fact that the
decider doesn't give it.

The fact the actual question, "Does the computation represented by the
input halt?" actually has a correct answer for every possible version of
this problem, means it is a valid question.

The fact that no decider can give the right answer for some particular
input, means that no decider is actually correct, and thus the problme
is uncomputable.

>
> embedded_H cannot even see the computation that itself is contained
> within it can only see the behavior of its actual input.
>

Right, it needs to answer about the computataion specified by the input.

And the fact that the computation specified by the input just happens to
match itself is thus irrelevent to the validity of the question, since
the problem statement is to try to handle ALL inputs, and this input is
a member of the input set.

You keep on trying to make the input dependent on the decider it is run
on, THAT is incorrect. The input is based on the decider that it was
built to prove wrong, and is thus a FIXED input, with an answer.

Your problem seems to be that you want to limit the behavior that H is
required to answer on to be something that it can actually compute.

You try to make Ĥ to not have a "correct" answer, but Ĥ isn't a decider,
so it doesn't need to have any particular answer. It just has defined
behavior, that H needs to correctly predict for *H* to be correct.

H is the machine that needs to have the "correct" behavior to be right,
and that behavior is fixed by the code the defines H.

The fact that we can't possibly write an H that gives the correct answer
to this particular input just means that the question is uncomputable,
not "invalid".

On 10/25/2023 6:01 PM, olcott wrote:
> On 10/25/2023 5:25 PM, olcott wrote:
>> https://www.liarparadox.org/Linz_Proof.pdf
>>
>> This Turing Machine description at the top of page 3
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>
>> Is simplified and clarified to this:
>> when Ĥ is applied to ⟨Ĥ⟩
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> The advantage of the Linz proof is that it simultaneously represents
>> the entire infinite set of what would otherwise be an infinite set of
>> H/D pairs by using a single TM template for Ĥ.
>>
>> *We can say that both yes and no are incorrect answers for every*
>> *embedded_H that attempts to answer the question*
>> Does the computation that I am contained within halt?
>
>
> When we accept the idea of a pure function and that computations
> must be pure functions then we know that it would be incorrect
> for H to report on the computation that itself is contained within.
>
> embedded_H cannot even see the computation that itself is contained
> within it can only see the behavior of its actual input.

Right, it needs to answer about the computataion specified by the input.

Thus embedded_H is not allowed to report on the behavior of the
directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
is contained within.

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

On 10/25/23 5:55 PM, olcott wrote:
> On 10/25/2023 6:01 PM, olcott wrote:
>> On 10/25/2023 5:25 PM, olcott wrote:
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This Turing Machine description at the top of page 3
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>
>>> Is simplified and clarified to this:
>>> when Ĥ is applied to ⟨Ĥ⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The advantage of the Linz proof is that it simultaneously represents
>>> the entire infinite set of what would otherwise be an infinite set of
>>> H/D pairs by using a single TM template for Ĥ.
>>>
>>> *We can say that both yes and no are incorrect answers for every*
>>> *embedded_H that attempts to answer the question*
>>> Does the computation that I am contained within halt?
>>
>>
>> When we accept the idea of a pure function and that computations
>> must be pure functions then we know that it would be incorrect
>> for H to report on the computation that itself is contained within.
>>
>> embedded_H cannot even see the computation that itself is contained
>> within it can only see the behavior of its actual input.
>
> Right, it needs to answer about the computataion specified by the input.
>
> Thus embedded_H is not allowed to report on the behavior of the
> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
> is contained within.
>

It is ALSO the computation specified by the input.

So, it IS the criteria the answer, to be correct, needs to be based on.

What else would the answer to:

"Does the computation reprented by the input Halt?" refer to?

What other computation does the input represent?

I think you understand that you have been lying about this for years.

That, or you are admitting that you are a total idiot, as it HAS been
pointed out to you many times.

On 10/25/2023 7:55 PM, olcott wrote:
> On 10/25/2023 6:01 PM, olcott wrote:
>> On 10/25/2023 5:25 PM, olcott wrote:
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This Turing Machine description at the top of page 3
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>
>>> Is simplified and clarified to this:
>>> when Ĥ is applied to ⟨Ĥ⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The advantage of the Linz proof is that it simultaneously represents
>>> the entire infinite set of what would otherwise be an infinite set of
>>> H/D pairs by using a single TM template for Ĥ.
>>>
>>> *We can say that both yes and no are incorrect answers for every*
>>> *embedded_H that attempts to answer the question*
>>> Does the computation that I am contained within halt?
>>
>>
>> When we accept the idea of a pure function and that computations
>> must be pure functions then we know that it would be incorrect
>> for H to report on the computation that itself is contained within.
>>
>> embedded_H cannot even see the computation that itself is contained
>> within it can only see the behavior of its actual input.
>
> Right, it needs to answer about the computataion specified by the input.
>
> Thus embedded_H is not allowed to report on the behavior of the
> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
> is contained within.

It <is> not the computation that is specified by the
input because the computation specified by the input
includes that Ĥ is invoking embedded_H recursively.

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

On 10/25/2023 7:55 PM, olcott wrote:
> On 10/25/2023 6:01 PM, olcott wrote:
>> On 10/25/2023 5:25 PM, olcott wrote:
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This Turing Machine description at the top of page 3
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>
>>> Is simplified and clarified to this:
>>> when Ĥ is applied to ⟨Ĥ⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The advantage of the Linz proof is that it simultaneously represents
>>> the entire infinite set of what would otherwise be an infinite set of
>>> H/D pairs by using a single TM template for Ĥ.
>>>
>>> *We can say that both yes and no are incorrect answers for every*
>>> *embedded_H that attempts to answer the question*
>>> Does the computation that I am contained within halt?
>>
>>
>> When we accept the idea of a pure function and that computations
>> must be pure functions then we know that it would be incorrect
>> for H to report on the computation that itself is contained within.
>>
>> embedded_H cannot even see the computation that itself is contained
>> within it can only see the behavior of its actual input.
>
> Right, it needs to answer about the computataion specified by the input.
>
> Thus embedded_H is not allowed to report on the behavior of the
> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
> is contained within.

Since it is WRONG for embedded_H to report on the behavior of the direct
execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

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

On 10/25/23 7:07 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> It <is> not the computation that is specified by the
> input because the computation specified by the input
> includes that Ĥ is invoking embedded_H recursively.
>

No, it specifies that Ĥ is using a COPY of H, so there is NO "recursive"
call.

Ĥ is using a copy of H that needs to determine (to be correct) what the
input that it is give will do when run.

You are just talking about your INCORRECT reframing, that isn't actually
equivalent, since it has Ĥ using the decider deciding on it instead of
the decider that it is supposed to be built on.

On 10/25/23 7:13 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> Since it is WRONG for embedded_H to report on the behavior of the direct
> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>

Why? Since that *IS* what the question is asking?

Don't you understand what the words mean.

If your name is Peter, and so is your boss, if someone asks you the name
of your boss, would it be incorrect to answer Peter because that
happened to also be your name?

You clearly don't understand what you are talking about.

On 10/25/2023 7:55 PM, olcott wrote:
> On 10/25/2023 6:01 PM, olcott wrote:
>> On 10/25/2023 5:25 PM, olcott wrote:
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This Turing Machine description at the top of page 3
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>
>>> Is simplified and clarified to this:
>>> when Ĥ is applied to ⟨Ĥ⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The advantage of the Linz proof is that it simultaneously represents
>>> the entire infinite set of what would otherwise be an infinite set of
>>> H/D pairs by using a single TM template for Ĥ.
>>>
>>> *We can say that both yes and no are incorrect answers for every*
>>> *embedded_H that attempts to answer the question*
>>> Does the computation that I am contained within halt?
>>
>>
>> When we accept the idea of a pure function and that computations
>> must be pure functions then we know that it would be incorrect
>> for H to report on the computation that itself is contained within.
>>
>> embedded_H cannot even see the computation that itself is contained
>> within it can only see the behavior of its actual input.
>
> Right, it needs to answer about the computataion specified by the input.
>
> Thus embedded_H is not allowed to report on the behavior of the
> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
> is contained within.

Since it is WRONG for embedded_H to report on the behavior of the direct
execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

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

On 10/25/23 8:01 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> Since it is WRONG for embedded_H to report on the behavior of the direct
> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>

Nope, and you are just admitting you are a stupid idiot.

H MUST report on the behavior of its input, NO MATTER WHAT THAT INPUT IS.

There is no "rule" that it can't report on the direct execution of Ĥ
⟨Ĥ⟩, where are you getting that?

It can't see "itself", but the input isn't "itself", it is just a
machine that has a copy of itself.

There is no way to "code" a Turing Machine to some how know if it is
embedded in another machine, or what that machine is if it is.

It is wrong to make it change its mind based on who is using it, and
embedded_H is Identical to H, then if it is incorrect to ask it about
the input (Ĥ) ⟨Ĥ⟩ which represents Ĥ ⟨Ĥ⟩ then it must be invalid to ask
H about that either, and thus H has specifically said it isn't a proper
Halt Decider, since a Halt Decider needs to be able to answer about ANY
computation.

So, you are just admitting you have been lying that H actually is a Halt
Decider, or even a partial Halt Decier that handles the pathological
case, since that is PRECISELY the case you say it can't handle.

Thus, you are admitting you life has been a waste because your argument
is based on your lies.

On 10/25/2023 10:01 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> Since it is WRONG for embedded_H to report on the behavior of the direct
> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>

Only stupid idiots call other people stupid idiots.

People that are not stupid idiots realize that ad
hominem attacks from them directed at others make
them look very foolish.

AD Hominem attacks on others is a direct admission
that one has run out of reasoning.

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

On 10/25/2023 7:55 PM, olcott wrote:
> On 10/25/2023 6:01 PM, olcott wrote:
>> On 10/25/2023 5:25 PM, olcott wrote:
>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>> This Turing Machine description at the top of page 3
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>
>>> Is simplified and clarified to this:
>>> when Ĥ is applied to ⟨Ĥ⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> The advantage of the Linz proof is that it simultaneously represents
>>> the entire infinite set of what would otherwise be an infinite set of
>>> H/D pairs by using a single TM template for Ĥ.
>>>
>>> *We can say that both yes and no are incorrect answers for every*
>>> *embedded_H that attempts to answer the question*
>>> Does the computation that I am contained within halt?
>>
>>
>> When we accept the idea of a pure function and that computations
>> must be pure functions then we know that it would be incorrect
>> for H to report on the computation that itself is contained within.
>>
>> embedded_H cannot even see the computation that itself is contained
>> within it can only see the behavior of its actual input.
>
> Right, it needs to answer about the computataion specified by the input.
>
> Thus embedded_H is not allowed to report on the behavior of the
> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
> is contained within.

Since it is WRONG for embedded_H to report on the behavior of the direct
execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

The computation that embedded_H is contained within is
not the input and does not have the behavior of the input.

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

On 10/25/23 8:50 PM, olcott wrote:
> On 10/25/2023 10:01 PM, olcott wrote:
>> On 10/25/2023 7:55 PM, olcott wrote:
>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> This Turing Machine description at the top of page 3
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>
>>>>> Is simplified and clarified to this:
>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>
>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>> *embedded_H that attempts to answer the question*
>>>>> Does the computation that I am contained within halt?
>>>>
>>>>
>>>> When we accept the idea of a pure function and that computations
>>>> must be pure functions then we know that it would be incorrect
>>>> for H to report on the computation that itself is contained within.
>>>>
>>>> embedded_H cannot even see the computation that itself is contained
>>>> within it can only see the behavior of its actual input.
>>>
>>> Right, it needs to answer about the computataion specified by the input.
>>>
>>> Thus embedded_H is not allowed to report on the behavior of the
>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>> is contained within.
>>
>> Since it is WRONG for embedded_H to report on the behavior of the direct
>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>>
>
> Only stupid idiots call other people stupid idiots.

So, you are admitting you are a stupid idiot?

>
> People that are not stupid idiots realize that ad
> hominem attacks from them directed at others make
> them look very foolish.
>
> AD Hominem attacks on others is a direct admission
> that one has run out of reasoning.
>

So, you don't understand what an ad hominem attack is!

Just shows how stupid you are.

Note, that ISN'T an ad hominem, because I am pointing out your stupidity
as being shown by the words you used, NOT claim you are wrong because
you are stupid.

You are just PROVING your stupidity.

Note, you can't even quote the statement you want to accuse me with.

I guess it is because you know it will show that you don't actually have
any ground to stand on.

As you continue to use invalid arguements, you are just proving your
ignorance of the system.

Sorry that you are so dumb.

On 10/25/23 8:56 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> Since it is WRONG for embedded_H to report on the behavior of the direct
> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>
> The computation that embedded_H is contained within is
> not the input and does not have the behavior of the input.
>

Repeating your errors and not responding to the errors point out is just
an admission that you don't actually have any valid arguement, but are
just engaged in a "Big Lie" campaign and don't actually care about what
is true.

Igt CAN'T be wrong for embedded_H to report on the behavior of the
direct execution of Ĥ ⟨Ĥ⟩ if that is what the input represents. So, your
arguement is just based on LIES.

If the input is not a representation of this particular comuptation that
embedded_H is contained within, namely Ĥ ⟨Ĥ⟩, then your input is formed
incorrectly, and thus you are again shown to be a LIAR.

if (Ĥ) ⟨Ĥ⟩ is not the representation of Ĥ ⟨Ĥ⟩, then you are just shown
to be a LIAR in that you claim you have built the system by the rules of
the proof.

I guess you are just admitting you are just a stupid lying idiot because
you say what you have claimed can't be true, therefore you are calling
yourself a liar.

On 10/25/2023 10:50 PM, olcott wrote:
> On 10/25/2023 10:01 PM, olcott wrote:
>> On 10/25/2023 7:55 PM, olcott wrote:
>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> This Turing Machine description at the top of page 3
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>
>>>>> Is simplified and clarified to this:
>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>
>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>> *embedded_H that attempts to answer the question*
>>>>> Does the computation that I am contained within halt?
>>>>
>>>>
>>>> When we accept the idea of a pure function and that computations
>>>> must be pure functions then we know that it would be incorrect
>>>> for H to report on the computation that itself is contained within.
>>>>
>>>> embedded_H cannot even see the computation that itself is contained
>>>> within it can only see the behavior of its actual input.
>>>
>>> Right, it needs to answer about the computataion specified by the input.
>>>
>>> Thus embedded_H is not allowed to report on the behavior of the
>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>> is contained within.
>>
>> Since it is WRONG for embedded_H to report on the behavior of the direct
>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>>
>
> Only stupid idiots call other people stupid idiots.
>
> People that are not stupid idiots realize that ad
> hominem attacks from them directed at others make
> them look very foolish.
>
> AD Hominem attacks on others is a direct admission
> that one has run out of reasoning.
>

Nothing but insults without any reasoning is one
of the stupidest things to do within the context
of fields having professional decorum.

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

On 10/25/23 9:25 PM, olcott wrote:
> On 10/25/2023 10:50 PM, olcott wrote:
>> On 10/25/2023 10:01 PM, olcott wrote:
>>> On 10/25/2023 7:55 PM, olcott wrote:
>>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>
>>>>>> This Turing Machine description at the top of page 3
>>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>>
>>>>>> Is simplified and clarified to this:
>>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>>
>>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>>> *embedded_H that attempts to answer the question*
>>>>>> Does the computation that I am contained within halt?
>>>>>
>>>>>
>>>>> When we accept the idea of a pure function and that computations
>>>>> must be pure functions then we know that it would be incorrect
>>>>> for H to report on the computation that itself is contained within.
>>>>>
>>>>> embedded_H cannot even see the computation that itself is contained
>>>>> within it can only see the behavior of its actual input.
>>>>
>>>> Right, it needs to answer about the computataion specified by the
>>>> input.
>>>>
>>>> Thus embedded_H is not allowed to report on the behavior of the
>>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>>> is contained within.
>>>
>>> Since it is WRONG for embedded_H to report on the behavior of the direct
>>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>>>
>>
>> Only stupid idiots call other people stupid idiots.
>>
>> People that are not stupid idiots realize that ad
>> hominem attacks from them directed at others make
>> them look very foolish.
>>
>> AD Hominem attacks on others is a direct admission
>> that one has run out of reasoning.
>>
>
> Nothing but insults without any reasoning is one
> of the stupidest things to do within the context
> of fields having professional decorum.
>

The fact that you don't understand the reasoning that is being use to
support the insults, just proves they are correct.

Your refusal to quote them, implies you agree with that.

On 10/25/2023 9:13 PM, olcott wrote:
> On 10/25/2023 7:55 PM, olcott wrote:
>> On 10/25/2023 6:01 PM, olcott wrote:
>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>
>>>> This Turing Machine description at the top of page 3
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>
>>>> Is simplified and clarified to this:
>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The advantage of the Linz proof is that it simultaneously represents
>>>> the entire infinite set of what would otherwise be an infinite set of
>>>> H/D pairs by using a single TM template for Ĥ.
>>>>
>>>> *We can say that both yes and no are incorrect answers for every*
>>>> *embedded_H that attempts to answer the question*
>>>> Does the computation that I am contained within halt?
>>>
>>>
>>> When we accept the idea of a pure function and that computations
>>> must be pure functions then we know that it would be incorrect
>>> for H to report on the computation that itself is contained within.
>>>
>>> embedded_H cannot even see the computation that itself is contained
>>> within it can only see the behavior of its actual input.
>>
>> Right, it needs to answer about the computataion specified by the input.
>>
>> Thus embedded_H is not allowed to report on the behavior of the
>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>> is contained within.
>
> Since it is WRONG for embedded_H to report on the behavior of the direct
> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

People that understand that computable functions must be a pure
function of their inputs and thus are not allowed to report on
the computation that they are contained within also understand

that embedded_H is not allowed to report that the direct execution
of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

We a few repetitions people that are not quite smart enough
eventually get this.

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

On 10/25/23 9:34 PM, olcott wrote:
> On 10/25/2023 9:13 PM, olcott wrote:
>> On 10/25/2023 7:55 PM, olcott wrote:
>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> This Turing Machine description at the top of page 3
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>
>>>>> Is simplified and clarified to this:
>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>
>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>> *embedded_H that attempts to answer the question*
>>>>> Does the computation that I am contained within halt?
>>>>
>>>>
>>>> When we accept the idea of a pure function and that computations
>>>> must be pure functions then we know that it would be incorrect
>>>> for H to report on the computation that itself is contained within.
>>>>
>>>> embedded_H cannot even see the computation that itself is contained
>>>> within it can only see the behavior of its actual input.
>>>
>>> Right, it needs to answer about the computataion specified by the input.
>>>
>>> Thus embedded_H is not allowed to report on the behavior of the
>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>> is contained within.
>>
>> Since it is WRONG for embedded_H to report on the behavior of the direct
>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>
> People that understand that computable functions must be a pure
> function of their inputs and thus are not allowed to report on
> the computation that they are contained within also understand
>
> that embedded_H is not allowed to report that the direct execution
> of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>
> We a few repetitions people that are not quite smart enough
> eventually get this.
>
IF H / embedded_H is a pure function, how can it tell that it is being
called by Ĥ to change its behavior on the input (Ĥ) (Ĥ)?

The fact that is CAN'T means that you 'arguement' that the fact that the
input matches the machine it is part of is just a big fat LIE

The fat that you don't quote the message that point out your errors, but
you just repeat your erroneous claims show that you know tha tyou
arguments don't actually answer the problems reveiled.

You are just proving your stupidity.

On 10/25/2023 11:34 PM, olcott wrote:
> On 10/25/2023 9:13 PM, olcott wrote:
>> On 10/25/2023 7:55 PM, olcott wrote:
>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>
>>>>> This Turing Machine description at the top of page 3
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>
>>>>> Is simplified and clarified to this:
>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>
>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>> *embedded_H that attempts to answer the question*
>>>>> Does the computation that I am contained within halt?
>>>>
>>>>
>>>> When we accept the idea of a pure function and that computations
>>>> must be pure functions then we know that it would be incorrect
>>>> for H to report on the computation that itself is contained within.
>>>>
>>>> embedded_H cannot even see the computation that itself is contained
>>>> within it can only see the behavior of its actual input.
>>>
>>> Right, it needs to answer about the computataion specified by the input.
>>>
>>> Thus embedded_H is not allowed to report on the behavior of the
>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>> is contained within.
>>
>> Since it is WRONG for embedded_H to report on the behavior of the direct
>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>
> People that understand that computable functions must be a pure
> function of their inputs and thus are not allowed to report on
> the computation that they are contained within also understand
>
> that embedded_H is not allowed to report that the direct execution
> of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>
> We a few repetitions people that are not quite smart enough
> eventually get this.
>

IF H / embedded_H is a pure function, how can it tell that it is being
called by Ĥ to change its behavior on the input (Ĥ) (Ĥ)?

It cannot, that is why it must rely on ⟨Ĥ⟩ correctly
simulated by embedded_H as its only valid measure.

embedded_H is expressly not allowed to consider that
Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.

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

On 10/26/23 8:45 AM, olcott wrote:
> On 10/25/2023 11:34 PM, olcott wrote:
>> On 10/25/2023 9:13 PM, olcott wrote:
>>> On 10/25/2023 7:55 PM, olcott wrote:
>>>> On 10/25/2023 6:01 PM, olcott wrote:
>>>>> On 10/25/2023 5:25 PM, olcott wrote:
>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
>>>>>>
>>>>>> This Turing Machine description at the top of page 3
>>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ ∞
>>>>>> q0 WM ⊢* Ĥq0 WM WM ⊢* Ĥ y1 qn y2
>>>>>>
>>>>>> Is simplified and clarified to this:
>>>>>> when Ĥ is applied to ⟨Ĥ⟩
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The advantage of the Linz proof is that it simultaneously represents
>>>>>> the entire infinite set of what would otherwise be an infinite set of
>>>>>> H/D pairs by using a single TM template for Ĥ.
>>>>>>
>>>>>> *We can say that both yes and no are incorrect answers for every*
>>>>>> *embedded_H that attempts to answer the question*
>>>>>> Does the computation that I am contained within halt?
>>>>>
>>>>>
>>>>> When we accept the idea of a pure function and that computations
>>>>> must be pure functions then we know that it would be incorrect
>>>>> for H to report on the computation that itself is contained within.
>>>>>
>>>>> embedded_H cannot even see the computation that itself is contained
>>>>> within it can only see the behavior of its actual input.
>>>>
>>>> Right, it needs to answer about the computataion specified by the
>>>> input.
>>>>
>>>> Thus embedded_H is not allowed to report on the behavior of the
>>>> directly executed Ĥ ⟨Ĥ⟩ because that <is> the computation that it
>>>> is contained within.
>>>
>>> Since it is WRONG for embedded_H to report on the behavior of the direct
>>> execution of Ĥ ⟨Ĥ⟩, that means that embedded_H is not allowed to report
>>> that the direct execution of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>>
>> People that understand that computable functions must be a pure
>> function of their inputs and thus are not allowed to report on
>> the computation that they are contained within also understand
>>
>> that embedded_H is not allowed to report that the direct execution
>> of Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>>
>> We a few repetitions people that are not quite smart enough
>> eventually get this.
>>
>
> IF H / embedded_H is a pure function, how can it tell that it is being
> called by Ĥ to change its behavior on the input (Ĥ) (Ĥ)?
>
> It cannot, that is why it must rely on ⟨Ĥ⟩ correctly
> simulated by embedded_H as its only valid measure.
>
> embedded_H is expressly not allowed to consider that
> Ĥ ⟨Ĥ⟩ reaches Ĥ.qn and halts.
>

It must give to correct answer to the problem given to it.

Where is the "rule" that says it can't consider that case? It *MUST*
consider that case or it violates the "All Inputs" requirement.

How can that possibly affect the behavior of the code that already
exists in H / embedded_H.

It only CAN use what it can compute, but the key is that it turns out
this is insufficient to actually be able to answer the question.

If embedded_H needs to rely on its correct simulation of the input, then
it needs to correctly simulate that input, which means its simulation
needs to reflect what the direct execution of the program the input
specifies will do. Since that program halts, since you claim H(D,D)
returns 0, that simulation must indicate the input is Halting, or the
simulation is incorrect, and embedded_H needs to blaim its own failing
to correctly simulate.

You want to ban the correct answer, because it shows that the
computation is impossible to do, but that it part of the question, *IS*
the computatoin possible.

You are just showing you don't understand that basics of computability,
or Truth, in your unfounded assumption that all quetions need to be
computable, or Truths provable.

Your illogical adherence to this false premise is just making you whole
logic system unsound and inconsistant.