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

embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
and halts because this requires embedded_H to report on the computation
that contains itself thus breaking the rule that all computations must
be a pure functions of their inputs.

--
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 11:17 AM, 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
>
> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
> and halts because this requires embedded_H to report on the computation
> that contains itself thus breaking the rule that all computations must
> be a pure functions of their inputs.
>

Nope, by the definition of H, (and thus embedded_H)

H WM d must go to qy if M d Halts, and to qn if M d never halts.

Thus, BY DEFINITION embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ must go to qy if Ĥ ⟨Ĥ⟩ halts and
to qn if it never halts, so your claim that it is not allowed to
consider that says you are refuting that your H meets its specification,
and thus ALL your logic is a LIE.

Where is the "express" statement that it can not (or even allowed to
not) consider the actual behavior of the input.

If it is an "expresa" limitation, it will be actuall stated somewhere in
the problem, which it isnt, so you are shown to be a LIAR.

Care to point out the "express" statement that you get this from?

Or, are you going to just gaslight yourself more with your Big Lie
Disinformation campaign?

Note, your refusal to quote and reply to the errors being pointed out
just reinforce the case that you have no actual grounds to your argument
and are admitting you have no answers to the rebuttals.

Yes, I am in "Rebuttal" mode, because you are in "Erroneous" mode, and
Errors need to be Rebutted. Your refusal to try a counter rebutal just
shows your illogic.

On 10/26/2023 1:17 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 ∞
> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
> and halts because this requires embedded_H to report on the computation
> that contains itself thus breaking the rule that all computations must
> be a pure functions of their inputs.
>

By the definition of computation that requires all computations to
be a pure function of their inputs no Turing Machine is allowed to
report on the computation that itself is contained within.

This utterly forbids embedded_H from reporting that the directly
executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.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 11:59 AM, olcott wrote:
> On 10/26/2023 1:17 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 ∞
>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>> and halts because this requires embedded_H to report on the computation
>> that contains itself thus breaking the rule that all computations must
>> be a pure functions of their inputs.
>>
>
> By the definition of computation that requires all computations to
> be a pure function of their inputs no Turing Machine is allowed to
> report on the computation that itself is contained within.
>
> This utterly forbids embedded_H from reporting that the directly
> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>
>

So, you don't know what the definition means, do you.

A Computation is a pure function, which means its answer can not vary
based on how it is "called", but only on the input it is given.

That does not mean it isn't allowed to report on a computation that is a
copy of a machine that includes a call to it.

Where do you get that idea?

Yes, you can't ask the Turing Machine that is literally asking
self-referentially about the machine that is "calling" it, because it
can't know what that is. You CAN ask about a machine that just happens
to include a copy of the machine itself, as that doesn't actually
"refer" to the machine, just uses a copy of it.

I guess part of your problem is you don;t understand what a "reference"
actual means, do you.

Is that you you never quote the messages you are replying to, because
you don't understand how to properly reference them?

I guess you are just proving your utter stupidity by your incorrect
arguments that just show how pitifully little you understand of the
field that you are claiming to be making breakthrough arguments in.

On 10/26/2023 1:59 PM, olcott wrote:
> On 10/26/2023 1:17 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 ∞
>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>> and halts because this requires embedded_H to report on the computation
>> that contains itself thus breaking the rule that all computations must
>> be a pure functions of their inputs.
>>
>
> By the definition of computation that requires all computations to
> be a pure function of their inputs no Turing Machine is allowed to
> report on the computation that itself is contained within.
>
> This utterly forbids embedded_H from reporting that the directly
> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>
>

A Computation is a pure function, which means its answer can not vary
based on how it is "called", but only on the input it is given.

That does not mean it isn't allowed to report on a computation that is a
copy of a machine that includes a call to it.

All of my reviews have consistently claimed that it must report
on the direct execution of its input and this is expressly not
allowed because itself is contained within this direct execution.

embedded_H is not allowed to report that
Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.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 12:43 PM, olcott wrote:
> On 10/26/2023 1:59 PM, olcott wrote:
>> On 10/26/2023 1:17 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 ∞
>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>>> and halts because this requires embedded_H to report on the computation
>>> that contains itself thus breaking the rule that all computations must
>>> be a pure functions of their inputs.
>>>
>>
>> By the definition of computation that requires all computations to
>> be a pure function of their inputs no Turing Machine is allowed to
>> report on the computation that itself is contained within.
>>
>> This utterly forbids embedded_H from reporting that the directly
>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>
>>
>
> A Computation is a pure function, which means its answer can not vary
> based on how it is "called", but only on the input it is given.
>
> That does not mean it isn't allowed to report on a computation that is a
> copy of a machine that includes a call to it.

Right, so why do you say it can'?

>
> All of my reviews have consistently claimed that it must report
> on the direct execution of its input and this is expressly not
> allowed because itself is contained within this direct execution.

No, it is being asked about the direct execution of the program
described by the input.

That is a SEPERATE computation (even if identical) to the one that it is
running in.

>
> embedded_H is not allowed to report that
> Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>

So, you are saying it isn't allowed to give the one and only correct answer?

Thus, YOU system is a system that is BY DEFINITION inconsistent.

Your problem is that you have made an INCORRECT "equivalent" in your
version that had D call the exact same copy of H as is deciding on it.

That was explained to you YEARS ago, but you still don't seem to
understand, that is an IMPOSSIBLE implementation of an actual Turing
Machine, and can only be an "equivalent" if the program can't tell that
is what is happening.

Since your H break that information barrier, it is no longer an
"Equivalent" of the Turing Machine H as you are claiming.

You are just proving you don't understand what you are talking about,
because of your utter ignorance of the topic.

On 10/26/2023 1:59 PM, olcott wrote:
> On 10/26/2023 1:17 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 ∞
>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>> and halts because this requires embedded_H to report on the computation
>> that contains itself thus breaking the rule that all computations must
>> be a pure functions of their inputs.
>>
>
> By the definition of computation that requires all computations to
> be a pure function of their inputs no Turing Machine is allowed to
> report on the computation that itself is contained within.
>
> This utterly forbids embedded_H from reporting that the directly
> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.

That is <not> the behavior that embedded_H sees.

When embedded_H is a pure function of its inputs then it sees
that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
same machine with the exact same input, recursively such that
the simulated ⟨Ĥ⟩ cannot possibly terminate normally.

It has no idea about the behavior of the computation that
itself is embedded 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/26/23 1:12 PM, olcott wrote:
> On 10/26/2023 1:59 PM, olcott wrote:
>> On 10/26/2023 1:17 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 ∞
>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>>> and halts because this requires embedded_H to report on the computation
>>> that contains itself thus breaking the rule that all computations must
>>> be a pure functions of their inputs.
>>>
>>
>> By the definition of computation that requires all computations to
>> be a pure function of their inputs no Turing Machine is allowed to
>> report on the computation that itself is contained within.
>>
>> This utterly forbids embedded_H from reporting that the directly
>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>
> That is <not> the behavior that embedded_H sees.

Maybe not, but it is the behavior that it is REQUIRED to decide on to be
correct. If embedded_H can't actually see it, then it is just
insufficiently powerful to do the required task (and it may be that
NOTHING is sufficiently powerful, as the task is uncomputable).

>
> When embedded_H is a pure function of its inputs then it sees
> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
> same machine with the exact same input, recursively such that
> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.

No, that logic is incorrect, It isn't asking if it will terminate
"normally", but if it will halt, in fact.

The fact that the copy of H inside Ĥ will abort its simulation (because
this copy of H does, and they are copies of the same code) and return 0,
means that Ĥ will halt.

H needs to decide on the ACTUAL machine it sees described, not some
imaginary "equivalent" machine that does what H is required to do to be
correct.

Your inability to understand this logic, that has been explained to you
many times, shows your inability to understand how logic actually works,
and what the actual definitions of the words are.

H (and thus embedded_H) needs to respond about the ACTUAL MACHINE
described by the input. That machine includes a copy of H that will do
exactly what H does. That means, that for H to actually correctly decide
the behavior of the input by simulation, H needs to be able to correctly
predict its own behavior.

Yes, THIS leads to a self-contradictory problem, but that doesn't make
the problem "invalid", it makes in "uncomputable", because the correct
answer exists for every possible H, its just that this H doesn't give
that answer.

You don't know the difference between "invalid" and "uncomputable" or
"unprovable", because it seems your brain can't handle the concepts
because of your own limitations.

>
> It has no idea about the behavior of the computation that
> itself is embedded within.
>
>

On 10/26/2023 3:12 PM, olcott wrote:
> On 10/26/2023 1:59 PM, olcott wrote:
>> On 10/26/2023 1:17 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 ∞
>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>>> and halts because this requires embedded_H to report on the computation
>>> that contains itself thus breaking the rule that all computations must
>>> be a pure functions of their inputs.
>>>
>>
>> By the definition of computation that requires all computations to
>> be a pure function of their inputs no Turing Machine is allowed to
>> report on the computation that itself is contained within.
>>
>> This utterly forbids embedded_H from reporting that the directly
>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>
> That is <not> the behavior that embedded_H sees.
>
> When embedded_H is a pure function of its inputs then it sees
> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
> same machine with the exact same input, recursively such that
> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>
> It has no idea about the behavior of the computation that
> itself is embedded within.

Maybe not, but it is the behavior that it is REQUIRED to decide on to be
correct.

That is either a widely held misconception or an the
incoherent requirement of simultaneous mutually exclusive
properties.

Nothing is computable that is not a pure function of its
inputs and the behavior of the computation that a decider
is contained within is absolutely not a pure function its
actual inputs.

--
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 2:35 PM, olcott wrote:
> On 10/26/2023 3:12 PM, olcott wrote:
>> On 10/26/2023 1:59 PM, olcott wrote:
>>> On 10/26/2023 1:17 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 ∞
>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>>>> and halts because this requires embedded_H to report on the computation
>>>> that contains itself thus breaking the rule that all computations must
>>>> be a pure functions of their inputs.
>>>>
>>>
>>> By the definition of computation that requires all computations to
>>> be a pure function of their inputs no Turing Machine is allowed to
>>> report on the computation that itself is contained within.
>>>
>>> This utterly forbids embedded_H from reporting that the directly
>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>
>> That is <not> the behavior that embedded_H sees.
>>
>> When embedded_H is a pure function of its inputs then it sees
>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>> same machine with the exact same input, recursively such that
>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>
>> It has no idea about the behavior of the computation that
>> itself is embedded within.
>
My comment, that seems to be yours because you don't quote:

> Maybe not, but it is the behavior that it is REQUIRED to decide on to be
> correct.
>

Your responce

> That is either a widely held misconception or an the
> incoherent requirement of simultaneous mutually exclusive
> properties.

So, what else could the ACTUAL Halting question of:

"Does the machine represented by the input to the decider Halt?"

mean?

Are you admitting that you think Strawman questions are valid?

>
> Nothing is computable that is not a pure function of its
> inputs and the behavior of the computation that a decider
> is contained within is absolutely not a pure function its
> actual inputs.
>

And what isn't a "pure functon of its inputs" about this?

In particular for this question: "Does the computation represented by
the input to the decider [namely (Ĥ) (Ĥ), which represents Ĥ (Ĥ)] halt?"
Why isn't it a pure function of the input?

Remeber Ĥ is a SPECIFIC machine input built on a SPECIFIC machine H. In
your case, it is claimed that this SPEICIFIC H is "correct" to answer
False (0) when run as: H (Ĥ) (Ĥ)

And, by the structure of Ĥ, we can show that Ĥ (Ĥ), which is the
computation described by the input, since Ĥ will use a copy of H and ask
it what value H (Ĥ) (Ĥ) will result in, which is 0, and thus the machine
Ĥ when applied as Ĥ (Ĥ) will halt.

Thus, the behavior of the input (Ĥ) (Ĥ) is not dependent on anything
other than itself.

Note, the claimed dependency on H isn't actually there, as H's behavior
for a given input is FIXED by the definition of H (unless you are LYING
that H is actually a pure function). Remember the order of operations:

1) Choose an H, which is then FIXED for the problem

2) Build an Ĥ from that specific H

3) Give that specific (Ĥ) (Ĥ) to that specific H, and see that it gets
the wrong answer

There IS a CORRECT answer to Halting (Ĥ) (Ĥ) as a mathematical function,
as described above, thus the question is correct.

The proof that no machine exists that can compute it show it is
uncomputable.

Note, just quoting the thing your are arquing about doesn't help if you
don't actually answer the problem it points out.

How is the requirement to answer about the actual machine described by
the input not a requirement when it is part of the actual question.

You are just proving you believe you don't need to actually follow the
actual rules, which is of course, just a statment that you logic isn't
logical.

On 10/26/2023 4:35 PM, olcott wrote:
> On 10/26/2023 3:12 PM, olcott wrote:
>> On 10/26/2023 1:59 PM, olcott wrote:
>>> On 10/26/2023 1:17 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 ∞
>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches Ĥ.qn
>>>> and halts because this requires embedded_H to report on the computation
>>>> that contains itself thus breaking the rule that all computations must
>>>> be a pure functions of their inputs.
>>>>
>>>
>>> By the definition of computation that requires all computations to
>>> be a pure function of their inputs no Turing Machine is allowed to
>>> report on the computation that itself is contained within.
>>>
>>> This utterly forbids embedded_H from reporting that the directly
>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>
>> That is <not> the behavior that embedded_H sees.
>>
>> When embedded_H is a pure function of its inputs then it sees
>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>> same machine with the exact same input, recursively such that
>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>
>> It has no idea about the behavior of the computation that
>> itself is embedded within.
>
> Maybe not, but it is the behavior that it is REQUIRED to decide on to be
> correct.
>
> That is either a widely held misconception or an the
> incoherent requirement of simultaneous mutually exclusive
> properties.
>
> Nothing is computable that is not a pure function of its
> inputs and the behavior of the computation that a decider
> is contained within is absolutely not a pure function its
> actual inputs.

So, what else could the ACTUAL
Halting question of:
"Does the machine represented by the
input to the decider Halt?"

Does D simulated by H reach it own final state?

--
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 5:37 PM, olcott wrote:
> On 10/26/2023 4:35 PM, olcott wrote:
>> On 10/26/2023 3:12 PM, olcott wrote:
>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>> On 10/26/2023 1:17 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 ∞
>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches
>>>>> Ĥ.qn
>>>>> and halts because this requires embedded_H to report on the
>>>>> computation
>>>>> that contains itself thus breaking the rule that all computations must
>>>>> be a pure functions of their inputs.
>>>>>
>>>>
>>>> By the definition of computation that requires all computations to
>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>> report on the computation that itself is contained within.
>>>>
>>>> This utterly forbids embedded_H from reporting that the directly
>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>
>>> That is <not> the behavior that embedded_H sees.
>>>
>>> When embedded_H is a pure function of its inputs then it sees
>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>> same machine with the exact same input, recursively such that
>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>
>>> It has no idea about the behavior of the computation that
>>> itself is embedded within.
>>
>> Maybe not, but it is the behavior that it is REQUIRED to decide on to
>> be correct.
>>
>> That is either a widely held misconception or an the
>> incoherent requirement of simultaneous mutually exclusive
>> properties.
>>
>> Nothing is computable that is not a pure function of its
>> inputs and the behavior of the computation that a decider
>> is contained within is absolutely not a pure function its
>> actual inputs.
>
>    So, what else could the ACTUAL
>    Halting question of:
>    "Does the machine represented by the
>    input to the decider Halt?"
>
> Does D simulated by H reach it own final state?
>

Which is only correct *IF* H meets the definition of a UTM, and actually
correctly simulates its input to give the same results as the actual
machine, that is the only thing that allows the equivalene of the actual
machine and a "simulation" of the input.

That means H can NEVER correctly say non-halting, as the UTM simulation
doesn't end for a non-halting input, so H could never "Correctly
Simulate" the input and also give an answer in finite time.

Thus, YOUR definition is BY DEFINITION broken for something to actually
be a decider.

You can't change the meaning of the problem and still be working on the
problem.

To try to do that, just means you are working on a Strawman, and that
proves your logic is fallacious.

But of course, that seems to be the nature of most of your logic, which
is why you have so much problem getting valid answers.

You are just continuing to prove you don't understand what you are
talking about.

Now, you COULD ask, does the input simulated by an actual UTM reach a
final state, as that is equivalent, but you will run into the exact same
problem, H needs to determine what that UTM would do when it simulates
the copy of H that is in the input, which will do the same thing that
this H does.

Or, you can just admit that you whole concept is just broken.

On 10/26/2023 7:37 PM, olcott wrote:
> On 10/26/2023 4:35 PM, olcott wrote:
>> On 10/26/2023 3:12 PM, olcott wrote:
>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>> On 10/26/2023 1:17 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 ∞
>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches
>>>>> Ĥ.qn
>>>>> and halts because this requires embedded_H to report on the
>>>>> computation
>>>>> that contains itself thus breaking the rule that all computations must
>>>>> be a pure functions of their inputs.
>>>>>
>>>>
>>>> By the definition of computation that requires all computations to
>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>> report on the computation that itself is contained within.
>>>>
>>>> This utterly forbids embedded_H from reporting that the directly
>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>
>>> That is <not> the behavior that embedded_H sees.
>>>
>>> When embedded_H is a pure function of its inputs then it sees
>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>> same machine with the exact same input, recursively such that
>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>
>>> It has no idea about the behavior of the computation that
>>> itself is embedded within.
>>
>> Maybe not, but it is the behavior that it is REQUIRED to decide on to
>> be correct.
>>
>> That is either a widely held misconception or an the
>> incoherent requirement of simultaneous mutually exclusive
>> properties.
>>
>> Nothing is computable that is not a pure function of its
>> inputs and the behavior of the computation that a decider
>> is contained within is absolutely not a pure function its
>> actual inputs.
>
>    So, what else could the ACTUAL
>    Halting question of:
>    "Does the machine represented by the
>    input to the decider Halt?"
>
> Does D simulated by H reach it own final state?
>

Which is only correct *IF* H meets
the definition of a UTM,

Not at all. H merely must simulate the actual sequence
of states that it is actually presented with.

This does include a call from its input to a copy of
itself that will never stop copying and calling other
copies unless this H right here stops them.

If this H right here does not stop them then no H anywhere
will ever stop them because
(a) They all have the same machine description
(b) The outermost H always has the most execution trace information.

--
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 6:09 PM, olcott wrote:
> On 10/26/2023 7:37 PM, olcott wrote:
>> On 10/26/2023 4:35 PM, olcott wrote:
>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>> On 10/26/2023 1:17 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 ∞
>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches
>>>>>> Ĥ.qn
>>>>>> and halts because this requires embedded_H to report on the
>>>>>> computation
>>>>>> that contains itself thus breaking the rule that all computations
>>>>>> must
>>>>>> be a pure functions of their inputs.
>>>>>>
>>>>>
>>>>> By the definition of computation that requires all computations to
>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>> report on the computation that itself is contained within.
>>>>>
>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>
>>>> That is <not> the behavior that embedded_H sees.
>>>>
>>>> When embedded_H is a pure function of its inputs then it sees
>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>> same machine with the exact same input, recursively such that
>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>
>>>> It has no idea about the behavior of the computation that
>>>> itself is embedded within.
>>>
>>> Maybe not, but it is the behavior that it is REQUIRED to decide on to
>>> be correct.
>>>
>>> That is either a widely held misconception or an the
>>> incoherent requirement of simultaneous mutually exclusive
>>> properties.
>>>
>>> Nothing is computable that is not a pure function of its
>>> inputs and the behavior of the computation that a decider
>>> is contained within is absolutely not a pure function its
>>> actual inputs.
>>
>>     So, what else could the ACTUAL
>>     Halting question of:
>>     "Does the machine represented by the
>>     input to the decider Halt?"
>>
>> Does D simulated by H reach it own final state?
>>
>
>    Which is only correct *IF* H meets
>    the definition of a UTM,
>
> Not at all. H merely must simulate the actual sequence
> of states that it is actually presented with.

And if it doesn't get to the end, it hasn't determined the actual
behavior of the input per the problem statement.

You don't understand that you need to use the actual definitions of the
problem.

You are just going for a Strawman, and claiming it is ok, which is just
a LIE.

>
> This does include a call from its input to a copy of
> itself that will never stop copying and calling other
> copies unless this H right here stops them.

Except that isn't the actual behavior of a call to the copy of itself,
so is an INCORRECT simulation. PERIOD.

Simulation not equal to actual behavior is an ERROR. DEFINITION.

>
> If this H right here does not stop them then no H anywhere
> will ever stop them because
> (a) They all have the same machine description
> (b) The outermost H always has the most execution trace information.
>
So, ALL H's will either stop their simulation or not.

If it doesn't, then H never answers.

If it does, then a correct simulation of the input needs to account for
that, which your algorithm doesn'r.

You are just asserting that it is ok you use FALSE premises in your logic,

Thus your logic is unsound.

You are just asserting a Strawman argument, and FAILING.

You seem to believe that wrong answers can be right, which means you
believe it is ok to have a logic system built on contradictions.

This shows that you don't understand how logic works, but you just want
to work with the Big Lie and just pass your Disinformation to try to
press your unsound agenda.

You are just proving you are nothing but an ignorant liar.

On 10/26/2023 8:09 PM, olcott wrote:
> On 10/26/2023 7:37 PM, olcott wrote:
>> On 10/26/2023 4:35 PM, olcott wrote:
>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>> On 10/26/2023 1:17 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 ∞
>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩ reaches
>>>>>> Ĥ.qn
>>>>>> and halts because this requires embedded_H to report on the
>>>>>> computation
>>>>>> that contains itself thus breaking the rule that all computations
>>>>>> must
>>>>>> be a pure functions of their inputs.
>>>>>>
>>>>>
>>>>> By the definition of computation that requires all computations to
>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>> report on the computation that itself is contained within.
>>>>>
>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>
>>>> That is <not> the behavior that embedded_H sees.
>>>>
>>>> When embedded_H is a pure function of its inputs then it sees
>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>> same machine with the exact same input, recursively such that
>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>
>>>> It has no idea about the behavior of the computation that
>>>> itself is embedded within.
>>>
>>> Maybe not, but it is the behavior that it is REQUIRED to decide on to
>>> be correct.
>>>
>>> That is either a widely held misconception or an the
>>> incoherent requirement of simultaneous mutually exclusive
>>> properties.
>>>
>>> Nothing is computable that is not a pure function of its
>>> inputs and the behavior of the computation that a decider
>>> is contained within is absolutely not a pure function its
>>> actual inputs.
>>
>>     So, what else could the ACTUAL
>>     Halting question of:
>>     "Does the machine represented by the
>>     input to the decider Halt?"
>>
>> Does D simulated by H reach it own final state?
>>
>
>    Which is only correct *IF* H meets
>    the definition of a UTM,
>
> Not at all. H merely must simulate the actual sequence
> of states that it is actually presented with.
>
> This does include a call from its input to a copy of
> itself that will never stop copying and calling other
> copies unless this H right here stops them.
>
> If this H right here does not stop them then no H anywhere
> will ever stop them because
> (a) They all have the same machine description
> (b) The outermost H always has the most execution trace information.
>

H merely must simulate the actual sequence
of states that it is actually presented with.

THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
THIS H STOPS THEM

--
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 6:28 PM, olcott wrote:
> On 10/26/2023 8:09 PM, olcott wrote:
>> On 10/26/2023 7:37 PM, olcott wrote:
>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>> reaches Ĥ.qn
>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>> computation
>>>>>>> that contains itself thus breaking the rule that all computations
>>>>>>> must
>>>>>>> be a pure functions of their inputs.
>>>>>>>
>>>>>>
>>>>>> By the definition of computation that requires all computations to
>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>> report on the computation that itself is contained within.
>>>>>>
>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>
>>>>> That is <not> the behavior that embedded_H sees.
>>>>>
>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>> same machine with the exact same input, recursively such that
>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>
>>>>> It has no idea about the behavior of the computation that
>>>>> itself is embedded within.
>>>>
>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>> to be correct.
>>>>
>>>> That is either a widely held misconception or an the
>>>> incoherent requirement of simultaneous mutually exclusive
>>>> properties.
>>>>
>>>> Nothing is computable that is not a pure function of its
>>>> inputs and the behavior of the computation that a decider
>>>> is contained within is absolutely not a pure function its
>>>> actual inputs.
>>>
>>>     So, what else could the ACTUAL
>>>     Halting question of:
>>>     "Does the machine represented by the
>>>     input to the decider Halt?"
>>>
>>> Does D simulated by H reach it own final state?
>>>
>>
>>     Which is only correct *IF* H meets
>>     the definition of a UTM,
>>
>> Not at all. H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> This does include a call from its input to a copy of
>> itself that will never stop copying and calling other
>> copies unless this H right here stops them.
>>
>> If this H right here does not stop them then no H anywhere
>> will ever stop them because
>> (a) They all have the same machine description
>> (b) The outermost H always has the most execution trace information.
>>
>
> H merely must simulate the actual sequence
> of states that it is actually presented with.
>
> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
> THIS H STOPS THEM
>
>

On what grounds do you say that?

By the definition of the problem, H must report if the machine
represented by its input will Halt. PERIOD.

It can use an actually "equivalent" criteria, but it must be actually
equivalent.

Thus, you claim otherwise just shows that you think "Strawmen" criteria
are valid logical argument.

You CLEARLY don't understand what is meant by REQUIREMENTS, because your
mind just don't understand the nature of Logic or Truth.

On what grounds is H allowed to give an answer that isn't actually the
answer to the question it is requried to be answering?

You are just admitting that you are just a liar, and that you totally
don't understand what you are talking about.

It really does seem that you think LIES are perfectly fine logic, just
like the BIG LIE you have been telling with your Disinformation campaign
that you are engaging in to supposedly fight disinformation.

PURE HYPOCRACY.

There is a place in HELL reserved just for you, which is why you refuse
to look at what is True, because the truth of your future is just to
horrible to look at.

On 10/26/2023 8:28 PM, olcott wrote:
> On 10/26/2023 8:09 PM, olcott wrote:
>> On 10/26/2023 7:37 PM, olcott wrote:
>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>> reaches Ĥ.qn
>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>> computation
>>>>>>> that contains itself thus breaking the rule that all computations
>>>>>>> must
>>>>>>> be a pure functions of their inputs.
>>>>>>>
>>>>>>
>>>>>> By the definition of computation that requires all computations to
>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>> report on the computation that itself is contained within.
>>>>>>
>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>
>>>>> That is <not> the behavior that embedded_H sees.
>>>>>
>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>> same machine with the exact same input, recursively such that
>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>
>>>>> It has no idea about the behavior of the computation that
>>>>> itself is embedded within.
>>>>
>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>> to be correct.
>>>>
>>>> That is either a widely held misconception or an the
>>>> incoherent requirement of simultaneous mutually exclusive
>>>> properties.
>>>>
>>>> Nothing is computable that is not a pure function of its
>>>> inputs and the behavior of the computation that a decider
>>>> is contained within is absolutely not a pure function its
>>>> actual inputs.
>>>
>>>     So, what else could the ACTUAL
>>>     Halting question of:
>>>     "Does the machine represented by the
>>>     input to the decider Halt?"
>>>
>>> Does D simulated by H reach it own final state?
>>>
>>
>>     Which is only correct *IF* H meets
>>     the definition of a UTM,
>>
>> Not at all. H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> This does include a call from its input to a copy of
>> itself that will never stop copying and calling other
>> copies unless this H right here stops them.
>>
>> If this H right here does not stop them then no H anywhere
>> will ever stop them because
>> (a) They all have the same machine description
>> (b) The outermost H always has the most execution trace information.
>>
>
> H merely must simulate the actual sequence
> of states that it is actually presented with.
>
> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
> THIS H STOPS THEM

"On what grounds do you say that?"

Those ARE the states that H sees.

If the definition of the problem says it must
look at the computation that contains itself
then this definition of the problem is AFU!

We can know that definitions are incorrect
when two of them contradict each other.

--
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 7:04 PM, olcott wrote:
> On 10/26/2023 8:28 PM, olcott wrote:
>> On 10/26/2023 8:09 PM, olcott wrote:
>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>> reaches Ĥ.qn
>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>> computation
>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>> computations must
>>>>>>>> be a pure functions of their inputs.
>>>>>>>>
>>>>>>>
>>>>>>> By the definition of computation that requires all computations to
>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>> report on the computation that itself is contained within.
>>>>>>>
>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>
>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>
>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>> same machine with the exact same input, recursively such that
>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>
>>>>>> It has no idea about the behavior of the computation that
>>>>>> itself is embedded within.
>>>>>
>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>>> to be correct.
>>>>>
>>>>> That is either a widely held misconception or an the
>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>> properties.
>>>>>
>>>>> Nothing is computable that is not a pure function of its
>>>>> inputs and the behavior of the computation that a decider
>>>>> is contained within is absolutely not a pure function its
>>>>> actual inputs.
>>>>
>>>>     So, what else could the ACTUAL
>>>>     Halting question of:
>>>>     "Does the machine represented by the
>>>>     input to the decider Halt?"
>>>>
>>>> Does D simulated by H reach it own final state?
>>>>
>>>
>>>     Which is only correct *IF* H meets
>>>     the definition of a UTM,
>>>
>>> Not at all. H merely must simulate the actual sequence
>>> of states that it is actually presented with.
>>>
>>> This does include a call from its input to a copy of
>>> itself that will never stop copying and calling other
>>> copies unless this H right here stops them.
>>>
>>> If this H right here does not stop them then no H anywhere
>>> will ever stop them because
>>> (a) They all have the same machine description
>>> (b) The outermost H always has the most execution trace information.
>>>
>>
>> H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>> THIS H STOPS THEM
>
> "On what grounds do you say that?"
>
> Those ARE the states that H sees.

But not the question that H NEEDS to answer!

You seem to be saying that a correct answer to "how many cats do you
have?" would be "I have 2 dog." even though it doesn't actually answer
the question asked.

>
> If the definition of the problem says it must
> look at the computation that contains itself
> then this definition of the problem is AFU!
>

Nope. It doesn't matter that this instance happens to have a copy of itself.

Note, the input can't actually reference the decider that the input is
being given to, as that wouldn't be a computation.

It CAN use a copy of a specific machine, and that can be the machine we
happen to give it to.

That just says that the mathematics is powerful enough to express this
sort of relationship.

Your not understanding this just means that YOU are AFU.

> We can know that definitions are incorrect
> when two of them contradict each other.
>

Nope.

There IS a correct answer, so the question is NOT incorrect.

Since the H that you claim to be correct answer False for H (Ĥ) (Ĥ), we
know that with Ĥ built from this H, Ĥ (Ĥ) will Halt, and thus the
CORRECT answer to the question is True, the computation described by the
input will Halt. Thus there is no "contradiction" in the problem.

The fact that no H can give this correct answer for the Ĥ built on it,
means the problem is uncomputable, which is a perfectly valid answer.

Your mind just doesn't seem to understand this simple fact, because your
"correct reasoning" system is just too simple. The world needs logic
bigger than the toy system you want to try to use, so your mind just
seems to overload.

You don't get to just try to define real problems as "invalid" because
they cause problems for your logic system (or your tiny mind).

Admit it, your logic is just broken.

On 10/26/2023 8:28 PM, olcott wrote:
> On 10/26/2023 8:09 PM, olcott wrote:
>> On 10/26/2023 7:37 PM, olcott wrote:
>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>> reaches Ĥ.qn
>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>> computation
>>>>>>> that contains itself thus breaking the rule that all computations
>>>>>>> must
>>>>>>> be a pure functions of their inputs.
>>>>>>>
>>>>>>
>>>>>> By the definition of computation that requires all computations to
>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>> report on the computation that itself is contained within.
>>>>>>
>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>
>>>>> That is <not> the behavior that embedded_H sees.
>>>>>
>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>> same machine with the exact same input, recursively such that
>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>
>>>>> It has no idea about the behavior of the computation that
>>>>> itself is embedded within.
>>>>
>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>> to be correct.
>>>>
>>>> That is either a widely held misconception or an the
>>>> incoherent requirement of simultaneous mutually exclusive
>>>> properties.
>>>>
>>>> Nothing is computable that is not a pure function of its
>>>> inputs and the behavior of the computation that a decider
>>>> is contained within is absolutely not a pure function its
>>>> actual inputs.
>>>
>>>     So, what else could the ACTUAL
>>>     Halting question of:
>>>     "Does the machine represented by the
>>>     input to the decider Halt?"
>>>
>>> Does D simulated by H reach it own final state?
>>>
>>
>>     Which is only correct *IF* H meets
>>     the definition of a UTM,
>>
>> Not at all. H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> This does include a call from its input to a copy of
>> itself that will never stop copying and calling other
>> copies unless this H right here stops them.
>>
>> If this H right here does not stop them then no H anywhere
>> will ever stop them because
>> (a) They all have the same machine description
>> (b) The outermost H always has the most execution trace information.
>>
>
> H merely must simulate the actual sequence
> of states that it is actually presented with.
>
> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
> THIS H STOPS THEM

When one definition says that:
(A) H must look at the direct execution of its input
and another definition of computation says that:
(B) H is not allowed to look at the computation that
contains itself

THEY CAN'T BOTH BE RIGHT

--
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 7:48 PM, olcott wrote:
> On 10/26/2023 8:28 PM, olcott wrote:
>> On 10/26/2023 8:09 PM, olcott wrote:
>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>> reaches Ĥ.qn
>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>> computation
>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>> computations must
>>>>>>>> be a pure functions of their inputs.
>>>>>>>>
>>>>>>>
>>>>>>> By the definition of computation that requires all computations to
>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>> report on the computation that itself is contained within.
>>>>>>>
>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>
>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>
>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>> same machine with the exact same input, recursively such that
>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>
>>>>>> It has no idea about the behavior of the computation that
>>>>>> itself is embedded within.
>>>>>
>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>>> to be correct.
>>>>>
>>>>> That is either a widely held misconception or an the
>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>> properties.
>>>>>
>>>>> Nothing is computable that is not a pure function of its
>>>>> inputs and the behavior of the computation that a decider
>>>>> is contained within is absolutely not a pure function its
>>>>> actual inputs.
>>>>
>>>>     So, what else could the ACTUAL
>>>>     Halting question of:
>>>>     "Does the machine represented by the
>>>>     input to the decider Halt?"
>>>>
>>>> Does D simulated by H reach it own final state?
>>>>
>>>
>>>     Which is only correct *IF* H meets
>>>     the definition of a UTM,
>>>
>>> Not at all. H merely must simulate the actual sequence
>>> of states that it is actually presented with.
>>>
>>> This does include a call from its input to a copy of
>>> itself that will never stop copying and calling other
>>> copies unless this H right here stops them.
>>>
>>> If this H right here does not stop them then no H anywhere
>>> will ever stop them because
>>> (a) They all have the same machine description
>>> (b) The outermost H always has the most execution trace information.
>>>
>>
>> H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>> THIS H STOPS THEM
>
> When one definition says that:
> (A) H must look at the direct execution of its input
> and another definition of computation says that:
> (B) H is not allowed to look at the computation that
> contains itself
>
> THEY CAN'T BOTH BE RIGHT
>

But how does (B) apply, since the input doesn't say that H need to look
at "itself" but at something that just happens to be copy of itself.

There is no rule against looking at an input that just happens to be a
copy of itself, that if a figment of your own mind, the rule you seem to
be referencing is about its inability to know how it is being used.

You just don't understand what you are talking about, and are just
making up rules by twisting things, because you are so ignorant.

You don't seem to understand that you can freely make copyies of Turing
Machines, and Turing Machines can easily be given representations of
Turing Machines, including themselves.

In fact, it turns out that it is impossible for a given Turing Machine
to identify that an input is a representation of itself. (It might be
able to recognize a finite number of representations of itself, but not
all).

THis of course, totally breaks your method, as it turns out that your H
can't ever detect that Ĥ is using a copy of itself to try to do your logic.

Of course, you don't understand what that means, as you can't write even
a fairly simple Turing machine, because they are too complicated for you.

On 10/26/2023 9:48 PM, olcott wrote:
> On 10/26/2023 8:28 PM, olcott wrote:
>> On 10/26/2023 8:09 PM, olcott wrote:
>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>> reaches Ĥ.qn
>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>> computation
>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>> computations must
>>>>>>>> be a pure functions of their inputs.
>>>>>>>>
>>>>>>>
>>>>>>> By the definition of computation that requires all computations to
>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>> report on the computation that itself is contained within.
>>>>>>>
>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>
>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>
>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>> same machine with the exact same input, recursively such that
>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>
>>>>>> It has no idea about the behavior of the computation that
>>>>>> itself is embedded within.
>>>>>
>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>>> to be correct.
>>>>>
>>>>> That is either a widely held misconception or an the
>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>> properties.
>>>>>
>>>>> Nothing is computable that is not a pure function of its
>>>>> inputs and the behavior of the computation that a decider
>>>>> is contained within is absolutely not a pure function its
>>>>> actual inputs.
>>>>
>>>>     So, what else could the ACTUAL
>>>>     Halting question of:
>>>>     "Does the machine represented by the
>>>>     input to the decider Halt?"
>>>>
>>>> Does D simulated by H reach it own final state?
>>>>
>>>
>>>     Which is only correct *IF* H meets
>>>     the definition of a UTM,
>>>
>>> Not at all. H merely must simulate the actual sequence
>>> of states that it is actually presented with.
>>>
>>> This does include a call from its input to a copy of
>>> itself that will never stop copying and calling other
>>> copies unless this H right here stops them.
>>>
>>> If this H right here does not stop them then no H anywhere
>>> will ever stop them because
>>> (a) They all have the same machine description
>>> (b) The outermost H always has the most execution trace information.
>>>
>>
>> H merely must simulate the actual sequence
>> of states that it is actually presented with.
>>
>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>> THIS H STOPS THEM
>
> When one definition says that:
> (A) H must look at the direct execution of its input
> and another definition of computation says that:
> (B) H is not allowed to look at the computation that
> contains itself
>
> THEY CAN'T BOTH BE RIGHT
>

But how does (B) apply, since the input doesn't say that H need to look
at "itself" but at something that just happens to be copy of itself.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Yet you keep saying directly executed Ĥ ⟨Ĥ⟩ must be looked at and
this IS forbidden. *embedded_H simulates ⟨Ĥ⟩ and sees how it continues*
*to call embedded_H in recursive simulation until embedded_H stops it*

--
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 9:04 PM, olcott wrote:
> On 10/26/2023 9:48 PM, olcott wrote:
>> On 10/26/2023 8:28 PM, olcott wrote:
>>> On 10/26/2023 8:09 PM, olcott wrote:
>>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>>> reaches Ĥ.qn
>>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>>> computation
>>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>>> computations must
>>>>>>>>> be a pure functions of their inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> By the definition of computation that requires all computations to
>>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>>> report on the computation that itself is contained within.
>>>>>>>>
>>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>>
>>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>>
>>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>>> same machine with the exact same input, recursively such that
>>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>>
>>>>>>> It has no idea about the behavior of the computation that
>>>>>>> itself is embedded within.
>>>>>>
>>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>>>> to be correct.
>>>>>>
>>>>>> That is either a widely held misconception or an the
>>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>>> properties.
>>>>>>
>>>>>> Nothing is computable that is not a pure function of its
>>>>>> inputs and the behavior of the computation that a decider
>>>>>> is contained within is absolutely not a pure function its
>>>>>> actual inputs.
>>>>>
>>>>>     So, what else could the ACTUAL
>>>>>     Halting question of:
>>>>>     "Does the machine represented by the
>>>>>     input to the decider Halt?"
>>>>>
>>>>> Does D simulated by H reach it own final state?
>>>>>
>>>>
>>>>     Which is only correct *IF* H meets
>>>>     the definition of a UTM,
>>>>
>>>> Not at all. H merely must simulate the actual sequence
>>>> of states that it is actually presented with.
>>>>
>>>> This does include a call from its input to a copy of
>>>> itself that will never stop copying and calling other
>>>> copies unless this H right here stops them.
>>>>
>>>> If this H right here does not stop them then no H anywhere
>>>> will ever stop them because
>>>> (a) They all have the same machine description
>>>> (b) The outermost H always has the most execution trace information.
>>>>
>>>
>>> H merely must simulate the actual sequence
>>> of states that it is actually presented with.
>>>
>>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>>> THIS H STOPS THEM
>>
>> When one definition says that:
>> (A) H must look at the direct execution of its input
>> and another definition of computation says that:
>> (B) H is not allowed to look at the computation that
>> contains itself
>>
>> THEY CAN'T BOTH BE RIGHT
>>
>
> But how does (B) apply, since the input doesn't say that H need to look
> at "itself" but at something that just happens to be copy of itself.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Yet you keep saying directly executed Ĥ ⟨Ĥ⟩ must be looked at and
> this IS forbidden. *embedded_H simulates ⟨Ĥ⟩ and sees how it continues*
> *to call embedded_H in recursive simulation until embedded_H stops it*
>

No, it is NOT forbidden.

Literally ANY machine can be asked to look at the input (Ĥ) (Ĥ) and for
a halt decider, that means look at the behavior of the computation Ĥ (Ĥ).

There is not problem with this.

Yes, if some H / embedded_H just continues to simulate, then that H will
never answer, and thus FAIL to be a decider.

But THIS H doesn't do that, it DOES abort, and thus the actual behavior
of Ĥ (Ĥ) is to reach a Halt State, so the correct answer is Halting.

You are using unsound logic when you think that one copy of H/embedded_H
gets stuck in an infinte loop while another doesn't.

If you care to disagree, please show the ACTUAL CODE for an H where the
"outer" H aborts its simulation and returns an answer, but the actual
running or actual correct simulation (i.e. one that never aborts) of the
Ĥ built on that EXACT same code gets stuck in the loop.

Remember, BOTH COPY of H, even the one you are calling "embedded_H" must
be the copies of the exact same code.

To do so, H must not actually be a "computation" as its behavior is
based on more than its explicit input, and thus it can't be the
equivalent of a Turing Machine.

You are just proving your stupidity and ignorance of what you are
talking about.

You keep on saying that doing the requirments are some how forbidden,
but can't actually quote an actual rule that actually say so, but are
conflating that the program being decided on can't make a request about
the decider that is currently deciding on it, but CAN use a copy of a
specific decider.

Thus it is ALLOWS for a specific Ĥ to use a specific H, and then even if
we use an equivalent H (or the exact same one) that is allowed.

What we can't do is have a specific Ĥ that tries to use whatever Hi is
trying to decide it at the moment, it needs to choose what Hi, now
called H, it will be based on.

That particular Ĥ will only confound some of the Hi, only those that
happen to agree with H what H (Ĥ) (Ĥ) computed to, which was the wrong
answer.

The key is that for ANY Hi, we can create a specific Ĥi (different from
all other Ĥj) based on THAT Hi, that will confound that particular Hi.
Thus every Hi has a Ĥi that confounds it, so no Hi can corectly decide
all inputs.

The question is still correct, as there IS a correct answer for every
input (Ĥi) (Ĥi), which just happens (by construction) to be the opposite
of what Hi (Ĥi) (Ĥi) produces.

This is like above your head, and I suspect you will come back with
another stupid reply, but if you don't actually point out an error, I
can just point back to this and say you are too stupid to understand.

On 10/26/2023 11:04 PM, olcott wrote:
> On 10/26/2023 9:48 PM, olcott wrote:
>> On 10/26/2023 8:28 PM, olcott wrote:
>>> On 10/26/2023 8:09 PM, olcott wrote:
>>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>>> reaches Ĥ.qn
>>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>>> computation
>>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>>> computations must
>>>>>>>>> be a pure functions of their inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> By the definition of computation that requires all computations to
>>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>>> report on the computation that itself is contained within.
>>>>>>>>
>>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>>
>>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>>
>>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>>> same machine with the exact same input, recursively such that
>>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>>
>>>>>>> It has no idea about the behavior of the computation that
>>>>>>> itself is embedded within.
>>>>>>
>>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide on
>>>>>> to be correct.
>>>>>>
>>>>>> That is either a widely held misconception or an the
>>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>>> properties.
>>>>>>
>>>>>> Nothing is computable that is not a pure function of its
>>>>>> inputs and the behavior of the computation that a decider
>>>>>> is contained within is absolutely not a pure function its
>>>>>> actual inputs.
>>>>>
>>>>>     So, what else could the ACTUAL
>>>>>     Halting question of:
>>>>>     "Does the machine represented by the
>>>>>     input to the decider Halt?"
>>>>>
>>>>> Does D simulated by H reach it own final state?
>>>>>
>>>>
>>>>     Which is only correct *IF* H meets
>>>>     the definition of a UTM,
>>>>
>>>> Not at all. H merely must simulate the actual sequence
>>>> of states that it is actually presented with.
>>>>
>>>> This does include a call from its input to a copy of
>>>> itself that will never stop copying and calling other
>>>> copies unless this H right here stops them.
>>>>
>>>> If this H right here does not stop them then no H anywhere
>>>> will ever stop them because
>>>> (a) They all have the same machine description
>>>> (b) The outermost H always has the most execution trace information.
>>>>
>>>
>>> H merely must simulate the actual sequence
>>> of states that it is actually presented with.
>>>
>>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>>> THIS H STOPS THEM
>>
>> When one definition says that:
>> (A) H must look at the direct execution of its input
>> and another definition of computation says that:
>> (B) H is not allowed to look at the computation that
>> contains itself
>>
>> THEY CAN'T BOTH BE RIGHT
>>
>
> But how does (B) apply, since the input doesn't say that H need to look
> at "itself" but at something that just happens to be copy of itself.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Yet you keep saying directly executed Ĥ ⟨Ĥ⟩ must be looked at and
> this IS forbidden. *embedded_H simulates ⟨Ĥ⟩ and sees how it continues*
> *to call embedded_H in recursive simulation until embedded_H stops it*
>

No decider is allowed yo examine the computation
that contains itself because all computations must
be a pure function of their inputs and itself <is not>
its input. This means that embedded_H is not allowed
to look at the direct execution of Ĥ ⟨Ĥ⟩.

--
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/27/23 7:26 AM, olcott wrote:
> On 10/26/2023 11:04 PM, olcott wrote:
>> On 10/26/2023 9:48 PM, olcott wrote:
>>> On 10/26/2023 8:28 PM, olcott wrote:
>>>> On 10/26/2023 8:09 PM, olcott wrote:
>>>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>>>> reaches Ĥ.qn
>>>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>>>> computation
>>>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>>>> computations must
>>>>>>>>>> be a pure functions of their inputs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> By the definition of computation that requires all computations to
>>>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>>>> report on the computation that itself is contained within.
>>>>>>>>>
>>>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>>>
>>>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>>>
>>>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>>>> same machine with the exact same input, recursively such that
>>>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>>>
>>>>>>>> It has no idea about the behavior of the computation that
>>>>>>>> itself is embedded within.
>>>>>>>
>>>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide
>>>>>>> on to be correct.
>>>>>>>
>>>>>>> That is either a widely held misconception or an the
>>>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>>>> properties.
>>>>>>>
>>>>>>> Nothing is computable that is not a pure function of its
>>>>>>> inputs and the behavior of the computation that a decider
>>>>>>> is contained within is absolutely not a pure function its
>>>>>>> actual inputs.
>>>>>>
>>>>>>     So, what else could the ACTUAL
>>>>>>     Halting question of:
>>>>>>     "Does the machine represented by the
>>>>>>     input to the decider Halt?"
>>>>>>
>>>>>> Does D simulated by H reach it own final state?
>>>>>>
>>>>>
>>>>>     Which is only correct *IF* H meets
>>>>>     the definition of a UTM,
>>>>>
>>>>> Not at all. H merely must simulate the actual sequence
>>>>> of states that it is actually presented with.
>>>>>
>>>>> This does include a call from its input to a copy of
>>>>> itself that will never stop copying and calling other
>>>>> copies unless this H right here stops them.
>>>>>
>>>>> If this H right here does not stop them then no H anywhere
>>>>> will ever stop them because
>>>>> (a) They all have the same machine description
>>>>> (b) The outermost H always has the most execution trace information.
>>>>>
>>>>
>>>> H merely must simulate the actual sequence
>>>> of states that it is actually presented with.
>>>>
>>>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>>>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>>>> THIS H STOPS THEM
>>>
>>> When one definition says that:
>>> (A) H must look at the direct execution of its input
>>> and another definition of computation says that:
>>> (B) H is not allowed to look at the computation that
>>> contains itself
>>>
>>> THEY CAN'T BOTH BE RIGHT
>>>
>>
>> But how does (B) apply, since the input doesn't say that H need to
>> look at "itself" but at something that just happens to be copy of itself.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Yet you keep saying directly executed Ĥ ⟨Ĥ⟩ must be looked at and
>> this IS forbidden. *embedded_H simulates ⟨Ĥ⟩ and sees how it continues*
>> *to call embedded_H in recursive simulation until embedded_H stops it*
>>
>
> No decider is allowed yo examine the computation
> that contains itself because all computations must
> be a pure function of their inputs and itself <is not>
> its input. This means that embedded_H is not allowed
> to look at the direct execution of Ĥ ⟨Ĥ⟩.
>

Yes, No computation has the ability to know if, or what, computation it
is contained in, and it is also impossible to write a program whose
behavior is dependent on (or if) its description is being decided on.

This is because, in part, that Turing Machines can't "reference" another
Turing Machine, they can only be given a copy of a description of it.

This does NOT mean that you can't give a machine an input that just
happens to contains a copy of the description of that machine or a
machine that contains it.

There is nothing in the concept of a "Pure Function" that prohibits
about asking a decider about a specified program given as an input, even
if that specified program happens to include a copy of the decider, or a
copy of a program that contains a copy of that decider.

You can not ask it about the specified only by reference "The program
that is containing this copy". It isn't that the program itself can't be
asked about, it just can't be asked about via a "pronoun-like" reference.

Your repeating your INCORRECT claim just shows how ignorant you are of
the actual "rules" of the game you are making grand FALSE claims about.
This has been explained to you MANY times, and your repeating your lies
just shows how STUPID you are.

I note again, that you haven't responded to ANY of the errors pointed
out in your argument, but you just repeat your erroneous statement,
because you KNOW that it is incorrect and you have no reply to the
errors pointed out, but just want to repeat your 'Big Lie' as part of
your Disinformation campaign because you can't face the actual truth of
the matter.

You are just sick in the head, and have gas-lighted yourself into being
a pathological lying idiot.

On 10/27/2023 9:26 AM, olcott wrote:
> On 10/26/2023 11:04 PM, olcott wrote:
>> On 10/26/2023 9:48 PM, olcott wrote:
>>> On 10/26/2023 8:28 PM, olcott wrote:
>>>> On 10/26/2023 8:09 PM, olcott wrote:
>>>>> On 10/26/2023 7:37 PM, olcott wrote:
>>>>>> On 10/26/2023 4:35 PM, olcott wrote:
>>>>>>> On 10/26/2023 3:12 PM, olcott wrote:
>>>>>>>> On 10/26/2023 1:59 PM, olcott wrote:
>>>>>>>>> On 10/26/2023 1:17 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 ∞
>>>>>>>>>> embedded_H ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> embedded_H is expressly not allowed to consider that Ĥ ⟨Ĥ⟩
>>>>>>>>>> reaches Ĥ.qn
>>>>>>>>>> and halts because this requires embedded_H to report on the
>>>>>>>>>> computation
>>>>>>>>>> that contains itself thus breaking the rule that all
>>>>>>>>>> computations must
>>>>>>>>>> be a pure functions of their inputs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> By the definition of computation that requires all computations to
>>>>>>>>> be a pure function of their inputs no Turing Machine is allowed to
>>>>>>>>> report on the computation that itself is contained within.
>>>>>>>>>
>>>>>>>>> This utterly forbids embedded_H from reporting that the directly
>>>>>>>>> executed Ĥ ⟨Ĥ⟩ transitions to its final state of Ĥ.qn and halts.
>>>>>>>>
>>>>>>>> That is <not> the behavior that embedded_H sees.
>>>>>>>>
>>>>>>>> When embedded_H is a pure function of its inputs then it sees
>>>>>>>> that ⟨Ĥ⟩ simulated by embedded_H continues to call the exact
>>>>>>>> same machine with the exact same input, recursively such that
>>>>>>>> the simulated ⟨Ĥ⟩ cannot possibly terminate normally.
>>>>>>>>
>>>>>>>> It has no idea about the behavior of the computation that
>>>>>>>> itself is embedded within.
>>>>>>>
>>>>>>> Maybe not, but it is the behavior that it is REQUIRED to decide
>>>>>>> on to be correct.
>>>>>>>
>>>>>>> That is either a widely held misconception or an the
>>>>>>> incoherent requirement of simultaneous mutually exclusive
>>>>>>> properties.
>>>>>>>
>>>>>>> Nothing is computable that is not a pure function of its
>>>>>>> inputs and the behavior of the computation that a decider
>>>>>>> is contained within is absolutely not a pure function its
>>>>>>> actual inputs.
>>>>>>
>>>>>>     So, what else could the ACTUAL
>>>>>>     Halting question of:
>>>>>>     "Does the machine represented by the
>>>>>>     input to the decider Halt?"
>>>>>>
>>>>>> Does D simulated by H reach it own final state?
>>>>>>
>>>>>
>>>>>     Which is only correct *IF* H meets
>>>>>     the definition of a UTM,
>>>>>
>>>>> Not at all. H merely must simulate the actual sequence
>>>>> of states that it is actually presented with.
>>>>>
>>>>> This does include a call from its input to a copy of
>>>>> itself that will never stop copying and calling other
>>>>> copies unless this H right here stops them.
>>>>>
>>>>> If this H right here does not stop them then no H anywhere
>>>>> will ever stop them because
>>>>> (a) They all have the same machine description
>>>>> (b) The outermost H always has the most execution trace information.
>>>>>
>>>>
>>>> H merely must simulate the actual sequence
>>>> of states that it is actually presented with.
>>>>
>>>> THIS DOES INCLUDE THAT THESE STATES DO CONTINUE
>>>> TO CALL A COPY OF H WITH IDENTICAL INPUT UNTIL
>>>> THIS H STOPS THEM
>>>
>>> When one definition says that:
>>> (A) H must look at the direct execution of its input
>>> and another definition of computation says that:
>>> (B) H is not allowed to look at the computation that
>>> contains itself
>>>
>>> THEY CAN'T BOTH BE RIGHT
>>>
>>
>> But how does (B) apply, since the input doesn't say that H need to
>> look at "itself" but at something that just happens to be copy of itself.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Yet you keep saying directly executed Ĥ ⟨Ĥ⟩ must be looked at and
>> this IS forbidden. *embedded_H simulates ⟨Ĥ⟩ and sees how it continues*
>> *to call embedded_H in recursive simulation until embedded_H stops it*
>>
>
> No decider is allowed yo examine the computation
> that contains itself because all computations must
> be a pure function of their inputs and itself <is not>
> its input. This means that embedded_H is not allowed
> to look at the direct execution of Ĥ ⟨Ĥ⟩.

Since we know that embedded_H is not allowed to base its
halt status decision on the behavior of the direct execution
of Ĥ ⟨Ĥ⟩ then requiring it to base its halt status decision
of this basis is known to be incorrect.

You agree with the first part and disagree with the second
part that <is> a necessary consequence of the first part.

I have no need to add ad hominem colored statement that
this means you must be very bad at logic, I simply stick
with the objective facts and let the chips fall where they may.

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