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:You know that a decider only computes the mapping from its input
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:That your only rebuttal to what I say now is dredging up what >>>>>>>>>> I said
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).But for your "PO-machines":
Ĥ.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.
"Ĥ.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. >>>>>>>>>>
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.
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:That is a non finite string non input, so you lied.
On 3/23/2022 6:19 AM, Richard Damon wrote:
On 3/23/22 12:00 AM, olcott wrote: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
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:That your only rebuttal to what I say now is dredging up >>>>>>>>>>>> what I said
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).But for your "PO-machines":
Ĥ.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.
"Ĥ.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. >>>>>>>>>>>>
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.
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. >>>>>>
<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/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: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.
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:You said this:
olcott <NoOne@NoWhere.com> writes:That your only rebuttal to what I say now is dredging up >>>>>>>>>>>>>> what I said
On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:Everything Linz says, everything, is predicated on what a >>>>>>>>>>>>>>> Turing machine
olcott <NoOne@NoWhere.com> writes:
A copy of Linz H is embedded at Ĥ.qx as a simulating >>>>>>>>>>>>>>>>>> halt decider (SHD).But for your "PO-machines":
Ĥ.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.
"Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>
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. >>>>>>>>>>>>>>
many months ago proves that you are being dishonest. >>>>>>>>>>>>>
"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.
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/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: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.
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:You said this:
olcott <NoOne@NoWhere.com> writes:That your only rebuttal to what I say now is dredging up >>>>>>>>>>>>>>>> what I said
On 3/21/2022 10:22 PM, Ben Bacarisse wro0te: >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:Everything Linz says, everything, is predicated on what >>>>>>>>>>>>>>>>> a Turing machine
A copy of Linz H is embedded at Ĥ.qx as a simulating >>>>>>>>>>>>>>>>>>>> halt decider (SHD).But for your "PO-machines":
Ĥ.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.
"Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>
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. >>>>>>>>>>>>>>>>
many months ago proves that you are being dishonest. >>>>>>>>>>>>>>>
"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. >>>>>>>>>>>>>
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: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: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.
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:You said this:
On 3/21/2022 10:22 PM, Ben Bacarisse wro0te: >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:Everything Linz says, everything, is predicated on >>>>>>>>>>>>>>>>>>> what a Turing machine
A copy of Linz H is embedded at Ĥ.qx as a >>>>>>>>>>>>>>>>>>>>>> simulating halt decider (SHD).But for your "PO-machines":
Ĥ.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.
"Ĥ.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 ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>
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. >>>>>>>>>>>>>>>>>
"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.
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)
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 427 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 33:36:10 |
| Calls: | 9,027 |
| Calls today: | 10 |
| Files: | 13,384 |
| Messages: | 6,008,640 |