On 3/26/22 9:14 AM, olcott wrote:
On 3/26/2022 8:11 AM, Richard Damon wrote:
On 3/26/22 9:04 AM, olcott wrote:
On 3/26/2022 5:18 AM, Richard Damon wrote:
On 3/25/22 11:58 PM, olcott wrote:
On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
A SHD computes the mapping from its input to its own accept or >>>>>>>>>> rejectOr, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.
state based on whether or not the pure simulation of its
simulated
input could reach its own final state in a finite number of >>>>>>>>>> simulated
steps.
The following simplifies the syntax for the definition of the >>>>>>>>>> Linz
Turing machine Ĥ, it is now a single machine with a single start >>>>>>>>>> state. A copy of Linz H is embedded at Ĥ.qx
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
its final
state.
No it turns out to be the case that a halt decider is not
allowed to
report on its own behavior because itself is neither an input nor a >>>>>>>> finite string.
No. Happy to answer questions about why this is wrong, but since >>>>>>> you
have not grasped what a halt decider is after 17 years, I don't
think
it's worth my while just writing it out yet again.
You are agreed that a decider maps its input finite string input
to an accept or reject state.
Now you are contradicting yourself by saying that a decider maps a >>>>>> non-input non-finite string.
Nope, what it is mapping is the input <H^> <H^> which most
definitely IS a finite string input.
It is to map it to Qy (accept) or Qn (reject) based on if the
machine H^ applied to <H^> Halts.
The fact tha H^ applied to <H^> isn't exactly an input if fine,
I am looking for white dogs in my kitchen by looking for black cats
in my living room.
Yes, EXACTLY. YOU ARE. This is because you aren't using the right
definition of HALTING. (Halting is the white dog, your POOP is the
black cats).
Halting is DEFINED based on the behavoir of the TURING MACHINE that
the input represents, NOT a simulation of the input by the decider.
The only correct halt status criteria for a simulating halt decider is
whether or not the simulated input can possibly reach its own final
state. Every distraction away from this point is a dishonest dodge.
The only correct halt status criteria for a simulating halt decider is
whether or not the simulated input can possibly reach its own final
state. Every distraction away from this point is a dishonest dodge.
The only correct halt status criteria for a simulating halt decider is
whether or not the simulated input can possibly reach its own final
state. Every distraction away from this point is a dishonest dodge.
The only correct halt status criteria for a simulating halt decider is
whether or not the simulated input can possibly reach its own final
state. Every distraction away from this point is a dishonest dodge.
Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
MACHINE the input represents does.
Anything else, that isn't PROVABLY EXACTLY THE SAME, is WRONG.
This is the plain meaning of the words.
Your use of something different just PROVES that you whole arguement is
a LIE.
Your repeating it 4 times, just shows your maturing it that of a Toddler.
FAIL.
On 3/26/22 9:44 AM, olcott wrote:
On 3/26/2022 8:24 AM, Richard Damon wrote:
On 3/26/22 9:14 AM, olcott wrote:
On 3/26/2022 8:11 AM, Richard Damon wrote:
On 3/26/22 9:04 AM, olcott wrote:
On 3/26/2022 5:18 AM, Richard Damon wrote:
On 3/25/22 11:58 PM, olcott wrote:
On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
A SHD computes the mapping from its input to its own accept >>>>>>>>>>>> or rejectOr, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>> halts.
state based on whether or not the pure simulation of its >>>>>>>>>>>> simulated
input could reach its own final state in a finite number of >>>>>>>>>>>> simulated
steps.
The following simplifies the syntax for the definition of >>>>>>>>>>>> the Linz
Turing machine Ĥ, it is now a single machine with a single >>>>>>>>>>>> start
state. A copy of Linz H is embedded at Ĥ.qx
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
its final
state.
No it turns out to be the case that a halt decider is not
allowed to
report on its own behavior because itself is neither an input >>>>>>>>>> nor a
finite string.
No. Happy to answer questions about why this is wrong, but >>>>>>>>> since you
have not grasped what a halt decider is after 17 years, I don't >>>>>>>>> think
it's worth my while just writing it out yet again.
You are agreed that a decider maps its input finite string input >>>>>>>> to an accept or reject state.
Now you are contradicting yourself by saying that a decider maps >>>>>>>> a non-input non-finite string.
Nope, what it is mapping is the input <H^> <H^> which most
definitely IS a finite string input.
It is to map it to Qy (accept) or Qn (reject) based on if the
machine H^ applied to <H^> Halts.
The fact tha H^ applied to <H^> isn't exactly an input if fine,
I am looking for white dogs in my kitchen by looking for black
cats in my living room.
Yes, EXACTLY. YOU ARE. This is because you aren't using the right
definition of HALTING. (Halting is the white dog, your POOP is the
black cats).
Halting is DEFINED based on the behavoir of the TURING MACHINE that
the input represents, NOT a simulation of the input by the decider.
The only correct halt status criteria for a simulating halt decider
is whether or not the simulated input can possibly reach its own
final state. Every distraction away from this point is a dishonest
dodge.
The only correct halt status criteria for a simulating halt decider
is whether or not the simulated input can possibly reach its own
final state. Every distraction away from this point is a dishonest
dodge.
The only correct halt status criteria for a simulating halt decider
is whether or not the simulated input can possibly reach its own
final state. Every distraction away from this point is a dishonest
dodge.
The only correct halt status criteria for a simulating halt decider
is whether or not the simulated input can possibly reach its own
final state. Every distraction away from this point is a dishonest
dodge.
Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
MACHINE the input represents does.
The actual behavior of the actual simulated input it what counts.
NOPE. READ THE DEFINITION!
It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
On 3/26/22 10:13 AM, olcott wrote:
On 3/26/2022 8:55 AM, Richard Damon wrote:
On 3/26/22 9:44 AM, olcott wrote:
On 3/26/2022 8:24 AM, Richard Damon wrote:
On 3/26/22 9:14 AM, olcott wrote:
On 3/26/2022 8:11 AM, Richard Damon wrote:
On 3/26/22 9:04 AM, olcott wrote:
On 3/26/2022 5:18 AM, Richard Damon wrote:
On 3/25/22 11:58 PM, olcott wrote:I am looking for white dogs in my kitchen by looking for black >>>>>>>> cats in my living room.
On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
A SHD computes the mapping from its input to its own >>>>>>>>>>>>>> accept or rejectOr, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>> halts.
state based on whether or not the pure simulation of its >>>>>>>>>>>>>> simulated
input could reach its own final state in a finite number >>>>>>>>>>>>>> of simulated
steps.
The following simplifies the syntax for the definition of >>>>>>>>>>>>>> the Linz
Turing machine Ĥ, it is now a single machine with a single >>>>>>>>>>>>>> start
state. A copy of Linz H is embedded at Ĥ.qx
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would >>>>>>>>>>>>>> reach its final
state.
No it turns out to be the case that a halt decider is not >>>>>>>>>>>> allowed to
report on its own behavior because itself is neither an >>>>>>>>>>>> input nor a
finite string.
No. Happy to answer questions about why this is wrong, but >>>>>>>>>>> since you
have not grasped what a halt decider is after 17 years, I >>>>>>>>>>> don't think
it's worth my while just writing it out yet again.
You are agreed that a decider maps its input finite string >>>>>>>>>> input to an accept or reject state.
Now you are contradicting yourself by saying that a decider >>>>>>>>>> maps a non-input non-finite string.
Nope, what it is mapping is the input <H^> <H^> which most
definitely IS a finite string input.
It is to map it to Qy (accept) or Qn (reject) based on if the >>>>>>>>> machine H^ applied to <H^> Halts.
The fact tha H^ applied to <H^> isn't exactly an input if fine, >>>>>>>>
Yes, EXACTLY. YOU ARE. This is because you aren't using the right >>>>>>> definition of HALTING. (Halting is the white dog, your POOP is
the black cats).
Halting is DEFINED based on the behavoir of the TURING MACHINE
that the input represents, NOT a simulation of the input by the
decider.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach
its own final state. Every distraction away from this point is a
dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach
its own final state. Every distraction away from this point is a
dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach
its own final state. Every distraction away from this point is a
dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach
its own final state. Every distraction away from this point is a
dishonest dodge.
Nope. THE DEFINITION of the right answer is what the ACTUAL TURING
MACHINE the input represents does.
The actual behavior of the actual simulated input it what counts.
NOPE. READ THE DEFINITION!
It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
This only means that it is not the behavior of a finite string because
finite strings have no behavior.
Right Finite strings have no behavior.
The behavior the decider needs to decide on is the Turing Machine the
input is a representation of.
The behavior referred to must be the same as the behavior of the
simulated Turing machine description otherwise you are denying the
computational equivalence of the direct execution of a Turing machine
and the UTM simulation of the machine description of this same machine.
Right, the behavior of the ACTUAL Turing Machine, which can also be
obtained by the simulation with a UTM
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
NOT 'by embedded_H' but by a UTM. Wrong Definition.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
NOT 'by embedded_H' but by a UTM. Wrong Definition.
If embedded_H CAN meet the requirements of a UTM, then it can use
itself, but if not, it can't. Note, one key point is for the second case
(Qn) UTM not halting meens an unaborted simulation does not halt.
If you can see that the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its final >> state and the executed Ĥ ⟨Ĥ⟩ does reach its final state then there
must be something about the different placement of Ĥ ⟨Ĥ⟩ at the
beginning of Ĥ and Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ in the middle of Ĥ that causes a
difference in behavior.
IF embedded_H never aborts, then YES, it has shown that the input is non-halting, but it fails to give the answer.
IF embedded_H does abort, then its simulation is no long that of a UTM,
so we need to look at what the UTM simulation will do.
We have shown that if H <H^> <H^> -> Qn then H^ <H^> -> H^.Qn and Halts,
and thus UTM <H^> <H^> will also go to H^.Qn and Halt.
THAT is the proper test.
What we cannot do is see that the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its
final state and simply ignore this fact because it is not what we
expect to happen.
And UTM <H^> <H^> only never halts if embedded_H never aborts.
since a embdded_H that never aborts is a DIFFERENT MACHINE than an
embedded_H that does abort, these represent DIFFERENT H^ machines, so different inputs.
You can't use the logic for Hn that doesn't abort and gives us a Hn^
that doesn't halt to answer about the correct answer for Ha that does
abort and its input <Ha^> <Ha^> which as we have shown represents a
HALTING computtion.
FAIL.
On 3/26/22 11:25 AM, olcott wrote:
On 3/26/2022 9:56 AM, Richard Damon wrote:
On 3/26/22 10:13 AM, olcott wrote:
On 3/26/2022 8:55 AM, Richard Damon wrote:
On 3/26/22 9:44 AM, olcott wrote:
On 3/26/2022 8:24 AM, Richard Damon wrote:
On 3/26/22 9:14 AM, olcott wrote:
On 3/26/2022 8:11 AM, Richard Damon wrote:
On 3/26/22 9:04 AM, olcott wrote:
On 3/26/2022 5:18 AM, Richard Damon wrote:
On 3/25/22 11:58 PM, olcott wrote:I am looking for white dogs in my kitchen by looking for black >>>>>>>>>> cats in my living room.
On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
A SHD computes the mapping from its input to its own >>>>>>>>>>>>>>>> accept or rejectOr, more simply, use Linz's condition: if Ĥ applied to >>>>>>>>>>>>>>> ⟨Ĥ⟩ halts.
state based on whether or not the pure simulation of its >>>>>>>>>>>>>>>> simulated
input could reach its own final state in a finite number >>>>>>>>>>>>>>>> of simulated
steps.
The following simplifies the syntax for the definition >>>>>>>>>>>>>>>> of the Linz
Turing machine Ĥ, it is now a single machine with a >>>>>>>>>>>>>>>> single start
state. A copy of Linz H is embedded at Ĥ.qx >>>>>>>>>>>>>>>>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
reach its final
state.
No it turns out to be the case that a halt decider is not >>>>>>>>>>>>>> allowed to
report on its own behavior because itself is neither an >>>>>>>>>>>>>> input nor a
finite string.
No. Happy to answer questions about why this is wrong, but >>>>>>>>>>>>> since you
have not grasped what a halt decider is after 17 years, I >>>>>>>>>>>>> don't think
it's worth my while just writing it out yet again.
You are agreed that a decider maps its input finite string >>>>>>>>>>>> input to an accept or reject state.
Now you are contradicting yourself by saying that a decider >>>>>>>>>>>> maps a non-input non-finite string.
Nope, what it is mapping is the input <H^> <H^> which most >>>>>>>>>>> definitely IS a finite string input.
It is to map it to Qy (accept) or Qn (reject) based on if the >>>>>>>>>>> machine H^ applied to <H^> Halts.
The fact tha H^ applied to <H^> isn't exactly an input if fine, >>>>>>>>>>
Yes, EXACTLY. YOU ARE. This is because you aren't using the
right definition of HALTING. (Halting is the white dog, your >>>>>>>>> POOP is the black cats).
Halting is DEFINED based on the behavoir of the TURING MACHINE >>>>>>>>> that the input represents, NOT a simulation of the input by the >>>>>>>>> decider.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach >>>>>>>> its own final state. Every distraction away from this point is a >>>>>>>> dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach >>>>>>>> its own final state. Every distraction away from this point is a >>>>>>>> dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach >>>>>>>> its own final state. Every distraction away from this point is a >>>>>>>> dishonest dodge.
The only correct halt status criteria for a simulating halt
decider is whether or not the simulated input can possibly reach >>>>>>>> its own final state. Every distraction away from this point is a >>>>>>>> dishonest dodge.
Nope. THE DEFINITION of the right answer is what the ACTUAL
TURING MACHINE the input represents does.
The actual behavior of the actual simulated input it what counts.
NOPE. READ THE DEFINITION!
It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT.
This only means that it is not the behavior of a finite string
because finite strings have no behavior.
Right Finite strings have no behavior.
The behavior the decider needs to decide on is the Turing Machine the
input is a representation of.
The behavior of the UTM simulation of the input is the behavior that
this input specifies. That the input simulated by a UTM would never
reach its final state conclusively proves that this input specifies a
non-halting sequence of configurations.
except that if H <H^> <H^> -> Qn, then H^ <H^> and UTM <H^> <H^> will
also gp tp H^.Qn and halt, so your claim is a LIE.
Eitehr you LIE that your deicder said its input was non-halting, or you
LIE that simulation does not reach a final state.
You can't use two different version of H/embedded_H here.
The behavior referred to must be the same as the behavior of the
simulated Turing machine description otherwise you are denying the
computational equivalence of the direct execution of a Turing
machine and the UTM simulation of the machine description of this
same machine.
Right, the behavior of the ACTUAL Turing Machine, which can also be
obtained by the simulation with a UTM
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its >>>> final state.
NOT 'by embedded_H' but by a UTM. Wrong Definition.
By the UTM aspect of embedded_H because the simulation must occur at
the same point (in the middle) of Ĥ where embedded_H is located.
Nope!!!
It is the INDEPENDENT running of UTM <H^> <H^>.
On 3/26/22 12:12 PM, olcott wrote:
On 3/26/2022 10:50 AM, Richard Damon wrote:
On 3/26/22 11:25 AM, olcott wrote:
On 3/26/2022 9:56 AM, Richard Damon wrote:
On 3/26/22 10:13 AM, olcott wrote:
On 3/26/2022 8:55 AM, Richard Damon wrote:
On 3/26/22 9:44 AM, olcott wrote:This only means that it is not the behavior of a finite string
On 3/26/2022 8:24 AM, Richard Damon wrote:NOPE. READ THE DEFINITION!
On 3/26/22 9:14 AM, olcott wrote:
On 3/26/2022 8:11 AM, Richard Damon wrote:
On 3/26/22 9:04 AM, olcott wrote:
On 3/26/2022 5:18 AM, Richard Damon wrote:
On 3/25/22 11:58 PM, olcott wrote:
On 3/25/2022 10:48 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/25/2022 3:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
A SHD computes the mapping from its input to its own >>>>>>>>>>>>>>>>>> accept or rejectOr, more simply, use Linz's condition: if Ĥ applied to >>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts.
state based on whether or not the pure simulation of >>>>>>>>>>>>>>>>>> its simulated
input could reach its own final state in a finite >>>>>>>>>>>>>>>>>> number of simulated
steps.
The following simplifies the syntax for the definition >>>>>>>>>>>>>>>>>> of the Linz
Turing machine Ĥ, it is now a single machine with a >>>>>>>>>>>>>>>>>> single start
state. A copy of Linz H is embedded at Ĥ.qx >>>>>>>>>>>>>>>>>>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
reach its final
state.
No it turns out to be the case that a halt decider is >>>>>>>>>>>>>>>> not allowed to
report on its own behavior because itself is neither an >>>>>>>>>>>>>>>> input nor a
finite string.
No. Happy to answer questions about why this is wrong, >>>>>>>>>>>>>>> but since you
have not grasped what a halt decider is after 17 years, I >>>>>>>>>>>>>>> don't think
it's worth my while just writing it out yet again. >>>>>>>>>>>>>>>
You are agreed that a decider maps its input finite string >>>>>>>>>>>>>> input to an accept or reject state.
Now you are contradicting yourself by saying that a >>>>>>>>>>>>>> decider maps a non-input non-finite string.
Nope, what it is mapping is the input <H^> <H^> which most >>>>>>>>>>>>> definitely IS a finite string input.
It is to map it to Qy (accept) or Qn (reject) based on if >>>>>>>>>>>>> the machine H^ applied to <H^> Halts.
The fact tha H^ applied to <H^> isn't exactly an input if >>>>>>>>>>>>> fine,
I am looking for white dogs in my kitchen by looking for >>>>>>>>>>>> black cats in my living room.
Yes, EXACTLY. YOU ARE. This is because you aren't using the >>>>>>>>>>> right definition of HALTING. (Halting is the white dog, your >>>>>>>>>>> POOP is the black cats).
Halting is DEFINED based on the behavoir of the TURING
MACHINE that the input represents, NOT a simulation of the >>>>>>>>>>> input by the decider.
The only correct halt status criteria for a simulating halt >>>>>>>>>> decider is whether or not the simulated input can possibly >>>>>>>>>> reach its own final state. Every distraction away from this >>>>>>>>>> point is a dishonest dodge.
The only correct halt status criteria for a simulating halt >>>>>>>>>> decider is whether or not the simulated input can possibly >>>>>>>>>> reach its own final state. Every distraction away from this >>>>>>>>>> point is a dishonest dodge.
The only correct halt status criteria for a simulating halt >>>>>>>>>> decider is whether or not the simulated input can possibly >>>>>>>>>> reach its own final state. Every distraction away from this >>>>>>>>>> point is a dishonest dodge.
The only correct halt status criteria for a simulating halt >>>>>>>>>> decider is whether or not the simulated input can possibly >>>>>>>>>> reach its own final state. Every distraction away from this >>>>>>>>>> point is a dishonest dodge.
Nope. THE DEFINITION of the right answer is what the ACTUAL
TURING MACHINE the input represents does.
The actual behavior of the actual simulated input it what counts. >>>>>>>
It is the behavior of the ACTUAL TURING MACHINE THE INPUT REPRESENT. >>>>>>
because finite strings have no behavior.
Right Finite strings have no behavior.
The behavior the decider needs to decide on is the Turing Machine
the input is a representation of.
The behavior of the UTM simulation of the input is the behavior that
this input specifies. That the input simulated by a UTM would never
reach its final state conclusively proves that this input specifies
a non-halting sequence of configurations.
except that if H <H^> <H^> -> Qn, then H^ <H^> and UTM <H^> <H^> will
also gp tp H^.Qn and halt, so your claim is a LIE.
Eitehr you LIE that your deicder said its input was non-halting, or
you LIE that simulation does not reach a final state.
You can't use two different version of H/embedded_H here.
The behavior referred to must be the same as the behavior of the
simulated Turing machine description otherwise you are denying the >>>>>> computational equivalence of the direct execution of a Turing
machine and the UTM simulation of the machine description of this
same machine.
Right, the behavior of the ACTUAL Turing Machine, which can also be
obtained by the simulation with a UTM
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
final state.
NOT 'by embedded_H' but by a UTM. Wrong Definition.
By the UTM aspect of embedded_H because the simulation must occur at
the same point (in the middle) of Ĥ where embedded_H is located.
Nope!!!
It is the INDEPENDENT running of UTM <H^> <H^>.
THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
THAT IS FALSE THERE IS A KEY DEPENDENCY !!!
The invocation of Ĥ ⟨Ĥ⟩ is the first invocation in what would
otherwise be infinite recursion.
Its normal behavior depends on a subsequent invocation being aborted.
If a subsequent invocation is never aborted then the recursion remains
infinite.
In any case the simulated input never reaches the final state of this
simulated input. The final state of the simulated input is ⟨Ĥ.qn⟩.
Nope, ALL Copies of the same machine given the same input behave the same.
If you want to refute that, provide and ACTUAL coded example.
H^ applied to <H^> -> H^.Qn and Halts and UTM <H^> <H^> goes to <H^>.Qn
and Halts if H/embedded_H -> Qn, and if H doesn't, it fails to be a
decider, so is wrong either way.
On 3/26/22 9:05 PM, olcott wrote:
On 3/26/2022 7:39 PM, Richard Damon wrote:
On 3/26/22 7:58 PM, olcott wrote:If embedded_H uses its UTM to simulate one state transition at a time
On 3/26/2022 6:54 PM, Richard Damon wrote:
On 3/26/22 7:40 PM, olcott wrote:
On 3/26/2022 6:32 PM, Richard Damon wrote:
On 3/26/22 7:09 PM, olcott wrote:
On 3/26/2022 5:49 PM, Richard Damon wrote:
On 3/26/22 6:36 PM, olcott wrote:Has never been what I am talking about and you know it.
On 3/26/2022 5:27 PM, Richard Damon wrote:
On 3/26/22 6:14 PM, olcott wrote:
On 3/26/2022 5:07 PM, Richard Damon wrote:
On 3/26/22 5:35 PM, olcott wrote:
On 3/26/2022 4:25 PM, Richard Damon wrote:
On 3/26/22 5:21 PM, olcott wrote:
On 3/26/2022 4:16 PM, Richard Damon wrote:
On 3/26/22 5:05 PM, olcott wrote:
On 3/26/2022 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 3/26/22 4:42 PM, olcott wrote:
On 3/26/2022 3:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 3/26/22 4:09 PM, olcott wrote:
As you were the first to point out the simulated >>>>>>>>>>>>>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H does not halt. To useOn 3/26/2022 2:58 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 12:48 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 11:35 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>
On 3/26/22 12:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 10:50 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 11:25 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 9:56 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On 3/26/22 10:13 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:55 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/22 9:44 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:24 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Right Finite strings have no behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>This only means that it is not the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of a finite string because finite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strings have no behavior. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>NOPE. READ THE DEFINITION! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 3/26/22 9:14 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 8:11 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 3/26/22 9:04 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/26/2022 5:18 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/22 11:58 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 10:48 PM, Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2022 3:29 PM, Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A SHD computes the mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its input to its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state based on whether or not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input could reach its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state in a finite number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following simplifies the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> syntax for the definition of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Linz >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine Ĥ, it is now a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single machine with a single >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. A copy of Linz H is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*The only correct halt status criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I am looking for white dogs in my >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kitchen by looking for black cats in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my living room. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>No. Happy to answer questions >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about why this is wrong, but >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have not grasped what a halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider is after 17 years, I >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't think >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it's worth my while just writing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it out yet again. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Ĥ.qy ∞ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ by embedded_H would reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or, more simply, use Linz's >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> condition: if Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it turns out to be the case >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a halt decider is not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report on its own behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because itself is neither an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input nor a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite string. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You are agreed that a decider maps >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input finite string input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Now you are contradicting yourself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by saying that a decider maps a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-input non-finite string. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, what it is mapping is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input <H^> <H^> which most >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitely IS a finite string input. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is to map it to Qy (accept) or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Qn (reject) based on if the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to <H^> Halts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact tha H^ applied to <H^> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't exactly an input if fine, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Yes, EXACTLY. YOU ARE. This is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because you aren't using the right >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of HALTING. (Halting is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the white dog, your POOP is the black >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cats).
Halting is DEFINED based on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavoir of the TURING MACHINE that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input represents, NOT a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input by the decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The only correct halt status criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The only correct halt status criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The only correct halt status criteria >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a simulating halt decider is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the simulated input can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every distraction away from this point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a dishonest dodge. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Nope. THE DEFINITION of the right >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is what the ACTUAL TURING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE the input represents does. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The actual behavior of the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input it what counts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
It is the behavior of the ACTUAL TURING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MACHINE THE INPUT REPRESENT. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The behavior the decider needs to decide on >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the Turing Machine the input is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of.
The behavior of the UTM simulation of the >>>>>>>>>>>>>>>>>>>>>>>>>>>> input is the behavior that this input >>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies. That the input simulated by a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its final state >>>>>>>>>>>>>>>>>>>>>>>>>>>> conclusively proves that this input >>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of >>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations.
except that if H <H^> <H^> -> Qn, then H^ >>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> and UTM <H^> <H^> will also gp tp H^.Qn >>>>>>>>>>>>>>>>>>>>>>>>>>> and halt, so your claim is a LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Eitehr you LIE that your deicder said its >>>>>>>>>>>>>>>>>>>>>>>>>>> input was non-halting, or you LIE that >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>
You can't use two different version of >>>>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H here.
Nope!!!
Right, the behavior of the ACTUAL Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine, which can also be obtained by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation with a UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The behavior referred to must be the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as the behavior of the simulated Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description otherwise you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> denying the computational equivalence of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of a Turing machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the UTM simulation of the machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description of this same machine. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
NOT 'by embedded_H' but by a UTM. Wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Definition.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
By the UTM aspect of embedded_H because the >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation must occur at the same point (in >>>>>>>>>>>>>>>>>>>>>>>>>>>> the middle) of Ĥ where embedded_H is located. >>>>>>>>>>>>>>>>>>>>>>>>>>>
It is the INDEPENDENT running of UTM <H^> <H^>. >>>>>>>>>>>>>>>>>>>>>>>>>>>
THAT IS FALSE THERE IS A KEY DEPENDENCY !!! >>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!! >>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS FALSE THERE IS A KEY DEPENDENCY !!! >>>>>>>>>>>>>>>>>>>>>>>>>>
The invocation of Ĥ ⟨Ĥ⟩ is the first >>>>>>>>>>>>>>>>>>>>>>>>>> invocation in what would otherwise be infinite >>>>>>>>>>>>>>>>>>>>>>>>>> recursion.
Its normal behavior depends on a subsequent >>>>>>>>>>>>>>>>>>>>>>>>>> invocation being aborted.
If a subsequent invocation is never aborted >>>>>>>>>>>>>>>>>>>>>>>>>> then the recursion remains infinite. >>>>>>>>>>>>>>>>>>>>>>>>>>
In any case the simulated input never reaches >>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this simulated input. The >>>>>>>>>>>>>>>>>>>>>>>>>> final state of the simulated input is ⟨Ĥ.qn⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>
Nope, ALL Copies of the same machine given the >>>>>>>>>>>>>>>>>>>>>>>>> same input behave the same.
There is never any case where the simulated >>>>>>>>>>>>>>>>>>>>>>>> input reaches its own final state ⟨Ĥ.qn⟩. >>>>>>>>>>>>>>>>>>>>>>>>
If you want to refute that, provide and ACTUAL >>>>>>>>>>>>>>>>>>>>>>>>> coded example.Ĥ ⟨Ĥ⟩ and embedded_H both reach their final >>>>>>>>>>>>>>>>>>>>>>>> state of Ĥ.qn and halt.
H^ applied to <H^> -> H^.Qn and Halts and UTM >>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> goes to <H^>.Qn and Halts if >>>>>>>>>>>>>>>>>>>>>>>>> H/embedded_H -> Qn, and if H doesn't, it fails >>>>>>>>>>>>>>>>>>>>>>>>> to be a decider, so is wrong either way. >>>>>>>>>>>>>>>>>>>>>>>>
The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
reaches its own final state ⟨Ĥ.qn⟩. >>>>>>>>>>>>>>>>>>>>>>>>
Nope. The PROPERLY simulated <H^> <H^> will also >>>>>>>>>>>>>>>>>>>>>>> go to H^.Qn and Halt.
I say I have no white dogs in my living room and >>>>>>>>>>>>>>>>>>>>>> disagree on the basis that I have a black cat in >>>>>>>>>>>>>>>>>>>>>> my kitchen.
The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never
reaches its own final state of ⟨Ĥ.qn⟩ even though >>>>>>>>>>>>>>>>>>>>>> the directly executed Ĥ applied to ⟨Ĥ⟩ does >>>>>>>>>>>>>>>>>>>>>> transition to its final state of Ĥ.qn. >>>>>>>>>>>>>>>>>>>>>>
The directly executed Ĥ applied to ⟨Ĥ⟩ is the >>>>>>>>>>>>>>>>>>>>>> first invocation of infinite recursion that only >>>>>>>>>>>>>>>>>>>>>> terminates normally because of its one-way >>>>>>>>>>>>>>>>>>>>>> dependency relationship on embedded_H aborting the >>>>>>>>>>>>>>>>>>>>>> second invocation of this otherwise infinite >>>>>>>>>>>>>>>>>>>>>> recursion.
And since it DOES Halt, the computation HA\LT. >>>>>>>>>>>>>>>>>>>>> DEFINITION.
your own terms its execution has been suspended. >>>>>>>>>>>>>>>>>>>>
YOU KNOW THIS IS TRUE YOU ARE JUST A LIAR >>>>>>>>>>>>>>>>>>>> The simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H never >>>>>>>>>>>>>>>>>>>> reaches its own final
state of ⟨Ĥ.qn⟩ even though the directly executed Ĥ >>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
does transition to its final state of Ĥ.qn. >>>>>>>>>>>>>>>>>>>>
The PARTIAL simulation of the input by embedded_H >>>>>>>>>>>>>>>>>>> never reaches its final state, yes.
Since you already agreed that the complete simulation >>>>>>>>>>>>>>>>>> of its input never stops running you already know that >>>>>>>>>>>>>>>>>> the simulation of its input never reaches its final >>>>>>>>>>>>>>>>>> state ⟨Ĥ.qn⟩ no matter what.
Then that means your embedded_H NEVER aborts its >>>>>>>>>>>>>>>>> simulation, and thus NEVER returns an annswer and thus >>>>>>>>>>>>>>>>> FAILS to be a decider.
It also means that because the input never halts under >>>>>>>>>>>>>>>> any circumstances that when embedded_H rejects this >>>>>>>>>>>>>>>> input it is necessarily correct.
No, that isn't what I agreed to.
Sure it was.
It doesn't reach its final state if it is not aborted (it >>>>>>>>>>>>>> keeps running) and it doesn't reach its final state if was >>>>>>>>>>>>>> aborted.
Bad use of pronouns.
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by the UTM inside of embedded_H never >>>>>>>>>>>> reaches its final state: ⟨Ĥ.qn⟩ no matter what.
There IS NO UTM that is still a UTM inside embedded_H, or >>>>>>>>>>> embedded_H doesn't ever answer.
You know that the simulated input to embedded_H never reaches >>>>>>>>>> its final state of ⟨Ĥ.qn⟩ no matter what. Why don't you just >>>>>>>>>> admit this so that I can escalate this to computer science >>>>>>>>>> review?
Because you are saying it wrong, because you are confusing two >>>>>>>>> different 'simulations'
The CORRECTLY Simulated input, done by the independent UTM,
So you admit that you are only talking about the INCORRECTLY
Simulated Output?
No nitwit I admit no such thing.
Then why did you say it?
I talked about the 'CORRECT Simulation' and you say that you aren't
talking about that.
What is the defintion of a simulation that isn't the correct
simulation?
You don't seem to understand the meaning of English words.
The input simulated by the UTM contained within embedded_H cannot
possibly reach its own final state of ⟨Ĥ.qn⟩ if simulated in an >>>>>> infinite or finite number of steps or if the simulation is aborted >>>>>> at any point along the way.
As I have said, there IS NO UTM contained within embedded_H that is
still a UTM if embedded_H EVER aborts its simulation.PERIOD.
A music app can contain a complete C compiler that remains a
complete C compiler even if it is never uses.
RED HERRING. Category error. (Since you claim embedded_H USES the
UTM, your case in non-applicable).
of its input then each of these state transitions are simulated
correctly.
The step maybe, the MACHINE, NO.
Definition of Correct Simulation, behaves IDENTICAL to the original
machine.
Means can not 'abort' the simulation.
FAIL.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 15:46:03 |
Calls: | 7,812 |
Files: | 12,927 |
Messages: | 5,766,124 |