A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

Because we can see that a correct simulation of the input to embedded_H
cannot possibly reach its final state we can see that this input never
halts.

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

Whether or not it is even possible for embedded_H to recognize this
infinitely nested simulation does not matter (for refuting Linz).

As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
that rejecting its input forms a necessary contradiction.
(bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf

After we have mutual agreement on the above point we can move on to how
embedded_H would use finite string comparison to detect that its input
specifies infinitely nested simulation.

Halting problem undecidability and infinitely nested simulation (V4)

https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2021 Pete Olcott

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

On 3/21/2022 9:59 PM, wij wrote:
> On Tuesday, 22 March 2022 at 10:05:09 UTC+8, olcott wrote:
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>
>> Because we can see that a correct simulation of the input to embedded_H
>> cannot possibly reach its final state we can see that this input never
>> halts.
>>
>> computation that halts … the Turing machine will halt whenever it enters
>> a final state. (Linz:1990:234)
>>
>> Whether or not it is even possible for embedded_H to recognize this
>> infinitely nested simulation does not matter (for refuting Linz).
>>
>> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
>> that rejecting its input forms a necessary contradiction.
>> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>>
>>
>>
>> After we have mutual agreement on the above point we can move on to how
>> embedded_H would use finite string comparison to detect that its input
>> specifies infinitely nested simulation.
>>
>> Halting problem undecidability and infinitely nested simulation (V4)
>>
>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> The H of the Halting Problem is not required to detect any infinite loop. H is
> only required to report whether the given algorithm instance P halts or not.
>
> Firstly, proving the conventional liar-paradox-like instance is wrong to prove
> the Halting Problem is decidable. At most, such proof proves HP is still
> unsolved. That HP remains unsolved is the most what such an approach can get.
>
> Secondly, you modified Linz's proof to your POOP. Nothing you say is therefore
> valid to the true/false status of Linz's proof.
>
> The discussion is at most about your POOP.

It is about the halting problem because embedded_H rejects its input on
the basis that it specifies a non-halting sequence of configurations.

When the Linz H embedded in the Linz Ĥ (as a simulating halt decider)
rejects its input it is correct even if it does not know that it is
correct. That it is correct refutes the Linz conclusion that it cannot
possibly be correct.

--
Copyright 2021 Pete Olcott

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

On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
> olcott <NoOne@NoWhere.com> writes:
>
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>
> But for your "PO-machines":
>
> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
> corresponds to
> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>
> and
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>
> so this has nothing to do with Linz. He is talking about Turing
> machines.
>

The Linz conclusion only pertains to the behavior the copy of H
embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge from
this point:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 5:50 AM, Richard Damon wrote:
> On 3/21/22 10:39 PM, olcott wrote:
>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>
>>> On 3/21/22 10:05 PM, olcott wrote:
>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>> (SHD).
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>> its final state.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>> ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>> ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> Because we can see that a correct simulation of the input to
>>>> embedded_H cannot possibly reach its final state we can see that
>>>> this input never halts.
>>>
>>>
>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Never halts means that the simulated input will never reach its final
>> state whether or not its simulation is aborted.
>>
>
> Never Halts means the TURING MACHINE will never reach a final state.
> (Where do you get 'Simulation' out of the definition?)
>

AS YOU ALREADY KNOW:
An executed Turing machine and a Turing machine description simulated by
a UTM are computationally equivalent.

Pretending to not know these things just so that you are can remain
disagreeable is quite a jackass move.

> YOu can replace that with a simulation that is ACCURATE, but to be
> accurate for non-halting, it must NOT be aborted, i.e., must run forever.
>

YET ANOTHER JACKASS MOVE:
You know that aborting the simulation of a Turing machine description
that would never reach its final state does not cause this Turing
machine description to reach its final state.

Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H specifies a
sequence of configuration that never reach their final state under any
circumstances.

Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot meet the
Linz definition of a

computation that halts … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234) UNDER ANY CIRCUMSTANCES

Therefore you know that when embedded_H rejects its input it is correct.

Therefore you know that when embedded_H rejects its input it and is
correct the Linz proof that asserts that rejecting its input results in
a contradiction is refuted.

> The fact that an aborted simulation didn't reach a final state is NOT
> proof that the machine in non-halting.
>
> You don't evn understand basic English.
>

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>> final state.
>>> But for your "PO-machines":
>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>> corresponds to
>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>> and
>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>> so this has nothing to do with Linz. He is talking about Turing
>>> machines.
>>>
>>
>> The Linz conclusion only pertains to the behavior the copy of H
>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Everything Linz says, everything, is predicated on what a Turing machine
> is. Unlike Turing machines, your machines are magic -- identical state
> transition functions can entail different configuration sequences for
> the same input. Nothing you say has any relevance to Linz's Turing
> machines until you categorically repudiate this nonsense.
>

That your only rebuttal to what I say now is dredging up what I said
many months ago proves that you are being dishonest.

It is the case that the pure simulation of the input to the simulating
halt decider Linz H embedded at Ĥ.qx would never reach the final state
of this simulated input.

You ignore this and change the subject only because you know that it is
correct and have denigration rather than honest critique as your only goal.

>> I don't have time to diverge from this point:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>
> And, since the action of your magic machines are not constrained by the
> state transition function and the input, I can assert that a copy of
> our Ĥ does this:
>

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

The above shows that the simulated input to embedded_H will never reach
its own final state whether or not its simulation is aborted thus never
meets the Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

Halting problem undecidability and infinitely nested simulation (V4)
https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 5:57 PM, Richard Damon wrote:
> On 3/22/22 10:13 AM, olcott wrote:
>> On 3/22/2022 5:50 AM, Richard Damon wrote:
>>> On 3/21/22 10:39 PM, olcott wrote:
>>>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/21/22 10:05 PM, olcott wrote:
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>> (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>> its final state.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>
>>>>>> Because we can see that a correct simulation of the input to
>>>>>> embedded_H cannot possibly reach its final state we can see that
>>>>>> this input never halts.
>>>>>
>>>>>
>>>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>>>
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Never halts means that the simulated input will never reach its
>>>> final state whether or not its simulation is aborted.
>>>>
>>>
>>> Never Halts means the TURING MACHINE will never reach a final state.
>>> (Where do you get 'Simulation' out of the definition?)
>>>
>>
>> AS YOU ALREADY KNOW:
>> An executed Turing machine and a Turing machine description simulated
>> by a UTM are computationally equivalent.
>>
>> Pretending to not know these things just so that you are can remain
>> disagreeable is quite a jackass move.
>>
>>> YOu can replace that with a simulation that is ACCURATE, but to be
>>> accurate for non-halting, it must NOT be aborted, i.e., must run
>>> forever.
>>>
>>
>> YET ANOTHER JACKASS MOVE:
>> You know that aborting the simulation of a Turing machine description
>> that would never reach its final state does not cause this Turing
>> machine description to reach its final state.
>
> The problem you have is that that the simulation that shows it would
> never reach a final state requries that H/embedded_H NEVER abort its
> simulation.
So basically when the simulated input has had it simulation aborted it
continues on and reaches its final state even though it was aborted.

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 5:59 PM, Richard Damon wrote:
> On 3/22/22 10:16 AM, olcott wrote:
>> On 3/22/2022 6:00 AM, Richard Damon wrote:
>>> On 3/21/22 11:59 PM, olcott wrote:
>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>> (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>>
>>>>> But for your "PO-machines":
>>>>>
>>>>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>    corresponds to
>>>>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>
>>>>> and
>>>>>
>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>> halts.
>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>
>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>> machines.
>>>>>
>>>>
>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge
>>>> from this point:
>>>
>>> No, it applies to ALL copies of H, because they ALL behave the same.
>>
>> Because the outermost simulation sees that its abort criteria is met
>> before any of the inner simulations have seen this criteria the
>> outermost simulation aborts all the rest which cuts off their behavior.
>>
>>
>
> But we don't care about simulations, we care about actual machine
> exectuitons.

So yet again you reject the computational equivalence of the direct
execution of a Turing machine with the UTM simulation of the Turing
machine description of this same machine.

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 6:00 PM, Richard Damon wrote:
> On 3/22/22 10:46 AM, olcott wrote:
>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>> (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>> But for your "PO-machines":
>>>>>     "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>     corresponds to
>>>>>     H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>> and
>>>>>     "The copy of H at Ĥ.qx correctly decides that its input never
>>>>> halts.
>>>>>     H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>> machines.
>>>>>
>>>>
>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Everything Linz says, everything, is predicated on what a Turing machine
>>> is.  Unlike Turing machines, your machines are magic -- identical state
>>> transition functions can entail different configuration sequences for
>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>> machines until you categorically repudiate this nonsense.
>>>
>>
>> That your only rebuttal to what I say now is dredging up what I said
>> many months ago proves that you are being dishonest.
>>
>> It is the case that the pure simulation of the input to the simulating
>> halt decider Linz H embedded at Ĥ.qx would never reach the final state
>> of this simulated input.
>>
>> You ignore this and change the subject only because you know that it
>> is correct and have denigration rather than honest critique as your
>> only goal.
>>
>>>> I don't have time to diverge from this point:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>>> state.
>>>
>>> And, since the action of your magic machines are not constrained by the
>>> state transition function and the input, I can assert that a copy of
>>> our Ĥ does this:
>>>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>> ⟨Ĥ4⟩...
>>
>> The above shows that the simulated input to embedded_H will never
>> reach its own final state whether or not its simulation is aborted
>> thus never meets the Linz definition of halting:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V4)
>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>
>>
>
> The above only doesn't halt if embedded_H never aborts its simulation,
And it doesn't halt if embedded_H DOES abort its simulation, therefore
it doesn't halt under any condition.

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 6:41 PM, André G. Isaak wrote:
> On 2022-03-22 17:07, olcott wrote:
>> On 3/22/2022 5:57 PM, Richard Damon wrote:
>
>>> The problem you have is that that the simulation that shows it would
>>> never reach a final state requries that H/embedded_H NEVER abort its
>>> simulation.
>> So basically when the simulated input has had it simulation aborted it
>> continues on and reaches its final state even though it was aborted.
>>
>
> As usual, you are horrendously confused.
>
> If a TM acting on some input halts after 125 steps and I simulate it in
> some partial simulator which simulates 100 steps and then aborts its
> simulation, the simulation never reaches a final state, but the
> computation is still a halting computation.
>

Yes you are correct. When a simulating halt decider correctly determines
that its correctly simulated input would never reach its final state
then and only then it can correctly abort the simulation of this input
and correctly transition to its reject state.

> When you abort a simulation after N steps, all that tells us is that the
> computation either doesn't halt or halts after more than N steps.
>
> André
>

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 6:29 PM, Richard Damon wrote:
> On 3/22/22 7:13 PM, olcott wrote:
>> On 3/22/2022 6:00 PM, Richard Damon wrote:
>>> On 3/22/22 10:46 AM, olcott wrote:
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>> decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>> reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>>     "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>     corresponds to
>>>>>>>     H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>>     "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>>> halts.
>>>>>>>     H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>> machine
>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>> state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>>
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>>>
>>>> It is the case that the pure simulation of the input to the
>>>> simulating halt decider Linz H embedded at Ĥ.qx would never reach
>>>> the final state of this simulated input.
>>>>
>>>> You ignore this and change the subject only because you know that it
>>>> is correct and have denigration rather than honest critique as your
>>>> only goal.
>>>>
>>>>>> I don't have time to diverge from this point:
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>>>>> state.
>>>>>
>>>>> And, since the action of your magic machines are not constrained by
>>>>> the
>>>>> state transition function and the input, I can assert that a copy of
>>>>> our Ĥ does this:
>>>>>
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>> ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>> ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> The above shows that the simulated input to embedded_H will never
>>>> reach its own final state whether or not its simulation is aborted
>>>> thus never meets the Linz definition of halting:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>
>>>>
>>>
>>> The above only doesn't halt if embedded_H never aborts its simulation,
>> And it doesn't halt if embedded_H DOES abort its simulation, therefore
>> it doesn't halt under any condition.
>>
>
> Except that the actual machine DOES Halt, as does the UTM simulation.

Because the simulated Turing machine description cannot possibly reach
its final state it is necessarily correct for embedded_ to compute the
mapping from its input ⟨Ĥ⟩ ⟨Ĥ⟩ to its final reject state Ĥ.qn

When you have a dog in your living room you know that this dog is not a
cat, not even if the theory of computation says that it is.

--
Copyright 2021 Pete Olcott

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

On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>> But for your "PO-machines":
>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>> corresponds to
>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>> and
>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>> machines.
>>>>>
>>>>
>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Everything Linz says, everything, is predicated on what a Turing machine
>>> is. Unlike Turing machines, your machines are magic -- identical state
>>> transition functions can entail different configuration sequences for
>>> the same input. Nothing you say has any relevance to Linz's Turing
>>> machines until you categorically repudiate this nonsense.
>>
>> That your only rebuttal to what I say now is dredging up what I said
>> many months ago proves that you are being dishonest.
>
> You said this:
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>

If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
same result. They are not identical final strings.

> four days ago and you haven't retracted it. Until you do, when you
> write Ĥ your readers must assume that you are referring to something
> about which this quote applies.
>
> What's more, for your remarks to have any bearing on Linz's Ĥ you must
> not only repudiate what you said, you must accept the converse,
> i.e. that if
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>
> then
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>
> So, do you retract what you said and accept this fact about Linz's H and
> Ĥ?
>

You you continue to say that you believe that a decider must report on
its own behavior when you already know damn well that a decider only
computes the mapping from its inputs to its own final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

The above shows that the simulated input to embedded_H will never reach
its own final state whether or not its simulation is aborted thus never
meets the Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 6:19 AM, Richard Damon wrote:
> On 3/23/22 12:00 AM, olcott wrote:
>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>> decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>> reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>      corresponds to
>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>> never halts.
>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>> machine
>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>> state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>>
>>> You said this:
>>>
>>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>
>>
>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>> same result. They are not identical final strings.
>>
>>> four days ago and you haven't retracted it.  Until you do, when you
>>> write Ĥ your readers must assume that you are referring to something
>>> about which this quote applies.
>>>
>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>> not only repudiate what you said, you must accept the converse,
>>> i.e. that if
>>>
>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>
>>> then
>>>
>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>
>>> So, do you retract what you said and accept this fact about Linz's H and
>>> Ĥ?
>>>
>>
>> You you continue to say that you believe that a decider must report on
>> its own behavior when you already know damn well that a decider only
>> computes the mapping from its inputs to its own final state.
>
> A Decider must report on its own behavior (or the behavior of a copy of
> it) if that is what the input asks for.
>
You know that a decider only computes the mapping from its input finite
strings to its own final state thus you know that you lie what you say
that a decider must compute the mapping from a non-finite sting non-input.

WHY LIE ? WHY LIE ? WHY LIE ? WHY LIE ?

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>> corresponds to
>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>> You said this:
>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>> same result. They are not identical final strings.
>
> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
> different transitions than H does, since they both have identical
> inputs. If one compares some strings, the other will too and they will
> both arrive as the same result and they will both behave in the same
> way. You H and Ĥ are obviously not Turing machines.
>
> I regret dropping down into simplistic metaphors. I'd rather keep this
> about formal Turing machines, but you don't really know what they are,
> and you certainly can't reason about them, so that hits a brick wall
> pretty quickly.
>
>>> four days ago and you haven't retracted it. Until you do, when you
>>> write Ĥ your readers must assume that you are referring to something
>>> about which this quote applies.
>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>> not only repudiate what you said, you must accept the converse,
>>> i.e. that if
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>> then
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>> So, do you retract what you said and accept this fact about Linz's H and
>>> Ĥ?
>>
>> You you continue to say that you believe that a decider must report on
>> its own behavior when you already know damn well that a decider only
>> computes the mapping from its inputs to its own final state.
>
> I continue to believe that I know what a Turing machine is and that you
> don't. A Turing machine and an exact copy of it can't entail different
> sequences of transitions. Your H and Ĥ don't have this property. They
> are not Turing machines.
>

I agree that a TM and an exact copy of it must entail the same sequence
of transitions when applied to identical input.

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>> final state.
>>>>>>>>> But for your "PO-machines":
>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>> corresponds to
>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>> and
>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>> machines.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>> transition functions can entail different configuration sequences for
>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>
>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>> many months ago proves that you are being dishonest.
>>>>> You said this:
>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>
>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>> same result. They are not identical final strings.
>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>> different transitions than H does, since they both have identical
>>> inputs. If one compares some strings, the other will too and they will
>>> both arrive as the same result and they will both behave in the same
>>> way. You H and Ĥ are obviously not Turing machines.
>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>> about formal Turing machines, but you don't really know what they are,
>>> and you certainly can't reason about them, so that hits a brick wall
>>> pretty quickly.
>>>
>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>> write Ĥ your readers must assume that you are referring to something
>>>>> about which this quote applies.
>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>> not only repudiate what you said, you must accept the converse,
>>>>> i.e. that if
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>> then
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>> Ĥ?
>>>>
>>>> You you continue to say that you believe that a decider must report on
>>>> its own behavior when you already know damn well that a decider only
>>>> computes the mapping from its inputs to its own final state.
>>>
>>> I continue to believe that I know what a Turing machine is and that you
>>> don't. A Turing machine and an exact copy of it can't entail different
>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>> are not Turing machines.
>>
>> I agree that a TM and an exact copy of it must entail the same
>> sequence of transitions when applied to identical input.
>
> OK, but what about your magic PO-machines? They don't behave like this
> (apparently). It's easy to agree to facts about Turing machines, if
> your plan is to keep talking about machines where
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

Not if H and Ĥ are identical and are not allowed to use their machine
address to tell them apart.

In my prior claims either H and Ĥ were not identical finite stings or
they were identical finite stings at different machine addresses and
they were allowed to use this machine address difference as their halt
status criteria.

From what I recall I explained all this before in complete detail but
you were so sure that I must be wrong that your made sure to repeatedly
always ignore this explanation.

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 6:26 PM, Richard Damon wrote:
> On 3/23/22 7:20 PM, olcott wrote:
>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>> On 3/23/22 9:09 AM, olcott wrote:
>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>> its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>>> reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>      corresponds to
>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>> and
>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>> never halts.
>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>> halts"
>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>>>>> machines.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>> Turing machine
>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>> identical state
>>>>>>>>> transition functions can entail different configuration
>>>>>>>>> sequences for
>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>> Turing
>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>
>>>>>>>> That your only rebuttal to what I say now is dredging up what I
>>>>>>>> said
>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>
>>>>>>> You said this:
>>>>>>>
>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>>> halts.
>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>
>>>>>>
>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive
>>>>>> the same result. They are not identical final strings.
>>>>>>
>>>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>>> about which this quote applies.
>>>>>>>
>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you
>>>>>>> must
>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>> i.e. that if
>>>>>>>
>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>
>>>>>>> then
>>>>>>>
>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>
>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>> Linz's H and
>>>>>>> Ĥ?
>>>>>>>
>>>>>>
>>>>>> You you continue to say that you believe that a decider must
>>>>>> report on its own behavior when you already know damn well that a
>>>>>> decider only computes the mapping from its inputs to its own final
>>>>>> state.
>>>>>
>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>> copy of it) if that is what the input asks for.
>>>>>
>>>> You know that a decider only computes the mapping from its input
>>>> finite strings to its own final state thus you know that you lie
>>>> what you say that a decider must compute the mapping from a
>>>> non-finite sting non-input.
>>>>
>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>
>>>
>>> I don't, but you seem to like to.
>>>
>>> I never said that H needs to compute a mapping of anything but what
>>> has been given as an input.
>>>
>>> The only thing H needs to compute the mapping of is <H^> <H^>, which
>>> is EXACTLY the string on its input.
>>>
>>> The problem which you don't seem to understand is that the MAPPING it
>>> needs to try and compute (and which is not guaranteed to BE
>>> Computable), is the Behavior of the machine it represents, H^ applied
>>> to <H^>, as that is the mapping of the Halting Function.
>>
>> That is a non finite string non input, so you lied.
>>
>
> <H^> <H^> is a finite string, which is what needs to be mapped, so you
> are just lying.
>

On 3/23/2022 6:04 PM, Richard Damon wrote:
> the MAPPING it needs to try and compute (and which is
> not guaranteed to BE Computable), is the Behavior of
> the machine it represents, H^ applied to <H^>,

So you are just bald faced liar then.
It does not map H^ applied to <H^> to anything.
It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 7:15 PM, Richard Damon wrote:
> On 3/23/22 7:50 PM, olcott wrote:
>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>> On 3/23/22 7:20 PM, olcott wrote:
>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>> and
>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>> halts"
>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>> Turing
>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>> Turing machine
>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>> identical state
>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>> sequences for
>>>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>>>> Turing
>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>
>>>>>>>>>> That your only rebuttal to what I say now is dredging up what
>>>>>>>>>> I said
>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>
>>>>>>>>> You said this:
>>>>>>>>>
>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>> never halts.
>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>
>>>>>>>>
>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>
>>>>>>>>> four days ago and you haven't retracted it.  Until you do, when
>>>>>>>>> you
>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>> something
>>>>>>>>> about which this quote applies.
>>>>>>>>>
>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>> you must
>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>> i.e. that if
>>>>>>>>>
>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>
>>>>>>>>> then
>>>>>>>>>
>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>
>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>> Linz's H and
>>>>>>>>> Ĥ?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>> report on its own behavior when you already know damn well that
>>>>>>>> a decider only computes the mapping from its inputs to its own
>>>>>>>> final state.
>>>>>>>
>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>
>>>>>> You know that a decider only computes the mapping from its input
>>>>>> finite strings to its own final state thus you know that you lie
>>>>>> what you say that a decider must compute the mapping from a
>>>>>> non-finite sting non-input.
>>>>>>
>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>
>>>>>
>>>>> I don't, but you seem to like to.
>>>>>
>>>>> I never said that H needs to compute a mapping of anything but what
>>>>> has been given as an input.
>>>>>
>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>> which is EXACTLY the string on its input.
>>>>>
>>>>> The problem which you don't seem to understand is that the MAPPING
>>>>> it needs to try and compute (and which is not guaranteed to BE
>>>>> Computable), is the Behavior of the machine it represents, H^
>>>>> applied to <H^>, as that is the mapping of the Halting Function.
>>>>
>>>> That is a non finite string non input, so you lied.
>>>>
>>>
>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>> you are just lying.
>>>
>>
>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>  > the MAPPING it needs to try and compute (and which is
>>  > not guaranteed to BE Computable), is the Behavior of
>>  > the machine it represents, H^ applied to <H^>,
>>
>> So you are just bald faced liar then.
>> It does not map H^ applied to <H^> to anything.
>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>
>>
>
> I never said it did.
>
> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
> FUNCTION) whether H^ applied to <H^> will Halt.

It must map the input to an accept or reject state based on the actual
behavior actually specified by this input as measured by N steps of the
correct UTM simulation of this input.

On 3/23/2022 8:39 PM, Richard Damon wrote:
> On 3/23/22 9:29 PM, olcott wrote:
>> On 3/23/2022 7:15 PM, Richard Damon wrote:
>>> On 3/23/22 7:50 PM, olcott wrote:
>>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating
>>>>>>>>>>>>>>>> halt decider (SHD).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its
>>>>>>>>>>>>>>> input halts"
>>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy
>>>>>>>>>>>>>> of H
>>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>>>> Turing machine
>>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>>>> identical state
>>>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>>>> sequences for
>>>>>>>>>>>>> the same input.  Nothing you say has any relevance to
>>>>>>>>>>>>> Linz's Turing
>>>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>>>
>>>>>>>>>>>> That your only rebuttal to what I say now is dredging up
>>>>>>>>>>>> what I said
>>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>>
>>>>>>>>>>> You said this:
>>>>>>>>>>>
>>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>> never halts.
>>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>>>
>>>>>>>>>>> four days ago and you haven't retracted it.  Until you do,
>>>>>>>>>>> when you
>>>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>>>> something
>>>>>>>>>>> about which this quote applies.
>>>>>>>>>>>
>>>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>>>> you must
>>>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>>>> i.e. that if
>>>>>>>>>>>
>>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> then
>>>>>>>>>>>
>>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>>
>>>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>>>> Linz's H and
>>>>>>>>>>> Ĥ?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>>>> report on its own behavior when you already know damn well
>>>>>>>>>> that a decider only computes the mapping from its inputs to
>>>>>>>>>> its own final state.
>>>>>>>>>
>>>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>>>
>>>>>>>> You know that a decider only computes the mapping from its input
>>>>>>>> finite strings to its own final state thus you know that you lie
>>>>>>>> what you say that a decider must compute the mapping from a
>>>>>>>> non-finite sting non-input.
>>>>>>>>
>>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>>
>>>>>>>
>>>>>>> I don't, but you seem to like to.
>>>>>>>
>>>>>>> I never said that H needs to compute a mapping of anything but
>>>>>>> what has been given as an input.
>>>>>>>
>>>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>>>> which is EXACTLY the string on its input.
>>>>>>>
>>>>>>> The problem which you don't seem to understand is that the
>>>>>>> MAPPING it needs to try and compute (and which is not guaranteed
>>>>>>> to BE Computable), is the Behavior of the machine it represents,
>>>>>>> H^ applied to <H^>, as that is the mapping of the Halting Function.
>>>>>>
>>>>>> That is a non finite string non input, so you lied.
>>>>>>
>>>>>
>>>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>>>> you are just lying.
>>>>>
>>>>
>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>  > the MAPPING it needs to try and compute (and which is
>>>>  > not guaranteed to BE Computable), is the Behavior of
>>>>  > the machine it represents, H^ applied to <H^>,
>>>>
>>>> So you are just bald faced liar then.
>>>> It does not map H^ applied to <H^> to anything.
>>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>
>>>>
>>>
>>> I never said it did.
>>>
>>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>>> FUNCTION) whether H^ applied to <H^> will Halt.
>>
>> It must map the input to an accept or reject state based on the actual
>> behavior actually specified by this input as measured by N steps of
>> the correct UTM simulation of this input.
>>
>>
>
> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn, based on
> the FUNCTION it is computing.
>
> There is NO requirement that it be based on its on simulation, or only N
> steps of a UTM.
>

On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>> corresponds to
>>>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>> and
>>>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>>>> machines.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>>>> transition functions can entail different configuration sequences for
>>>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>
>>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>> You said this:
>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>
>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>>>> same result. They are not identical final strings.
>>>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>>>> different transitions than H does, since they both have identical
>>>>> inputs. If one compares some strings, the other will too and they will
>>>>> both arrive as the same result and they will both behave in the same
>>>>> way. You H and Ĥ are obviously not Turing machines.
>>>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>>>> about formal Turing machines, but you don't really know what they are,
>>>>> and you certainly can't reason about them, so that hits a brick wall
>>>>> pretty quickly.
>>>>>
>>>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>>> about which this quote applies.
>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>> i.e. that if
>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>> then
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>>>> Ĥ?
>>>>>>
>>>>>> You you continue to say that you believe that a decider must report on
>>>>>> its own behavior when you already know damn well that a decider only
>>>>>> computes the mapping from its inputs to its own final state.
>>>>>
>>>>> I continue to believe that I know what a Turing machine is and that you
>>>>> don't. A Turing machine and an exact copy of it can't entail different
>>>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>>>> are not Turing machines.
>>>>
>>>> I agree that a TM and an exact copy of it must entail the same
>>>> sequence of transitions when applied to identical input.
>>> OK, but what about your magic PO-machines? They don't behave like this
>>> (apparently). It's easy to agree to facts about Turing machines, if
>>> your plan is to keep talking about machines where
>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>> Not if H and Ĥ are identical and are not allowed to use their machine
>> address to tell them apart.
>
> H and Ĥ are never identical. You know what the hat means don't you? So
> your magic PO-machines have machine addresses, do they? If so, that's
> another difference with Turing machines. You won't be able to say
> anything about Linz's proof unless you start to talk about Turing
> machines.
>
>> In my prior claims either H and Ĥ were not identical finite stings
>
> You've lost the plot mate. Nether is even a string. If you made a
> prior claim about H or Ĥ being strings (whether identical or not), that
> was wrong too.
>
> As far as I can tell, when you write H and Ĥ we must assume that these
> refer to some kind of as yet unspecified machine that has "machine
> addresses" (so definitely not what Linz is taking about). And that
> these H and Ĥ have the property that H applied to some string can
> transition to a different state to an exact copy of H if it's embedded
> in some other machine. I suppose they don't actually have to be
> literally magic to do this, but they are certainly not Turing machines.
>
> Do you have anything to say about Linz's proof?
>

All halt deciders must map their input to an accept or reject state
based on the actual behavior actually specified by this input as
measured by a finite number of N steps of the correct UTM simulation of
this input.

This does not mean that they must simulate their input. It means that
the behavior that they are reporting on must be the same behavior that
would occur by a UTM simulation of N steps.

The constraint of a finite number of N steps is required to guarantee
that the halt decider always reports.

--
Copyright 2021 Pete Olcott

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

On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>> corresponds to
>>>>>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>> and
>>>>>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>>>>>> transition functions can entail different configuration sequences for
>>>>>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>
>>>>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>> You said this:
>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>
>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>>>>>> same result. They are not identical final strings.
>>>>>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>>>>>> different transitions than H does, since they both have identical
>>>>>>> inputs. If one compares some strings, the other will too and they will
>>>>>>> both arrive as the same result and they will both behave in the same
>>>>>>> way. You H and Ĥ are obviously not Turing machines.
>>>>>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>>>>>> about formal Turing machines, but you don't really know what they are,
>>>>>>> and you certainly can't reason about them, so that hits a brick wall
>>>>>>> pretty quickly.
>>>>>>>
>>>>>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>>>>> about which this quote applies.
>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>> i.e. that if
>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>> then
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>>>>>> Ĥ?
>>>>>>>>
>>>>>>>> You you continue to say that you believe that a decider must report on
>>>>>>>> its own behavior when you already know damn well that a decider only
>>>>>>>> computes the mapping from its inputs to its own final state.
>>>>>>>
>>>>>>> I continue to believe that I know what a Turing machine is and that you
>>>>>>> don't. A Turing machine and an exact copy of it can't entail different
>>>>>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>>>>>> are not Turing machines.
>>>>>>
>>>>>> I agree that a TM and an exact copy of it must entail the same
>>>>>> sequence of transitions when applied to identical input.
>>>>> OK, but what about your magic PO-machines? They don't behave like this
>>>>> (apparently). It's easy to agree to facts about Turing machines, if
>>>>> your plan is to keep talking about machines where
>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>
>>>> Not if H and Ĥ are identical and are not allowed to use their machine
>>>> address to tell them apart.
>>> H and Ĥ are never identical. You know what the hat means don't you? So
>>> your magic PO-machines have machine addresses, do they? If so, that's
>>> another difference with Turing machines. You won't be able to say
>>> anything about Linz's proof unless you start to talk about Turing
>>> machines.
>>>
>>>> In my prior claims either H and Ĥ were not identical finite stings
>>> You've lost the plot mate. Nether is even a string. If you made a
>>> prior claim about H or Ĥ being strings (whether identical or not), that
>>> was wrong too.
>>>
>>> As far as I can tell, when you write H and Ĥ we must assume that these
>>> refer to some kind of as yet unspecified machine that has "machine
>>> addresses" (so definitely not what Linz is taking about). And that
>>> these H and Ĥ have the property that H applied to some string can
>>> transition to a different state to an exact copy of H if it's embedded
>>> in some other machine. I suppose they don't actually have to be
>>> literally magic to do this, but they are certainly not Turing machines.
>>> Do you have anything to say about Linz's proof?
>>
>> All halt deciders must map their input to an accept or reject state
>> based on the actual behavior actually specified by this input as
>> measured by a finite number of N steps of the correct UTM simulation
>> of this input.
>
> No. You'll find what a halt decider must do in any good text book.
>
> It appears that after 17 years of work in this you are:
>
> (a) trying to redefine what that halting problem is;
>

On 3/23/2022 9:31 PM, Richard Damon wrote:
>
> On 3/23/22 10:01 PM, olcott wrote:
>> On 3/23/2022 8:39 PM, Richard Damon wrote:
>>> On 3/23/22 9:29 PM, olcott wrote:
>>>> On 3/23/2022 7:15 PM, Richard Damon wrote:
>>>>> On 3/23/22 7:50 PM, olcott wrote:
>>>>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating
>>>>>>>>>>>>>>>>>> halt decider (SHD).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its
>>>>>>>>>>>>>>>>> input halts"
>>>>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking
>>>>>>>>>>>>>>>>> about Turing
>>>>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the
>>>>>>>>>>>>>>>> copy of H
>>>>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>>>>>> Turing machine
>>>>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>>>>>> identical state
>>>>>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>>>>>> sequences for
>>>>>>>>>>>>>>> the same input.  Nothing you say has any relevance to
>>>>>>>>>>>>>>> Linz's Turing
>>>>>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That your only rebuttal to what I say now is dredging up
>>>>>>>>>>>>>> what I said
>>>>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You said this:
>>>>>>>>>>>>>
>>>>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>> halts"
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>>>>>
>>>>>>>>>>>>> four days ago and you haven't retracted it.  Until you do,
>>>>>>>>>>>>> when you
>>>>>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>>>>>> something
>>>>>>>>>>>>> about which this quote applies.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What's more, for your remarks to have any bearing on Linz's
>>>>>>>>>>>>> Ĥ you must
>>>>>>>>>>>>> not only repudiate what you said, you must accept the
>>>>>>>>>>>>> converse,
>>>>>>>>>>>>> i.e. that if
>>>>>>>>>>>>>
>>>>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> then
>>>>>>>>>>>>>
>>>>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>>>>>> Linz's H and
>>>>>>>>>>>>> Ĥ?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>>>>>> report on its own behavior when you already know damn well
>>>>>>>>>>>> that a decider only computes the mapping from its inputs to
>>>>>>>>>>>> its own final state.
>>>>>>>>>>>
>>>>>>>>>>> A Decider must report on its own behavior (or the behavior of
>>>>>>>>>>> a copy of it) if that is what the input asks for.
>>>>>>>>>>>
>>>>>>>>>> You know that a decider only computes the mapping from its
>>>>>>>>>> input finite strings to its own final state thus you know that
>>>>>>>>>> you lie what you say that a decider must compute the mapping
>>>>>>>>>> from a non-finite sting non-input.
>>>>>>>>>>
>>>>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I don't, but you seem to like to.
>>>>>>>>>
>>>>>>>>> I never said that H needs to compute a mapping of anything but
>>>>>>>>> what has been given as an input.
>>>>>>>>>
>>>>>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>>>>>> which is EXACTLY the string on its input.
>>>>>>>>>
>>>>>>>>> The problem which you don't seem to understand is that the
>>>>>>>>> MAPPING it needs to try and compute (and which is not
>>>>>>>>> guaranteed to BE Computable), is the Behavior of the machine it
>>>>>>>>> represents, H^ applied to <H^>, as that is the mapping of the
>>>>>>>>> Halting Function.
>>>>>>>>
>>>>>>>> That is a non finite string non input, so you lied.
>>>>>>>>
>>>>>>>
>>>>>>> <H^> <H^> is a finite string, which is what needs to be mapped,
>>>>>>> so you are just lying.
>>>>>>>
>>>>>>
>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>  > the MAPPING it needs to try and compute (and which is
>>>>>>  > not guaranteed to BE Computable), is the Behavior of
>>>>>>  > the machine it represents, H^ applied to <H^>,
>>>>>>
>>>>>> So you are just bald faced liar then.
>>>>>> It does not map H^ applied to <H^> to anything.
>>>>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>
>>>>>>
>>>>>
>>>>> I never said it did.
>>>>>
>>>>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>>>>> FUNCTION) whether H^ applied to <H^> will Halt.
>>>>
>>>> It must map the input to an accept or reject state based on the
>>>> actual behavior actually specified by this input as measured by N
>>>> steps of the correct UTM simulation of this input.
>>>>
>>>>
>>>
>>> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn, based
>>> on the FUNCTION it is computing.
>>>
>>> There is NO requirement that it be based on its on simulation, or
>>> only N steps of a UTM.
>>>
>>
>> None-the-less if the behavior that is being measured is not exactly
>> the same behavior as the UTM simulation of the input then the behavior
>> being measured is measured incorrectly.
>>
>> A finite number of N steps is a mandatory constraint otherwise it
>> would be OK to report that infinite execution never halts after an
>> infinite number of steps.
>>
>
> You logic is backwards. You are just showing why it CAN'T be done, not
> why it must not be defined that way.
>
> The behavior that is measured MUST be exactly the behavior of the UTM
> simulation,

On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
>
>>>>> As far as I can tell, when you write H and Ĥ we must assume that these
>>>>> refer to some kind of as yet unspecified machine that has "machine
>>>>> addresses" (so definitely not what Linz is taking about). And that
>>>>> these H and Ĥ have the property that H applied to some string can
>>>>> transition to a different state to an exact copy of H if it's embedded
>>>>> in some other machine. I suppose they don't actually have to be
>>>>> literally magic to do this, but they are certainly not Turing machines.
>>>>> Do you have anything to say about Linz's proof?
>>>>
>>>> All halt deciders must map their input to an accept or reject state
>>>> based on the actual behavior actually specified by this input as
>>>> measured by a finite number of N steps of the correct UTM simulation
>>>> of this input.
>>>
>>> No. You'll find what a halt decider must do in any good text book.
>>> It appears that after 17 years of work in this you are:
>>>
>>> (a) trying to redefine what that halting problem is;
>>
>> Someone that understands these things deeper than learned by rote
>> would agree with me.
>
> No one agrees with the above. It's not the halting problem. What it
> is, ironically, is an admission that halting is undecidable! If you
> really thought it weren't, there would be no need to keep writing the
> condition for accepting an input incorrectly.
>

Certainly you can state this dogmatically, yet what you cannot do is
anchor this rebuttal in any sort of correct reasoning.

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever. https://en.wikipedia.org/wiki/Halting_problem

A halt decider must map its finite string input pair to an accept or
reject state on the basis of the actual halting / non-halting behavior
specified by this finite string pair.

It is the case that all deciders compute the mapping from their input
finite strings to their own accept or reject state.

It is the case that all deciders compute the mapping from their input
finite strings to their own accept or reject state on the basis of the
behavior specified by these finite strings.

It is the case that the behavior specified by these finite input strings
is correctly measured by the correct UTM simulation of these strings by
the simulating halt decider.

It is the case that the correctly simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
would never reach its final state.

It is the case that this causes the simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to
embedded_H to fail to match the Linz definition of a computation that
halts.

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

All of your replies have been dogma that would convince gullible fools.
None of your replies have pointed out any error in the above.

Bringing up things that I said months ago (your most recent tactic)
unrelated to the above is a dishonest dodge and you know it.

--
Copyright 2021 Pete Olcott

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

On 3/24/2022 6:12 AM, Richard Damon wrote:
> On 3/23/22 11:05 PM, olcott wrote:
>> On 3/23/2022 9:31 PM, Richard Damon wrote:
>>>
>>> On 3/23/22 10:01 PM, olcott wrote:
>>>> On 3/23/2022 8:39 PM, Richard Damon wrote:
>>>>> On 3/23/22 9:29 PM, olcott wrote:
>>>>>> On 3/23/2022 7:15 PM, Richard Damon wrote:
>>>>>>> On 3/23/22 7:50 PM, olcott wrote:
>>>>>>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>>>>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating
>>>>>>>>>>>>>>>>>>>> halt decider (SHD).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>> would reach its final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>> would never reach its
>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that
>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its
>>>>>>>>>>>>>>>>>>> input halts"
>>>>>>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking
>>>>>>>>>>>>>>>>>>> about Turing
>>>>>>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the
>>>>>>>>>>>>>>>>>> copy of H
>>>>>>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Everything Linz says, everything, is predicated on what
>>>>>>>>>>>>>>>>> a Turing machine
>>>>>>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>>>>>>>> identical state
>>>>>>>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>>>>>>>> sequences for
>>>>>>>>>>>>>>>>> the same input.  Nothing you say has any relevance to
>>>>>>>>>>>>>>>>> Linz's Turing
>>>>>>>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That your only rebuttal to what I say now is dredging up
>>>>>>>>>>>>>>>> what I said
>>>>>>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You said this:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>>>> halts"
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they
>>>>>>>>>>>>>> must derive the same result. They are not identical final
>>>>>>>>>>>>>> strings.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> four days ago and you haven't retracted it.  Until you
>>>>>>>>>>>>>>> do, when you
>>>>>>>>>>>>>>> write Ĥ your readers must assume that you are referring
>>>>>>>>>>>>>>> to something
>>>>>>>>>>>>>>> about which this quote applies.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What's more, for your remarks to have any bearing on
>>>>>>>>>>>>>>> Linz's Ĥ you must
>>>>>>>>>>>>>>> not only repudiate what you said, you must accept the
>>>>>>>>>>>>>>> converse,
>>>>>>>>>>>>>>> i.e. that if
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, do you retract what you said and accept this fact
>>>>>>>>>>>>>>> about Linz's H and
>>>>>>>>>>>>>>> Ĥ?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You you continue to say that you believe that a decider
>>>>>>>>>>>>>> must report on its own behavior when you already know damn
>>>>>>>>>>>>>> well that a decider only computes the mapping from its
>>>>>>>>>>>>>> inputs to its own final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A Decider must report on its own behavior (or the behavior
>>>>>>>>>>>>> of a copy of it) if that is what the input asks for.
>>>>>>>>>>>>>
>>>>>>>>>>>> You know that a decider only computes the mapping from its
>>>>>>>>>>>> input finite strings to its own final state thus you know
>>>>>>>>>>>> that you lie what you say that a decider must compute the
>>>>>>>>>>>> mapping from a non-finite sting non-input.
>>>>>>>>>>>>
>>>>>>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I don't, but you seem to like to.
>>>>>>>>>>>
>>>>>>>>>>> I never said that H needs to compute a mapping of anything
>>>>>>>>>>> but what has been given as an input.
>>>>>>>>>>>
>>>>>>>>>>> The only thing H needs to compute the mapping of is <H^>
>>>>>>>>>>> <H^>, which is EXACTLY the string on its input.
>>>>>>>>>>>
>>>>>>>>>>> The problem which you don't seem to understand is that the
>>>>>>>>>>> MAPPING it needs to try and compute (and which is not
>>>>>>>>>>> guaranteed to BE Computable), is the Behavior of the machine
>>>>>>>>>>> it represents, H^ applied to <H^>, as that is the mapping of
>>>>>>>>>>> the Halting Function.
>>>>>>>>>>
>>>>>>>>>> That is a non finite string non input, so you lied.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> <H^> <H^> is a finite string, which is what needs to be mapped,
>>>>>>>>> so you are just lying.
>>>>>>>>>
>>>>>>>>
>>>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>  > the MAPPING it needs to try and compute (and which is
>>>>>>>>  > not guaranteed to BE Computable), is the Behavior of
>>>>>>>>  > the machine it represents, H^ applied to <H^>,
>>>>>>>>
>>>>>>>> So you are just bald faced liar then.
>>>>>>>> It does not map H^ applied to <H^> to anything.
>>>>>>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> I never said it did.
>>>>>>>
>>>>>>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>>>>>>> FUNCTION) whether H^ applied to <H^> will Halt.
>>>>>>
>>>>>> It must map the input to an accept or reject state based on the
>>>>>> actual behavior actually specified by this input as measured by N
>>>>>> steps of the correct UTM simulation of this input.
>>>>>>
>>>>>>
>>>>>
>>>>> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn,
>>>>> based on the FUNCTION it is computing.
>>>>>
>>>>> There is NO requirement that it be based on its on simulation, or
>>>>> only N steps of a UTM.
>>>>>
>>>>
>>>> None-the-less if the behavior that is being measured is not exactly
>>>> the same behavior as the UTM simulation of the input then the
>>>> behavior being measured is measured incorrectly.
>>>>
>>>> A finite number of N steps is a mandatory constraint otherwise it
>>>> would be OK to report that infinite execution never halts after an
>>>> infinite number of steps.
>>>>
>>>
>>> You logic is backwards. You are just showing why it CAN'T be done,
>>> not why it must not be defined that way.
>>>
>>> The behavior that is measured MUST be exactly the behavior of the UTM
>>> simulation,
>>
>> In other words your requirement for a halt decider is that it
>> sometimes never halts.
>>
>
> Again, you are mixing REQUIREMENTS and CAPABILITIES.
>
> All deciders MUST Halt in finite time.

On 3/24/2022 9:58 AM, Richard Damon wrote:
>
> On 3/24/22 10:50 AM, olcott wrote:
>> On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
>>>
>>>>>>> As far as I can tell, when you write H and Ĥ we must assume that
>>>>>>> these
>>>>>>> refer to some kind of as yet unspecified machine that has "machine
>>>>>>> addresses" (so definitely not what Linz is taking about).  And that
>>>>>>> these H and Ĥ have the property that H applied to some string can
>>>>>>> transition to a different state to an exact copy of H if it's
>>>>>>> embedded
>>>>>>> in some other machine.  I suppose they don't actually have to be
>>>>>>> literally magic to do this, but they are certainly not Turing
>>>>>>> machines.
>>>>>>> Do you have anything to say about Linz's proof?
>>>>>>
>>>>>> All halt deciders must map their input to an accept or reject state
>>>>>> based on the actual behavior actually specified by this input as
>>>>>> measured by a finite number of N steps of the correct UTM simulation
>>>>>> of this input.
>>>>>
>>>>> No.  You'll find what a halt decider must do in any good text book.
>>>>> It appears that after 17 years of work in this you are:
>>>>>
>>>>> (a) trying to redefine what that halting problem is;
>>>>
>>>> Someone that understands these things deeper than learned by rote
>>>> would agree with me.
>>>
>>> No one agrees with the above.  It's not the halting problem.  What it
>>> is, ironically, is an admission that halting is undecidable!  If you
>>> really thought it weren't, there would be no need to keep writing the
>>> condition for accepting an input incorrectly.
>>>
>>
>> Certainly you can state this dogmatically, yet what you cannot do is
>> anchor this rebuttal in any sort of correct reasoning.
>>
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and
>> an input, whether the program will finish running, or continue to run
>> forever. https://en.wikipedia.org/wiki/Halting_problem
>>
>> A halt decider must map its finite string input pair to an accept or
>> reject state on the basis of the actual halting / non-halting behavior
>> specified by this finite string pair.
>>
>> It is the case that all deciders compute the mapping from their input
>> finite strings to their own accept or reject state.
>>
>> It is the case that all deciders compute the mapping from their input
>> finite strings to their own accept or reject state on the basis of the
>> behavior specified by these finite strings.
>>
>> It is the case that the behavior specified by these finite input
>> strings is correctly measured by the correct UTM simulation of these
>> strings by the simulating halt decider.
>
> The CORRECT UTM Simulation (not N steps)

This stupidly forbids simulating halt deciders from correctly rejecting
their input. As soon as an infinite behavior pattern is correctly
matched no more steps of simulation need be performed.

--
Copyright 2021 Pete Olcott

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

On 3/24/2022 10:30 AM, Richard Damon wrote:
> On 3/24/22 10:57 AM, olcott wrote:
>> On 3/24/2022 6:12 AM, Richard Damon wrote:
>>> On 3/23/22 11:05 PM, olcott wrote:
>>>> On 3/23/2022 9:31 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/23/22 10:01 PM, olcott wrote:
>>>>>> On 3/23/2022 8:39 PM, Richard Damon wrote:
>>>>>>> On 3/23/22 9:29 PM, olcott wrote:
>>>>>>>> On 3/23/2022 7:15 PM, Richard Damon wrote:
>>>>>>>>> On 3/23/22 7:50 PM, olcott wrote:
>>>>>>>>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>>>>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a
>>>>>>>>>>>>>>>>>>>>>> simulating halt decider (SHD).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>>>> would reach its final state.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>>>>>>>>>>>>>> would never reach its
>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that
>>>>>>>>>>>>>>>>>>>>> its input never halts.
>>>>>>>>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that
>>>>>>>>>>>>>>>>>>>>> its input halts"
>>>>>>>>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking
>>>>>>>>>>>>>>>>>>>>> about Turing
>>>>>>>>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior
>>>>>>>>>>>>>>>>>>>> the copy of H
>>>>>>>>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Everything Linz says, everything, is predicated on
>>>>>>>>>>>>>>>>>>> what a Turing machine
>>>>>>>>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic
>>>>>>>>>>>>>>>>>>> -- identical state
>>>>>>>>>>>>>>>>>>> transition functions can entail different
>>>>>>>>>>>>>>>>>>> configuration sequences for
>>>>>>>>>>>>>>>>>>> the same input.  Nothing you say has any relevance to
>>>>>>>>>>>>>>>>>>> Linz's Turing
>>>>>>>>>>>>>>>>>>> machines until you categorically repudiate this
>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That your only rebuttal to what I say now is dredging
>>>>>>>>>>>>>>>>>> up what I said
>>>>>>>>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You said this:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its
>>>>>>>>>>>>>>>>> input halts"
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they
>>>>>>>>>>>>>>>> must derive the same result. They are not identical
>>>>>>>>>>>>>>>> final strings.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> four days ago and you haven't retracted it.  Until you
>>>>>>>>>>>>>>>>> do, when you
>>>>>>>>>>>>>>>>> write Ĥ your readers must assume that you are referring
>>>>>>>>>>>>>>>>> to something
>>>>>>>>>>>>>>>>> about which this quote applies.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What's more, for your remarks to have any bearing on
>>>>>>>>>>>>>>>>> Linz's Ĥ you must
>>>>>>>>>>>>>>>>> not only repudiate what you said, you must accept the
>>>>>>>>>>>>>>>>> converse,
>>>>>>>>>>>>>>>>> i.e. that if
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, do you retract what you said and accept this fact
>>>>>>>>>>>>>>>>> about Linz's H and
>>>>>>>>>>>>>>>>> Ĥ?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You you continue to say that you believe that a decider
>>>>>>>>>>>>>>>> must report on its own behavior when you already know
>>>>>>>>>>>>>>>> damn well that a decider only computes the mapping from
>>>>>>>>>>>>>>>> its inputs to its own final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A Decider must report on its own behavior (or the
>>>>>>>>>>>>>>> behavior of a copy of it) if that is what the input asks
>>>>>>>>>>>>>>> for.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You know that a decider only computes the mapping from its
>>>>>>>>>>>>>> input finite strings to its own final state thus you know
>>>>>>>>>>>>>> that you lie what you say that a decider must compute the
>>>>>>>>>>>>>> mapping from a non-finite sting non-input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't, but you seem to like to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I never said that H needs to compute a mapping of anything
>>>>>>>>>>>>> but what has been given as an input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only thing H needs to compute the mapping of is <H^>
>>>>>>>>>>>>> <H^>, which is EXACTLY the string on its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The problem which you don't seem to understand is that the
>>>>>>>>>>>>> MAPPING it needs to try and compute (and which is not
>>>>>>>>>>>>> guaranteed to BE Computable), is the Behavior of the
>>>>>>>>>>>>> machine it represents, H^ applied to <H^>, as that is the
>>>>>>>>>>>>> mapping of the Halting Function.
>>>>>>>>>>>>
>>>>>>>>>>>> That is a non finite string non input, so you lied.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> <H^> <H^> is a finite string, which is what needs to be
>>>>>>>>>>> mapped, so you are just lying.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>  > the MAPPING it needs to try and compute (and which is
>>>>>>>>>>  > not guaranteed to BE Computable), is the Behavior of
>>>>>>>>>>  > the machine it represents, H^ applied to <H^>,
>>>>>>>>>>
>>>>>>>>>> So you are just bald faced liar then.
>>>>>>>>>> It does not map H^ applied to <H^> to anything.
>>>>>>>>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I never said it did.
>>>>>>>>>
>>>>>>>>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>>>>>>>>> FUNCTION) whether H^ applied to <H^> will Halt.
>>>>>>>>
>>>>>>>> It must map the input to an accept or reject state based on the
>>>>>>>> actual behavior actually specified by this input as measured by
>>>>>>>> N steps of the correct UTM simulation of this input.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn,
>>>>>>> based on the FUNCTION it is computing.
>>>>>>>
>>>>>>> There is NO requirement that it be based on its on simulation, or
>>>>>>> only N steps of a UTM.
>>>>>>>
>>>>>>
>>>>>> None-the-less if the behavior that is being measured is not
>>>>>> exactly the same behavior as the UTM simulation of the input then
>>>>>> the behavior being measured is measured incorrectly.
>>>>>>
>>>>>> A finite number of N steps is a mandatory constraint otherwise it
>>>>>> would be OK to report that infinite execution never halts after an
>>>>>> infinite number of steps.
>>>>>>
>>>>>
>>>>> You logic is backwards. You are just showing why it CAN'T be done,
>>>>> not why it must not be defined that way.
>>>>>
>>>>> The behavior that is measured MUST be exactly the behavior of the
>>>>> UTM simulation,
>>>>
>>>> In other words your requirement for a halt decider is that it
>>>> sometimes never halts.
>>>>
>>>
>>> Again, you are mixing REQUIREMENTS and CAPABILITIES.
>>>
>>> All deciders MUST Halt in finite time.
>>
>> And all deciders that simulate their infinitely repeating input are
>> not allowed to ever stop.
>>
>> If they recognize an infinitely repeating pattern in N steps of
>> simulation they are not allowed to report this otherwise the
>> simulation is not accurate.
>>
>>
>
> No, if they can CORRECTLY prove that their input will NEVER halt (even
> if they abort their simulation of them and go to Qn)

On 3/24/2022 10:35 AM, Richard Damon wrote:
> On 3/24/22 11:15 AM, olcott wrote:
>> On 3/24/2022 9:58 AM, Richard Damon wrote:
>>>
>>> On 3/24/22 10:50 AM, olcott wrote:
>>>> On 3/23/2022 11:21 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/23/2022 9:31 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
>>>>>
>>>>>>>>> As far as I can tell, when you write H and Ĥ we must assume
>>>>>>>>> that these
>>>>>>>>> refer to some kind of as yet unspecified machine that has "machine
>>>>>>>>> addresses" (so definitely not what Linz is taking about).  And
>>>>>>>>> that
>>>>>>>>> these H and Ĥ have the property that H applied to some string can
>>>>>>>>> transition to a different state to an exact copy of H if it's
>>>>>>>>> embedded
>>>>>>>>> in some other machine.  I suppose they don't actually have to be
>>>>>>>>> literally magic to do this, but they are certainly not Turing
>>>>>>>>> machines.
>>>>>>>>> Do you have anything to say about Linz's proof?
>>>>>>>>
>>>>>>>> All halt deciders must map their input to an accept or reject state
>>>>>>>> based on the actual behavior actually specified by this input as
>>>>>>>> measured by a finite number of N steps of the correct UTM
>>>>>>>> simulation
>>>>>>>> of this input.
>>>>>>>
>>>>>>> No.  You'll find what a halt decider must do in any good text book.
>>>>>>> It appears that after 17 years of work in this you are:
>>>>>>>
>>>>>>> (a) trying to redefine what that halting problem is;
>>>>>>
>>>>>> Someone that understands these things deeper than learned by rote
>>>>>> would agree with me.
>>>>>
>>>>> No one agrees with the above.  It's not the halting problem.  What it
>>>>> is, ironically, is an admission that halting is undecidable!  If you
>>>>> really thought it weren't, there would be no need to keep writing the
>>>>> condition for accepting an input incorrectly.
>>>>>
>>>>
>>>> Certainly you can state this dogmatically, yet what you cannot do is
>>>> anchor this rebuttal in any sort of correct reasoning.
>>>>
>>>> In computability theory, the halting problem is the problem of
>>>> determining, from a description of an arbitrary computer program and
>>>> an input, whether the program will finish running, or continue to
>>>> run forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> A halt decider must map its finite string input pair to an accept or
>>>> reject state on the basis of the actual halting / non-halting
>>>> behavior specified by this finite string pair.
>>>>
>>>> It is the case that all deciders compute the mapping from their
>>>> input finite strings to their own accept or reject state.
>>>>
>>>> It is the case that all deciders compute the mapping from their
>>>> input finite strings to their own accept or reject state on the
>>>> basis of the behavior specified by these finite strings.
>>>>
>>>> It is the case that the behavior specified by these finite input
>>>> strings is correctly measured by the correct UTM simulation of these
>>>> strings by the simulating halt decider.
>>>
>>> The CORRECT UTM Simulation (not N steps)
>>
>> This stupidly forbids simulating halt deciders from correctly
>> rejecting their input. As soon as an infinite behavior pattern is
>> correctly matched no more steps of simulation need be performed.
>>
>
> You need to CORRECTLY detect infininte behavior, EVEN IF the simulator
> aborts is simulation. For many machines, this isn't a problem (it only
> does become one if the machine contains a copy of the decider). That is
> your failing. Your 'proof' is based on false premises, that the decider
> will never abort.
>
> In fact, the bigger issue is that a real Turing Machine H can't actually
> detect that H^ is using a copy of itself, so it can't detect the
> recursion you are detecting. Your claims otherwise just show you don't
> understand how Turing Machines work.
>
> I would challenge you to try to design a Turing Machine (not just an
> 'equivalent, but an ACTUAL Turing Machine) that even trys to detect that
> its input is a representation of itself. (note, *A*, not *the* as
> machines have MANY (infinite) representations of themselves).

Linz says that when embedded_H transitions to Ĥ.qn this necessarily
forms a contradiction. https://www.liarparadox.org/Linz_Proof.pdf

As long as embedded_H transitions to its final reject state aborting its
input along with the whole chain of nested simulations then it is
correct and refutes Linz even if embedded_H does this on the basis of a
wild guess.

--
Copyright 2021 Pete Olcott

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