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.

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.

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?)

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.

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.

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.

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:

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.

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.

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,

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.

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é

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.

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"

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
Ĥ?

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.

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.

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"

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/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.

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.

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?

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/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,

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.

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/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)

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/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).