On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."
When you don't cut off what I said in the middle of the sentence then
it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to ⟨Ĥ⟩ or you can
provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a simulator. You cannot simulate ⟨Ĥ⟩
applied to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
On 2022-02-01 18:33, olcott wrote:
On 2/1/2022 6:58 PM, André G. Isaak wrote:
On 2022-01-30 19:05, olcott wrote:
On 1/30/2022 7:45 PM, Richard Damon wrote:
On 1/30/22 7:21 PM, olcott wrote:
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
iff H goes to that corresponding state.
⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
same way that (5,3) is syntactically specified as an input to Sum(5,3) >>>>
Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in >>>> the same way that (1,2) is NOT syntactically specified as an input
to Sum(5,3)
I promised myself I wouldn't involve myself in your nonsense any
further, but here you've made such a terribly inaccurate analogy that
I thought I had to comment.
The inputs to a function such as SUM(X, Y) are two REPRESENTATIONS of
integers. If SUM were a Turing Machine, these would be two strings in
the alphabet of the TM. if this were a C function, X and X would be
strings of bits which form the twos complement representation of some
integer. In neither case would the inputs be actual, mathematical
integers. C might use the term 'integer' as one of its built in
types, but C integers are NOT elements of ℤ. They are REPRESENTATIONS
of the supported subset of ℤ.
So ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H in the same sense that ⟨5⟩ ⟨3⟩
are the inputs to SUM.
Ĥ ⟨Ĥ⟩ is not the input to embedded_H in the same sense that the
actual mathematical integers 3 and 5 are not inputs to SUM.
We are on the same page so far. (acknowledging when there is agreement
is an essential part of an honest dialogue).
If your going to make analogies, at least make ones that are accurate.
SUM takes REPRESENTATIONS of integers as its inputs, but it answers
about the ACTUAL integers described by those representations. To talk
about the sum of two representations is meaningless. Only actual
integers have sums.
In exactly the same way, embedded_H takes a REPRESENTATION of some TM
⟨Ĥ⟩ as part of its input but it answers about the ACTUAL TM described >>> by that input, Ĥ.
To talk about whether a representation of a TM halts is meaningless
since only actual TMs, not representations of TMs, can halt. The
conditions which Richard indicates above (following Linz) are
therefore the correct ones.
In a previous post which I can't be botherered to find, you claimed
that when the input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ that embedded_H can only
be expected to answer about its actual inputs and not its 'enclosing
TM'.
Yes, it must answer about its input, but if its input is ⟨Ĥ⟩ ⟨Ĥ⟩, >>> then BY THE DEFINITION OF A HALT DECIDER is must determine whether Ĥ
applied to ⟨Ĥ⟩ halts.
No you are flat out wrong about this. You are wrong because of your
ignorance of how deciders work. Deciders compute the mapping from
their finite string inputs to an accept or reject state on the basis
of the actual properties of these actual inputs.
I am perfectly aware of how deciders work and an actual property of ⟨Ĥ⟩ is that it represents the Turing Machine Ĥ. And a halt decider is
required to accept ⟨Ĥ⟩ ⟨Ĥ⟩ if and only if Ĥ ⟨Ĥ⟩ halts.
In much the same way a TM which performs SUMS might take two input
strings ⟨x⟩ and ⟨y⟩ and output some third string ⟨z⟩, but specification
of such a machine would be that it maps ⟨x⟩ ⟨y⟩ to ⟨z⟩ such that x + y =
z. There are ⟨brackets⟩ around the inputs, but not around the entities
in the specification.
It *IS* mapping from its inputs to its output, but the mapping is based
on an operation over the entities which the inputs and outputs
represent. That's how *all* Turing Machines work.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
⟨Ĥ⟩.qn ?
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
You apply TMs to inputs.
You can't apply a string to a string any more than you can add the
strings "2" and "3". You can add the integers they represent, but not
the strings themselves.
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."
When you don't cut off what I said in the middle of the sentence
then it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition
to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to ⟨Ĥ⟩ or you >>> can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a simulator. You cannot simulate
⟨Ĥ⟩ applied to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of terminology.
Yes, I insist on terminology being used correctly. And any place where
you attempt to publish your results will be equally, if not more, nit
picky.
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider embedded_H and
embedded_H correctly determines that its simulated input cannot
possibly reach any final state then embedded_H is necessarily correct
to transition to Ĥ.qn indicating that its simulated input never halts.
But now you've just hidden your meaningless terminological abuse. "Its simulated input" is only meaningful when it is construed as meaning the simulation of the computation REPRESENTED by the input, i.e. the
On 2022-02-01 20:08, olcott wrote:
embedded_H is exactly a UTM with extra features added.
Apparently you don't know what 'exactly' means. embedded_H is not a UTM
*at* *all*.
If embedded_H were a UTM, then
embedded_H would accept ⟨Ĥ⟩ ⟨Ĥ⟩ if Ĥ accepts ⟨Ĥ⟩
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."
When you don't cut off what I said in the middle of the sentence
then it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition
to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to ⟨Ĥ⟩ or >>>>> you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a simulator. You cannot >>>>> simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of terminology.
Yes, I insist on terminology being used correctly. And any place
where you attempt to publish your results will be equally, if not
more, nit picky.
It is fine and good that you help correct my terminology.
What is not fine and good is for you to reject the essence of the gist
of what I am saying entirely on the basis that I did not say it
exactly according to conventions. The is what Ben always did. He never
paid any attention to the actual substance of what I was saying.
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider embedded_H and
embedded_H correctly determines that its simulated input cannot
possibly reach any final state then embedded_H is necessarily
correct to transition to Ĥ.qn indicating that its simulated input
never halts.
But now you've just hidden your meaningless terminological abuse.
"Its simulated input" is only meaningful when it is construed as
meaning the simulation of the computation REPRESENTED by the input,
i.e. the
Not at all. A simulator simulates a finite string and the actual
behavior of this simulated finite string is the ultimate basis of
whether or not it specifies a finite sequence of configurations.
No. A simulator simulates a Turing Machine applied to an input. It takes
as its input a finite string which represents that Turing Machine/Input
pair. It's completely meaningless to talk about simulating a finite string.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot possibly >> reach ⟨Ĥ⟩.qn then it is necessarily correct for embedded_H to
transition to Ĥ.qn and nothing else in the universe can possibly
refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ is
both meaningful (it isn't) and somehow distinct from H applied to ⟨Ĥ⟩.
What you're doing is essentially the same thing as if I produced a SUM
TM which, given ⟨3⟩ and ⟨2⟩ as inputs, produced the output ⟨6⟩, and me
claiming that it is correct because it isn't responsible for adding the integers, only the finite strings which SUM was given as inputs, and
that my algorithm correctly determines that SUM ⟨3⟩⟨2⟩ is ⟨6⟩ despite
the fact that SUM 3 2 is 5.
In much simpler terms if the input to simulating halt decider H never
halts then it is always correct for H to report that its input never
halts.
Inputs don't halt or not halt. Only the TM/input pair which the input *describes* can halt or not halt.
André
On 2022-02-01 20:59, olcott wrote:
On 2/1/2022 9:33 PM, André G. Isaak wrote:
On 2022-02-01 20:08, olcott wrote:
embedded_H is exactly a UTM with extra features added.
Apparently you don't know what 'exactly' means. embedded_H is not a
UTM *at* *all*.
If embedded_H were a UTM, then
embedded_H would accept ⟨Ĥ⟩ ⟨Ĥ⟩ if Ĥ accepts ⟨Ĥ⟩
And in a previous post you accused *me* of snipping part way through?
embedded_H merely determines whether or not its input specifies a
finite sequence of configurations. It does not give a rats ass about
anything else in the universe.
Which again means that it is not a UTM since that is *not* what a UTM determines.
Being a halt decider and being a UTM are mutually exclusive.
André
On 2/2/22 10:20 AM, olcott wrote:No it only proves that you and André don't understand that a halt
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."
When you don't cut off what I said in the middle of the sentence >>>>>>>> then it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly >>>>>>>> transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to ⟨Ĥ⟩ or >>>>>>> you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a simulator. You cannot
simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of terminology.
Yes, I insist on terminology being used correctly. And any place
where you attempt to publish your results will be equally, if not
more, nit picky.
It is fine and good that you help correct my terminology.
What is not fine and good is for you to reject the essence of the
gist of what I am saying entirely on the basis that I did not say it
exactly according to conventions. The is what Ben always did. He
never paid any attention to the actual substance of what I was saying. >>>>
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider embedded_H
and embedded_H correctly determines that its simulated input
cannot possibly reach any final state then embedded_H is
necessarily correct to transition to Ĥ.qn indicating that its
simulated input never halts.
But now you've just hidden your meaningless terminological abuse.
"Its simulated input" is only meaningful when it is construed as
meaning the simulation of the computation REPRESENTED by the input,
i.e. the
Not at all. A simulator simulates a finite string and the actual
behavior of this simulated finite string is the ultimate basis of
whether or not it specifies a finite sequence of configurations.
No. A simulator simulates a Turing Machine applied to an input. It
takes as its input a finite string which represents that Turing
Machine/Input pair. It's completely meaningless to talk about
simulating a finite string.
It is possible for Turing machines to have blank tapes.
The salient aspect for the Halting problem is whether or not the
finite string machine description specifies a finite or infinite
sequence of configurations. The ultimate basis for determining this is
the actual behavior of the simulated finite string.
Since this equally applies to machines having inputs and machines not
having inputs the distinction relative to inputs is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot possibly
reach ⟨Ĥ⟩.qn then it is necessarily correct for embedded_H to
transition to Ĥ.qn and nothing else in the universe can possibly
refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ is
both meaningful (it isn't) and somehow distinct from H applied to ⟨Ĥ⟩. >>>
The behavior of the simulated input when embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
is the ultimate measure of the halt status of this input.
Which just proves you are not working on the Halting Problem,
On 2/2/22 8:41 PM, olcott wrote:
On 2/2/2022 6:22 PM, Richard Damon wrote:
On 2/2/22 10:20 AM, olcott wrote:No it only proves that you and André don't understand that a halt
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.
Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."
When you don't cut off what I said in the middle of the
sentence then it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly >>>>>>>>>> transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to ⟨Ĥ⟩ >>>>>>>>> or you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a simulator. You >>>>>>>>> cannot simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ anymore than you can apply
⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of terminology.
Yes, I insist on terminology being used correctly. And any place >>>>>>> where you attempt to publish your results will be equally, if not >>>>>>> more, nit picky.
It is fine and good that you help correct my terminology.
What is not fine and good is for you to reject the essence of the
gist of what I am saying entirely on the basis that I did not say
it exactly according to conventions. The is what Ben always did.
He never paid any attention to the actual substance of what I was
saying.
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider embedded_H
and embedded_H correctly determines that its simulated input
cannot possibly reach any final state then embedded_H is
necessarily correct to transition to Ĥ.qn indicating that its >>>>>>>> simulated input never halts.
But now you've just hidden your meaningless terminological abuse. >>>>>>> "Its simulated input" is only meaningful when it is construed as >>>>>>> meaning the simulation of the computation REPRESENTED by the
input, i.e. the
Not at all. A simulator simulates a finite string and the actual
behavior of this simulated finite string is the ultimate basis of
whether or not it specifies a finite sequence of configurations.
No. A simulator simulates a Turing Machine applied to an input. It
takes as its input a finite string which represents that Turing
Machine/Input pair. It's completely meaningless to talk about
simulating a finite string.
It is possible for Turing machines to have blank tapes.
The salient aspect for the Halting problem is whether or not the
finite string machine description specifies a finite or infinite
sequence of configurations. The ultimate basis for determining this
is the actual behavior of the simulated finite string.
Since this equally applies to machines having inputs and machines
not having inputs the distinction relative to inputs is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot possibly
reach ⟨Ĥ⟩.qn then it is necessarily correct for embedded_H to >>>>>> transition to Ĥ.qn and nothing else in the universe can possibly
refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ applied to ⟨Ĥ⟩
is both meaningful (it isn't) and somehow distinct from H applied
to ⟨Ĥ⟩.
The behavior of the simulated input when embedded_H applied to ⟨Ĥ⟩ >>>> ⟨Ĥ⟩ is the ultimate measure of the halt status of this input.
Which just proves you are not working on the Halting Problem,
decider computes the mapping from the inputs to an accept or reject
state (here is the part that you two don't understand):
On the basis of the actual behavior specified by the actual input.
On the basis of the actual behavior specified by the actual input.
On the basis of the actual behavior specified by the actual input.
Which is DEFINED by what a the machine the input represents would do,
On 2/2/22 10:50 PM, olcott wrote:
On 2/2/2022 9:30 PM, Richard Damon wrote:
It must only do exactly what it actually does, if this does not meet
On 2/2/22 10:12 PM, olcott wrote:
On 2/2/2022 8:57 PM, Richard Damon wrote:
On 2/2/22 9:31 PM, olcott wrote:description of a machine is the ultimate measure of the behavior
On 2/2/2022 8:08 PM, Richard Damon wrote:
On 2/2/22 8:41 PM, olcott wrote:
On 2/2/2022 6:22 PM, Richard Damon wrote:
On 2/2/22 10:20 AM, olcott wrote:halt decider computes the mapping from the inputs to an accept >>>>>>>> or reject state (here is the part that you two don't understand): >>>>>>>>
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote:
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless. >>>>>>>>>>>>>>>>Sure and so is the "I am going to go to the" part of >>>>>>>>>>>>>>>> "I am going to go to the store to buy some ice cream." >>>>>>>>>>>>>>>>
When you don't cut off what I said in the middle of the >>>>>>>>>>>>>>>> sentence then it makes much more sense.
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly
transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied to >>>>>>>>>>>>>>> ⟨Ĥ⟩ or you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a >>>>>>>>>>>>>>> simulator. You cannot simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ anymore
than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of
terminology.
Yes, I insist on terminology being used correctly. And any >>>>>>>>>>>>> place where you attempt to publish your results will be >>>>>>>>>>>>> equally, if not more, nit picky.
It is fine and good that you help correct my terminology. >>>>>>>>>>>> What is not fine and good is for you to reject the essence >>>>>>>>>>>> of the gist of what I am saying entirely on the basis that I >>>>>>>>>>>> did not say it exactly according to conventions. The is what >>>>>>>>>>>> Ben always did. He never paid any attention to the actual >>>>>>>>>>>> substance of what I was saying.
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider >>>>>>>>>>>>>> embedded_H and embedded_H correctly determines that its >>>>>>>>>>>>>> simulated input cannot possibly reach any final state then >>>>>>>>>>>>>> embedded_H is necessarily correct to transition to Ĥ.qn >>>>>>>>>>>>>> indicating that its simulated input never halts.
But now you've just hidden your meaningless terminological >>>>>>>>>>>>> abuse. "Its simulated input" is only meaningful when it is >>>>>>>>>>>>> construed as meaning the simulation of the computation >>>>>>>>>>>>> REPRESENTED by the input, i.e. the
Not at all. A simulator simulates a finite string and the >>>>>>>>>>>> actual behavior of this simulated finite string is the >>>>>>>>>>>> ultimate basis of whether or not it specifies a finite >>>>>>>>>>>> sequence of configurations.
No. A simulator simulates a Turing Machine applied to an >>>>>>>>>>> input. It takes as its input a finite string which represents >>>>>>>>>>> that Turing Machine/Input pair. It's completely meaningless >>>>>>>>>>> to talk about simulating a finite string.
It is possible for Turing machines to have blank tapes.
The salient aspect for the Halting problem is whether or not >>>>>>>>>> the finite string machine description specifies a finite or >>>>>>>>>> infinite sequence of configurations. The ultimate basis for >>>>>>>>>> determining this is the actual behavior of the simulated
finite string.
Since this equally applies to machines having inputs and
machines not having inputs the distinction relative to inputs >>>>>>>>>> is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot
possibly reach ⟨Ĥ⟩.qn then it is necessarily correct for >>>>>>>>>>>> embedded_H to transition to Ĥ.qn and nothing else in the >>>>>>>>>>>> universe can possibly refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ applied to >>>>>>>>>>> ⟨Ĥ⟩ is both meaningful (it isn't) and somehow distinct from H >>>>>>>>>>> applied to ⟨Ĥ⟩.
The behavior of the simulated input when embedded_H applied to >>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is the ultimate measure of the halt status of this input.
Which just proves you are not working on the Halting Problem, >>>>>>>> No it only proves that you and André don't understand that a
On the basis of the actual behavior specified by the actual input. >>>>>>>> On the basis of the actual behavior specified by the actual input. >>>>>>>> On the basis of the actual behavior specified by the actual input. >>>>>>>>
Which is DEFINED by what a the machine the input represents would >>>>>>> do,
These words prove themselves true on the basis of their meaning:
The actual behavior of the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>> embedded_H is the ultimate measure of the behavior specified by
⟨Ĥ⟩ ⟨Ĥ⟩.
WRONG, which shows you do not actually know the meaning of the words. >>>> When you disagree that the correct simulation of a machine
specified by this machine description it is just like saying that a
black cat is not a cat.
The problem is that 'Correct Simulation of a machine description' has
an actual meaning, in that the simulation must match the actual
behavior of the machine whose description it is simulating, RIGHT?
expectations then expectations must be incorrect.
Here is what it actually does:
These steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
And if that is what it actually does, then H NEVER aborts its simulation
and thus never give an answer.
On 2/2/22 11:50 PM, olcott wrote:
On 2/2/2022 10:42 PM, Richard Damon wrote:
On 2/2/22 10:50 PM, olcott wrote:
On 2/2/2022 9:30 PM, Richard Damon wrote:
It must only do exactly what it actually does, if this does not meet
On 2/2/22 10:12 PM, olcott wrote:
On 2/2/2022 8:57 PM, Richard Damon wrote:
On 2/2/22 9:31 PM, olcott wrote:When you disagree that the correct simulation of a machine
On 2/2/2022 8:08 PM, Richard Damon wrote:
On 2/2/22 8:41 PM, olcott wrote:
On 2/2/2022 6:22 PM, Richard Damon wrote:
On 2/2/22 10:20 AM, olcott wrote:On the basis of the actual behavior specified by the actual >>>>>>>>>> input.
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote:
On 2022-02-01 19:37, olcott wrote:So you are simply being nit picky about my use of >>>>>>>>>>>>>>>> terminology.
On 2/1/2022 8:08 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless. >>>>>>>>>>>>>>>>>>Sure and so is the "I am going to go to the" part of >>>>>>>>>>>>>>>>>> "I am going to go to the store to buy some ice cream." >>>>>>>>>>>>>>>>>>
When you don't cut off what I said in the middle of >>>>>>>>>>>>>>>>>> the sentence then it makes much more sense. >>>>>>>>>>>>>>>>>>
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H >>>>>>>>>>>>>>>>>> possibly transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ applied >>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ or you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the input to a
simulator. You cannot simulate ⟨Ĥ⟩ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>> anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩. >>>>>>>>>>>>>>>>
Yes, I insist on terminology being used correctly. And >>>>>>>>>>>>>>> any place where you attempt to publish your results will >>>>>>>>>>>>>>> be equally, if not more, nit picky.
It is fine and good that you help correct my terminology. >>>>>>>>>>>>>> What is not fine and good is for you to reject the essence >>>>>>>>>>>>>> of the gist of what I am saying entirely on the basis that >>>>>>>>>>>>>> I did not say it exactly according to conventions. The is >>>>>>>>>>>>>> what Ben always did. He never paid any attention to the >>>>>>>>>>>>>> actual substance of what I was saying.
Not at all. A simulator simulates a finite string and the >>>>>>>>>>>>>> actual behavior of this simulated finite string is the >>>>>>>>>>>>>> ultimate basis of whether or not it specifies a finite >>>>>>>>>>>>>> sequence of configurations.When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider >>>>>>>>>>>>>>>> embedded_H and embedded_H correctly determines that its >>>>>>>>>>>>>>>> simulated input cannot possibly reach any final state >>>>>>>>>>>>>>>> then embedded_H is necessarily correct to transition to >>>>>>>>>>>>>>>> Ĥ.qn indicating that its simulated input never halts. >>>>>>>>>>>>>>>But now you've just hidden your meaningless
terminological abuse. "Its simulated input" is only >>>>>>>>>>>>>>> meaningful when it is construed as meaning the simulation >>>>>>>>>>>>>>> of the computation REPRESENTED by the input, i.e. the >>>>>>>>>>>>>>
No. A simulator simulates a Turing Machine applied to an >>>>>>>>>>>>> input. It takes as its input a finite string which
represents that Turing Machine/Input pair. It's completely >>>>>>>>>>>>> meaningless to talk about simulating a finite string. >>>>>>>>>>>>>
It is possible for Turing machines to have blank tapes. >>>>>>>>>>>>
The salient aspect for the Halting problem is whether or not >>>>>>>>>>>> the finite string machine description specifies a finite or >>>>>>>>>>>> infinite sequence of configurations. The ultimate basis for >>>>>>>>>>>> determining this is the actual behavior of the simulated >>>>>>>>>>>> finite string.
Since this equally applies to machines having inputs and >>>>>>>>>>>> machines not having inputs the distinction relative to >>>>>>>>>>>> inputs is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot
possibly reach ⟨Ĥ⟩.qn then it is necessarily correct for >>>>>>>>>>>>>> embedded_H to transition to Ĥ.qn and nothing else in the >>>>>>>>>>>>>> universe can possibly refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ applied >>>>>>>>>>>>> to ⟨Ĥ⟩ is both meaningful (it isn't) and somehow distinct >>>>>>>>>>>>> from H applied to ⟨Ĥ⟩.
The behavior of the simulated input when embedded_H applied >>>>>>>>>>>> to ⟨Ĥ⟩ ⟨Ĥ⟩ is the ultimate measure of the halt status of >>>>>>>>>>>> this input.
Which just proves you are not working on the Halting Problem, >>>>>>>>>> No it only proves that you and André don't understand that a >>>>>>>>>> halt decider computes the mapping from the inputs to an accept >>>>>>>>>> or reject state (here is the part that you two don't understand): >>>>>>>>>>
On the basis of the actual behavior specified by the actual >>>>>>>>>> input.
On the basis of the actual behavior specified by the actual >>>>>>>>>> input.
Which is DEFINED by what a the machine the input represents
would do,
These words prove themselves true on the basis of their meaning: >>>>>>>> The actual behavior of the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>>>> embedded_H is the ultimate measure of the behavior specified by >>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
WRONG, which shows you do not actually know the meaning of the
words.
description of a machine is the ultimate measure of the behavior
specified by this machine description it is just like saying that
a black cat is not a cat.
The problem is that 'Correct Simulation of a machine description'
has an actual meaning, in that the simulation must match the actual
behavior of the machine whose description it is simulating, RIGHT?
expectations then expectations must be incorrect.
Here is what it actually does:
These steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
And if that is what it actually does, then H NEVER aborts its
simulation and thus never give an answer.
When embedded_H correctly matches the above infinite sequence this
conclusively proves that its correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ cannot >> possibly reach ⟨Ĥ⟩.qn. (We don't even need to mention any UTM).
Excepts as previously said, that pattern only exists if H never aborts.
On 2/3/22 12:24 AM, olcott wrote:
On 2/2/2022 11:09 PM, Richard Damon wrote:
On 2/2/22 11:50 PM, olcott wrote:That is not true. The pattern exists for at least any finite number of
On 2/2/2022 10:42 PM, Richard Damon wrote:
On 2/2/22 10:50 PM, olcott wrote:
On 2/2/2022 9:30 PM, Richard Damon wrote:
It must only do exactly what it actually does, if this does not
On 2/2/22 10:12 PM, olcott wrote:
On 2/2/2022 8:57 PM, Richard Damon wrote:
On 2/2/22 9:31 PM, olcott wrote:When you disagree that the correct simulation of a machine
On 2/2/2022 8:08 PM, Richard Damon wrote:
On 2/2/22 8:41 PM, olcott wrote:
On 2/2/2022 6:22 PM, Richard Damon wrote:
On 2/2/22 10:20 AM, olcott wrote:
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote:
On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>>> On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>>>
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless. >>>>>>>>>>>>>>>>>>>>Sure and so is the "I am going to go to the" part of >>>>>>>>>>>>>>>>>>>> "I am going to go to the store to buy some ice cream." >>>>>>>>>>>>>>>>>>>>
When you don't cut off what I said in the middle of >>>>>>>>>>>>>>>>>>>> the sentence then it makes much more sense. >>>>>>>>>>>>>>>>>>>>
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H >>>>>>>>>>>>>>>>>>>> possibly transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ >>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ or you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the
input to a simulator. You cannot simulate ⟨Ĥ⟩ applied >>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of >>>>>>>>>>>>>>>>>> terminology.
Yes, I insist on terminology being used correctly. And >>>>>>>>>>>>>>>>> any place where you attempt to publish your results >>>>>>>>>>>>>>>>> will be equally, if not more, nit picky.
It is fine and good that you help correct my terminology. >>>>>>>>>>>>>>>> What is not fine and good is for you to reject the >>>>>>>>>>>>>>>> essence of the gist of what I am saying entirely on the >>>>>>>>>>>>>>>> basis that I did not say it exactly according to >>>>>>>>>>>>>>>> conventions. The is what Ben always did. He never paid >>>>>>>>>>>>>>>> any attention to the actual substance of what I was saying. >>>>>>>>>>>>>>>>
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider
embedded_H and embedded_H correctly determines that >>>>>>>>>>>>>>>>>> its simulated input cannot possibly reach any final >>>>>>>>>>>>>>>>>> state then embedded_H is necessarily correct to >>>>>>>>>>>>>>>>>> transition to Ĥ.qn indicating that its simulated input >>>>>>>>>>>>>>>>>> never halts.
But now you've just hidden your meaningless
terminological abuse. "Its simulated input" is only >>>>>>>>>>>>>>>>> meaningful when it is construed as meaning the >>>>>>>>>>>>>>>>> simulation of the computation REPRESENTED by the input, >>>>>>>>>>>>>>>>> i.e. the
Not at all. A simulator simulates a finite string and >>>>>>>>>>>>>>>> the actual behavior of this simulated finite string is >>>>>>>>>>>>>>>> the ultimate basis of whether or not it specifies a >>>>>>>>>>>>>>>> finite sequence of configurations.
No. A simulator simulates a Turing Machine applied to an >>>>>>>>>>>>>>> input. It takes as its input a finite string which >>>>>>>>>>>>>>> represents that Turing Machine/Input pair. It's
completely meaningless to talk about simulating a finite >>>>>>>>>>>>>>> string.
It is possible for Turing machines to have blank tapes. >>>>>>>>>>>>>>
The salient aspect for the Halting problem is whether or >>>>>>>>>>>>>> not the finite string machine description specifies a >>>>>>>>>>>>>> finite or infinite sequence of configurations. The >>>>>>>>>>>>>> ultimate basis for determining this is the actual behavior >>>>>>>>>>>>>> of the simulated finite string.
Since this equally applies to machines having inputs and >>>>>>>>>>>>>> machines not having inputs the distinction relative to >>>>>>>>>>>>>> inputs is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H >>>>>>>>>>>>>>>> cannot possibly reach ⟨Ĥ⟩.qn then it is necessarily >>>>>>>>>>>>>>>> correct for embedded_H to transition to Ĥ.qn and nothing >>>>>>>>>>>>>>>> else in the universe can possibly refute this.
Again, you're falling back on your belief that ⟨Ĥ⟩ >>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ is both meaningful (it isn't) and somehow >>>>>>>>>>>>>>> distinct from H applied to ⟨Ĥ⟩.
The behavior of the simulated input when embedded_H >>>>>>>>>>>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is the ultimate measure of the halt >>>>>>>>>>>>>> status of this input.
Which just proves you are not working on the Halting Problem, >>>>>>>>>>>> No it only proves that you and André don't understand that a >>>>>>>>>>>> halt decider computes the mapping from the inputs to an >>>>>>>>>>>> accept or reject state (here is the part that you two don't >>>>>>>>>>>> understand):
On the basis of the actual behavior specified by the actual >>>>>>>>>>>> input.
On the basis of the actual behavior specified by the actual >>>>>>>>>>>> input.
On the basis of the actual behavior specified by the actual >>>>>>>>>>>> input.
Which is DEFINED by what a the machine the input represents >>>>>>>>>>> would do,
These words prove themselves true on the basis of their meaning: >>>>>>>>>> The actual behavior of the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
embedded_H is the ultimate measure of the behavior specified >>>>>>>>>> by ⟨Ĥ⟩ ⟨Ĥ⟩.
WRONG, which shows you do not actually know the meaning of the >>>>>>>>> words.
description of a machine is the ultimate measure of the behavior >>>>>>>> specified by this machine description it is just like saying
that a black cat is not a cat.
The problem is that 'Correct Simulation of a machine description' >>>>>>> has an actual meaning, in that the simulation must match the
actual behavior of the machine whose description it is
simulating, RIGHT?
meet expectations then expectations must be incorrect.
Here is what it actually does:
These steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
And if that is what it actually does, then H NEVER aborts its
simulation and thus never give an answer.
When embedded_H correctly matches the above infinite sequence this
conclusively proves that its correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
possibly reach ⟨Ĥ⟩.qn. (We don't even need to mention any UTM).
Excepts as previously said, that pattern only exists if H never aborts.
steps where it can be recognized. The three iterations shown above are
plenty enough for it to be recogized.
But if it only exists for a finite number of steps (till it is
recognized)
On 2/3/2022 5:50 AM, Richard Damon wrote:
On 2/3/22 12:24 AM, olcott wrote:
On 2/2/2022 11:09 PM, Richard Damon wrote:
On 2/2/22 11:50 PM, olcott wrote:That is not true. The pattern exists for at least any finite number
On 2/2/2022 10:42 PM, Richard Damon wrote:
On 2/2/22 10:50 PM, olcott wrote:
On 2/2/2022 9:30 PM, Richard Damon wrote:
It must only do exactly what it actually does, if this does not
On 2/2/22 10:12 PM, olcott wrote:
On 2/2/2022 8:57 PM, Richard Damon wrote:
On 2/2/22 9:31 PM, olcott wrote:When you disagree that the correct simulation of a machine
On 2/2/2022 8:08 PM, Richard Damon wrote:
On 2/2/22 8:41 PM, olcott wrote:
On 2/2/2022 6:22 PM, Richard Damon wrote:
On 2/2/22 10:20 AM, olcott wrote:
On 2/1/2022 9:58 PM, André G. Isaak wrote:
On 2022-02-01 20:44, olcott wrote:
On 2/1/2022 9:24 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>> On 2022-02-01 19:57, olcott wrote:
On 2/1/2022 8:48 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>>>> On 2022-02-01 19:37, olcott wrote:
On 2/1/2022 8:08 PM, André G. Isaak wrote: >>>>>>>>>>>>>>>>>>>>
⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless. >>>>>>>>>>>>>>>>>>>>>Sure and so is the "I am going to go to the" part of >>>>>>>>>>>>>>>>>>>>> "I am going to go to the store to buy some ice cream." >>>>>>>>>>>>>>>>>>>>>
When you don't cut off what I said in the middle of >>>>>>>>>>>>>>>>>>>>> the sentence then it makes much more sense. >>>>>>>>>>>>>>>>>>>>>
Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H >>>>>>>>>>>>>>>>>>>>> possibly transition to ⟨Ĥ⟩.qn ?
That's just as meaningless. You can simulate Ĥ >>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ or you can provide ⟨Ĥ⟩ ⟨Ĥ⟩ as the
input to a simulator. You cannot simulate ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ anymore than you can apply ⟨Ĥ⟩ to ⟨Ĥ⟩.
So you are simply being nit picky about my use of >>>>>>>>>>>>>>>>>>> terminology.
Yes, I insist on terminology being used correctly. And >>>>>>>>>>>>>>>>>> any place where you attempt to publish your results >>>>>>>>>>>>>>>>>> will be equally, if not more, nit picky.
It is fine and good that you help correct my terminology. >>>>>>>>>>>>>>>>> What is not fine and good is for you to reject the >>>>>>>>>>>>>>>>> essence of the gist of what I am saying entirely on the >>>>>>>>>>>>>>>>> basis that I did not say it exactly according to >>>>>>>>>>>>>>>>> conventions. The is what Ben always did. He never paid >>>>>>>>>>>>>>>>> any attention to the actual substance of what I was >>>>>>>>>>>>>>>>> saying.
When ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to simulating halt decider
embedded_H and embedded_H correctly determines that >>>>>>>>>>>>>>>>>>> its simulated input cannot possibly reach any final >>>>>>>>>>>>>>>>>>> state then embedded_H is necessarily correct to >>>>>>>>>>>>>>>>>>> transition to Ĥ.qn indicating that its simulated >>>>>>>>>>>>>>>>>>> input never halts.
But now you've just hidden your meaningless >>>>>>>>>>>>>>>>>> terminological abuse. "Its simulated input" is only >>>>>>>>>>>>>>>>>> meaningful when it is construed as meaning the >>>>>>>>>>>>>>>>>> simulation of the computation REPRESENTED by the >>>>>>>>>>>>>>>>>> input, i.e. the
Not at all. A simulator simulates a finite string and >>>>>>>>>>>>>>>>> the actual behavior of this simulated finite string is >>>>>>>>>>>>>>>>> the ultimate basis of whether or not it specifies a >>>>>>>>>>>>>>>>> finite sequence of configurations.
No. A simulator simulates a Turing Machine applied to an >>>>>>>>>>>>>>>> input. It takes as its input a finite string which >>>>>>>>>>>>>>>> represents that Turing Machine/Input pair. It's >>>>>>>>>>>>>>>> completely meaningless to talk about simulating a finite >>>>>>>>>>>>>>>> string.
It is possible for Turing machines to have blank tapes. >>>>>>>>>>>>>>>
The salient aspect for the Halting problem is whether or >>>>>>>>>>>>>>> not the finite string machine description specifies a >>>>>>>>>>>>>>> finite or infinite sequence of configurations. The >>>>>>>>>>>>>>> ultimate basis for determining this is the actual >>>>>>>>>>>>>>> behavior of the simulated finite string.
Since this equally applies to machines having inputs and >>>>>>>>>>>>>>> machines not having inputs the distinction relative to >>>>>>>>>>>>>>> inputs is moot.
If the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H >>>>>>>>>>>>>>>>> cannot possibly reach ⟨Ĥ⟩.qn then it is necessarily >>>>>>>>>>>>>>>>> correct for embedded_H to transition to Ĥ.qn and >>>>>>>>>>>>>>>>> nothing else in the universe can possibly refute this. >>>>>>>>>>>>>>>>Again, you're falling back on your belief that ⟨Ĥ⟩ >>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ is both meaningful (it isn't) and somehow >>>>>>>>>>>>>>>> distinct from H applied to ⟨Ĥ⟩.
The behavior of the simulated input when embedded_H >>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is the ultimate measure of the halt
status of this input.
Which just proves you are not working on the Halting Problem, >>>>>>>>>>>>> No it only proves that you and André don't understand that >>>>>>>>>>>>> a halt decider computes the mapping from the inputs to an >>>>>>>>>>>>> accept or reject state (here is the part that you two don't >>>>>>>>>>>>> understand):
On the basis of the actual behavior specified by the actual >>>>>>>>>>>>> input.
On the basis of the actual behavior specified by the actual >>>>>>>>>>>>> input.
On the basis of the actual behavior specified by the actual >>>>>>>>>>>>> input.
Which is DEFINED by what a the machine the input represents >>>>>>>>>>>> would do,
These words prove themselves true on the basis of their meaning: >>>>>>>>>>> The actual behavior of the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
embedded_H is the ultimate measure of the behavior specified >>>>>>>>>>> by ⟨Ĥ⟩ ⟨Ĥ⟩.
WRONG, which shows you do not actually know the meaning of the >>>>>>>>>> words.
description of a machine is the ultimate measure of the
behavior specified by this machine description it is just like >>>>>>>>> saying that a black cat is not a cat.
The problem is that 'Correct Simulation of a machine
description' has an actual meaning, in that the simulation must >>>>>>>> match the actual behavior of the machine whose description it is >>>>>>>> simulating, RIGHT?
meet expectations then expectations must be incorrect.
Here is what it actually does:
These steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
⟨Ĥ4⟩ ⟨Ĥ5⟩...
And if that is what it actually does, then H NEVER aborts its
simulation and thus never give an answer.
When embedded_H correctly matches the above infinite sequence this
conclusively proves that its correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
possibly reach ⟨Ĥ⟩.qn. (We don't even need to mention any UTM). >>>>>
Excepts as previously said, that pattern only exists if H never aborts. >>>>
of steps where it can be recognized. The three iterations shown above
are plenty enough for it to be recogized.
But if it only exists for a finite number of steps (till it is
recognized)
Then embedded_H has conclusively proved that its simulated ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly ever reach ⟨Ĥ⟩.qn even in an infinite number of simulated steps thus meeting the Linz definition of a sequence of configurations that never halt.
computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)
On 2022-02-01 20:08, olcott wrote:
embedded_H is exactly a UTM with extra features added.
Apparently you don't know what 'exactly' means. embedded_H is not a UTM
*at* *all*.
If embedded_H were a UTM, then
embedded_H would accept ⟨Ĥ⟩ ⟨Ĥ⟩ if Ĥ accepts ⟨Ĥ⟩
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 124:56:53 |
| Calls: | 6,662 |
| Files: | 12,212 |
| Messages: | 5,334,849 |