H1(D,D) maps its input + its own machine address 00001422 to its output.
H(D,D) maps its input + its own machine address 00001522 to its output. Thus both H1 and H are computable functions of their input.
Turing machines don't even have the idea of their own machine
address so this exact same thing cannot be Turing computable.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine
descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces.
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
On 3/7/2024 4:32 PM, Richard Damon wrote:
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to its output. >>> H(D,D) maps its input + its own machine address 00001522 to its
output.
Thus both H1 and H are computable functions of their input.
And thus you are admitting that Neither H or H1 are actually correct
Halt Deciders, as Halt Deciders must be only a function of the
description of the Compuation to be decided.
It turns out that both H(D,D) and H1(D,D) do correctly determine
whether or not they must abort the simulation of their input.
That you or others consider this somehow improper does not change
the verified fact that they both correctly determine whether or
not they must abort their simulation.
It is also the case that both H1(D,D) and H(D,D) are a pure function
of their inputs when we construe their own machine address to be an
element of these inputs.
Turing machines don't even have the idea of their own machine
address so this exact same thing cannot be Turing computable.
And it isn't a Halt Decider even in Olcott machines as the algorithm
is shown to vary by a parameter that it isn't allowed to vary to be a
Halt Decider.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine
descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces.
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in mechanics, the
H^ that needs to be generated will be a bit different.
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
H^ needs to have a copy of the algorithm of the decider at that point,
and give it exactly the same input as the decider will get.
Both Ĥ and H have a copy of their own non-identical TMD's.
Since H will get on its tape the string (H^) (H^) (H), that is exactly
what H^ (H^) must put on its tape,
Not at all. Olcott machines are exactly the same as Turing machines
yet always have a copy of their own machine description appended to
the end of their own tape. That you assert that H must have a copy of
some other TMD at the end of its tape is quite nutty.
so since H^ starts its tape with the values (M) (H^),
Not at all. The only Ĥ that I am talking about only has
its own TMD for its input.
it must duplicate the (M), and replace the (H^) with the description
of the version of H it is going to confound. (even though that isn't
the description of the copy at H^.H).
Note, while your master UTM may make sure that no Top level machine is
given the wrong description, there is nothing stopping a machine from
faking the data to a submachine of it.
No matter how Ĥ screws things up it will either halt or fail
to halt. No matter how much Ĥ screws itself up none of these
things have any effect what-so-ever on H.
You are just not thinking the problem out far enough.
You are apparently not smart enough to figure out what this change
needed to be to handle you new definition of Olcott machines, but I
was able to do that in just a few minutes of thinking.
I thought this through more deeply than you have and you cannot
show otherwise by providing correct reasoning why my ideas will
not work.
*Like most people you conflate unconventional with impossible*
H1(D,D) maps its input + its own machine address 00001422 to its output.
H(D,D) maps its input + its own machine address 00001522 to its output. Thus both H1 and H are computable functions of their input.
Turing machines don't even have the idea of their own machine
address so this exact same thing cannot be Turing computable.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine
descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces.
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
It's also the reason why you approach is fundamentally flawed. Putting
aside the question of whether your proposal is workable (or even sane),
if your 'Olcott Machines' automatically supply the machines they emulate
with a copy of their own machine descriptions, then you are no longer
working on the halting problem.
The halting problem asks, is it possible to construct a TM X that, given
a description of a second TM Y and an input string Z *and* *only* *that* *input* *to* *work* *with*, is it possible for X to determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a description X,
can X determine whether Y applied to Z halts, is an *entirely* different question.
The answer to these two questions may well be entirely different, and
the answer to the second question tells us absolutely nothing about the answer to the first, which is the only thing the halting problem is
concerned with.
André
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
It's also the reason why you approach is fundamentally flawed. Putting
aside the question of whether your proposal is workable (or even
sane), if your 'Olcott Machines' automatically supply the machines
they emulate with a copy of their own machine descriptions, then you
are no longer working on the halting problem.
The halting problem asks, is it possible to construct a TM X that,
given a description of a second TM Y and an input string Z *and*
*only* *that* *input* *to* *work* *with*, is it possible for X to
determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a description
X, can X determine whether Y applied to Z halts, is an *entirely*
different question.
The answer to these two questions may well be entirely different, and
the answer to the second question tells us absolutely nothing about
the answer to the first, which is the only thing the halting problem
is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine which does
need its own description can be modified to include the description it
needs (which won't be "its own" description any more, but it's
impossible that it would need to be). Olcott is just grasping at straws
to explain why obvious facts are false.
On 3/7/2024 8:16 PM, immibis wrote:
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
It's also the reason why you approach is fundamentally flawed.
Putting aside the question of whether your proposal is workable (or
even sane), if your 'Olcott Machines' automatically supply the
machines they emulate with a copy of their own machine descriptions,
then you are no longer working on the halting problem.
The halting problem asks, is it possible to construct a TM X that,
given a description of a second TM Y and an input string Z *and*
*only* *that* *input* *to* *work* *with*, is it possible for X to
determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a description
X, can X determine whether Y applied to Z halts, is an *entirely*
different question.
The answer to these two questions may well be entirely different, and
the answer to the second question tells us absolutely nothing about
the answer to the first, which is the only thing the halting problem
is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine which
does need its own description can be modified to include the
description it needs (which won't be "its own" description any more,
but it's impossible that it would need to be). Olcott is just grasping
at straws to explain why obvious facts are false.
It is possible for Ĥ to screw itself up and write an English poem
to the place where its own TMD is supposed to be. It is impossible
for Ĥ to write <H> to this location because it has no access or
knowledge of the existence of any separate <H>.
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to its
output.
H(D,D) maps its input + its own machine address 00001522 to its
output.
Thus both H1 and H are computable functions of their input.
And thus you are admitting that Neither H or H1 are actually correct
Halt Deciders, as Halt Deciders must be only a function of the
description of the Compuation to be decided.
It turns out that both H(D,D) and H1(D,D) do correctly determine
whether or not they must abort the simulation of their input.
Which isn't the halting question, so you are LYING.
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded
within these inputs have no answer at all.
That you or others consider this somehow improper does not change
the verified fact that they both correctly determine whether or
not they must abort their simulation.
Which isn't the Halting Question, which you claim you are working on,
so you are just LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
It is also the case that both H1(D,D) and H(D,D) are a pure function
of their inputs when we construe their own machine address to be an
element of these inputs.
Which means they are not computing the Halting Function, which isn't a
function of the decider, so again, you are LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
Turing machines don't even have the idea of their own machine
address so this exact same thing cannot be Turing computable.
And it isn't a Halt Decider even in Olcott machines as the algorithm
is shown to vary by a parameter that it isn't allowed to vary to be
a Halt Decider.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine
descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces.
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in mechanics,
the H^ that needs to be generated will be a bit different.
That Olcott machines always know their own TMD is unconventional.
And breaks much of the background of Turing Machines,
Not at all. Not in the least little bit.
Olcott machines are 100% fully specified
in terms of Turing machines.
so if you what to use ANY establish property of Turing Machine, you
must include that now extra data EXPLICITLY.
It is already explicitly included in the definition of an Olcott machine.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
But not the RIGHT computation.
Not the same computation that conventional wisdom expects.
Right answer to the wrong question is still a WRONG ANSWER.
The right answer to a different question that can always
be construed as the right answer to the original question
by H ⟨Ĥ⟩ ⟨Ĥ⟩ is the right answer.
So, you are just shown again to be a LIAR.
H^ needs to have a copy of the algorithm of the decider at that
point, and give it exactly the same input as the decider will get.
Both Ĥ and H have a copy of their own non-identical TMD's.
Yep, and H^ can give its H^.H the same TMD of the machine that will
decide it to its copy of H's algorithm,
You are not saying that Ĥ does not have its own TMD
you are only saying that it can screw this up too.
No matter what Ĥ does it will either halt or fail to
halt in a way that can be determined by the actual H.
so it gets the same answer as that H wil produce, and thus that H will
give the WRONG answer to the Halting Question,
Since H will get on its tape the string (H^) (H^) (H), that is
exactly what H^ (H^) must put on its tape,
It will not get this, where the Hell did you get this from?
Ĥ ⟨Ĥ⟩ gets only two inputs and both of them are ⟨Ĥ⟩.
The latter one is appended to its tape by the master UTM.
Ĥ never gets any separate <H>.
Not at all. Olcott machines are exactly the same as Turing machines
yet always have a copy of their own machine description appended to
the end of their own tape. That you assert that H must have a copy of
some other TMD at the end of its tape is quite nutty.
WHAT WAS WRONG WITH WHAT I SAID.
Where did I say that a machine when started had anything else.
The SUB-MACHINE H^.H can have on its tape whatever H^ wants to put
there, if that puts in the "Your TMD" slot the description of some
other verison of it, that is fine and you can't stop it.
Ĥ ⟨Ĥ⟩ cannot possibly put a separate <H> anywhere on its tape
it has no access to any such separate <H>.
So H^.H (H^) (H^) (H) will give exactly the same answer as the top level
H (H^) (H^) (H) will give.
And thus H^ will make H give the wrong answer for the Halting Problem.
so since H^ starts its tape with the values (M) (H^),
Not at all. The only Ĥ that I am talking about only has
its own TMD for its input.
H^ IN GENERAL, can have the description of ANY machine on its tape.
The one case we look at, M = H^, which is its own.
so H^ (H^) (H^) {last one added by the Master UTM, or H}
goes to H^.Hq0 (H^) (H^) (H) by duplicating its input data, removing
its own description and adding the description of the H it is tragetig.
it must duplicate the (M), and replace the (H^) with the description
of the version of H it is going to confound. (even though that isn't
the description of the copy at H^.H).
Note, while your master UTM may make sure that no Top level machine
is given the wrong description, there is nothing stopping a machine
from faking the data to a submachine of it.
No matter how Ĥ screws things up it will either halt or fail
to halt. No matter how much Ĥ screws itself up none of these
things have any effect what-so-ever on H.
But what it does is ALWAYS the opposite of what H will say.
Not all all. not even once. Ĥ only ever does the opposite of whatever
its own internal Ĥ.H says. it has no access to any external <H>.
H^ gets to know this, as it has a copy of that H, and it knows what
the tape to H will look like when it is asked about itself.
It has no idea that it has a copy of any external <H>.
You can't (successfully) argue with facts.
Not to someone that doesn't care about facts and only
cares about rebuttal.
You are just not thinking the problem out far enough.
You are apparently not smart enough to figure out what this change
needed to be to handle you new definition of Olcott machines, but I
was able to do that in just a few minutes of thinking.
I thought this through more deeply than you have and you cannot
show otherwise by providing correct reasoning why my ideas will
not work.
*Like most people you conflate unconventional with impossible*
So, why doesn't H^ get the same answer as H will give when it gives
its exact copy and exact copy of the input that H will get?
*Like I said and you have not fully integrated into your thinking*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> does indeed map to a different output than H ⟨Ĥ⟩ ⟨Ĥ⟩ <H>.
I do still really appreciate all of your feedback.
You do show a very good understanding of these things.
YOU are the one that assumes the impossible, so your logic trues out
to be just the mystical product of Fairy dust powered Unicorns, and
not anything that actually works.
Your FAILURE to answer the questions just proves your guilt.
On 3/7/2024 9:36 PM, Richard Damon wrote:
On 3/7/24 7:10 PM, olcott wrote:
On 3/7/2024 8:16 PM, immibis wrote:
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
It's also the reason why you approach is fundamentally flawed.
Putting aside the question of whether your proposal is workable (or
even sane), if your 'Olcott Machines' automatically supply the
machines they emulate with a copy of their own machine
descriptions, then you are no longer working on the halting problem. >>>>>
The halting problem asks, is it possible to construct a TM X that,
given a description of a second TM Y and an input string Z *and*
*only* *that* *input* *to* *work* *with*, is it possible for X to
determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a
description X, can X determine whether Y applied to Z halts, is an
*entirely* different question.
The answer to these two questions may well be entirely different,
and the answer to the second question tells us absolutely nothing
about the answer to the first, which is the only thing the halting
problem is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine which
does need its own description can be modified to include the
description it needs (which won't be "its own" description any more,
but it's impossible that it would need to be). Olcott is just
grasping at straws to explain why obvious facts are false.
It is possible for Ĥ to screw itself up and write an English poem
to the place where its own TMD is supposed to be. It is impossible
for Ĥ to write <H> to this location because it has no access or
knowledge of the existence of any separate <H>.
OF COURSE it has knowledge of the ONE SPECIAL H that it was written to
confound, so can have a (the) description of it.
Why wouldn't it.
You wouldn't send out an assissin without giving it complete
information about its target.
Once Olcott Machines get a description of themselves added, then H^
will be defined to confound just a particular description of H, but
one can be defined to confound ANY of the description of H, so we can
prove that ALL are confounded, just as the proof generalizes from the
specific H that this H^ was built on to any and all machines that
might be consider as a Halt Decider.
No Ĥ can possibly be defined to confound any H besides the one
that is embedded within it because Turing machines do not call
external functions.
On 3/7/2024 9:28 PM, Richard Damon wrote:
Of course it can have access to that, i just needs a long series of
states saying write the first symbol of <H>
Turing machine Ĥ does not even know that an external
Turing machine H exists.
Olcott machines can compute the difference between H1(D,D) and H(D,D)
because Olcott machines can correctly determine whether or not they themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and 00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
On 3/7/2024 9:28 PM, Richard Damon wrote:
On 3/7/24 4:00 PM, olcott wrote:
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to its >>>>>>> output.
H(D,D) maps its input + its own machine address 00001522 to its >>>>>>> output.
Thus both H1 and H are computable functions of their input.
And thus you are admitting that Neither H or H1 are actually
correct Halt Deciders, as Halt Deciders must be only a function of >>>>>> the description of the Compuation to be decided.
It turns out that both H(D,D) and H1(D,D) do correctly determine
whether or not they must abort the simulation of their input.
Which isn't the halting question, so you are LYING.
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded
within these inputs have no answer at all.
In other words you argue by lying.
The QUESTION is, and always will be, does the computation described by
the input Halt when run.
Which must be answered incorrectly indirectly otherwise Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
literally has nothing to say.
The Computation so described is FIXED and UNCHANGING reguards of what
the decider that is deciding does, as is the behavior of the H that it
is built on.
That was FIXED and made UNCHANGING when it was defined.
Thus, the question does THIS H^(H^) halt? HAS a definite and fixed
answer. SO you LIE when you said it doesn't.
For Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ the question:
Does your input halt on its input? has neither YES nor NO.
Thus we ask the question indirectly:
Will you halt if you never abort your simulation?
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right answer to that question.
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer to this question:
Does your input halt on its input?
H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the right answer to
Does your input halt on its input?
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) and H(D,D)
because Olcott machines can correctly determine whether or not they
themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and 00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
All you have done is show why your H / H1 have been disqualified from
being Halt Deciders.
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines
defines a machine that is exactly a Turing machine except can
always correctly determine whether or not itself is called in
recursive simulation.
They are not Computations using only the description of the
Computation to be decided on.
This PROVES that they are not correct Halt Deciders.
And you are proved to be just a pathetic and pathological liar.
On 3/7/2024 9:28 PM, Richard Damon wrote:
On 3/7/24 4:00 PM, olcott wrote:
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to its >>>>>>> output.
H(D,D) maps its input + its own machine address 00001522 to its >>>>>>> output.
Thus both H1 and H are computable functions of their input.
And thus you are admitting that Neither H or H1 are actually
correct Halt Deciders, as Halt Deciders must be only a function of >>>>>> the description of the Compuation to be decided.
It turns out that both H(D,D) and H1(D,D) do correctly determine
whether or not they must abort the simulation of their input.
Which isn't the halting question, so you are LYING.
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded
within these inputs have no answer at all.
In other words you argue by lying.
The QUESTION is, and always will be, does the computation described by
the input Halt when run.
The Computation so described is FIXED and UNCHANGING reguards of what
the decider that is deciding does, as is the behavior of the H that it
is built on.
That was FIXED and made UNCHANGING when it was defined.
Thus, the question does THIS H^(H^) halt? HAS a definite and fixed
answer. SO you LIE when you said it doesn't.
Your problem seems to be that you think "Get the Right Answer?" is a
valid program instruction, or that H can somehow "change" itself after
H^ gets defined. IT CAN'T.
YOU persistently ignore this fact, likely because you are too stupid
and ignorant to understand that fundamental nature of programs, that
they will do what their programming says they will do, and that
programming doesn't change, EVER, with out the creation of some NEW
program that is different from its predicesor.
YOU *NEVER* have the right to change the question for a problem.
You can try to point out the the problem is inconsistant, and propose
a NEW PROBLEM, but that doesn't change the old.
You can talk about your new problem that you think is more useful than
the actual Halting Problem, after all, someone might be more
interested in the incorrect opinion of an admittedly faulty
"Olcott-Halt Decider" than the actual behavior of the Computation they
are interested in.
NOT.
What you can't to is say you are working on one problem, while trying
to change it to mean something different. That is just call LYING, and
you seem to know that you doing it (you might feel you have justified
reasons to talk about a different problem) so the lie is DELIBERATE.
That you or others consider this somehow improper does not change
the verified fact that they both correctly determine whether or
not they must abort their simulation.
Which isn't the Halting Question, which you claim you are working
on, so you are just LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
So, you think you can change the question and still be talking about
the same question.
You ARE the LIAR PARADOX.
It is also the case that both H1(D,D) and H(D,D) are a pure function >>>>> of their inputs when we construe their own machine address to be an
element of these inputs.
Which means they are not computing the Halting Function, which isn't
a function of the decider, so again, you are LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
Yes, you have ADMITTED that you are LYING about working on the Halting
Problem.
Turing machines don't even have the idea of their own machine
address so this exact same thing cannot be Turing computable.
And it isn't a Halt Decider even in Olcott machines as the
algorithm is shown to vary by a parameter that it isn't allowed to >>>>>> vary to be a Halt Decider.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine
descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces.
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not
halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in mechanics,
the H^ that needs to be generated will be a bit different.
That Olcott machines always know their own TMD is unconventional.
And breaks much of the background of Turing Machines,
Not at all. Not in the least little bit.
Olcott machines are 100% fully specified
in terms of Turing machines.
Yes, BUT if you talk about an Olcott machine, you MUST include the
added data as part of the description of that machine, or you are just
LYING.
so if you what to use ANY establish property of Turing Machine, you
must include that now extra data EXPLICITLY.
It is already explicitly included in the definition of an Olcott
machine.
Which means that you can't actually write an Olcott-Machine that
matches the requirements for a Halt Decider.
A Halt Decider MUST be able to defined as taking JUST the description
of the Computation to be decided (the Allgorithm and the Data). In
general this also holds, to be a Foo decider, the decider must be give
JUST the information about the thing that we are deciding Foo on.
If Olcott machines that are essentially Turing machines configured in
a certain way can detect when they themselves are called in recursive simulation then this reconfiguration defines a new machine that can
compute every function that a TM can and more.
Since the mapping function for no practial problem actually will
depend on the decider that is deciding it, NO Olcott-Machine meets the
basic definition to be any of those deciders.
Olcott machines are always able to detect when they themselves
are called in recursive simulation. Since Turing machines cannot
possibly do that then Olcott machine are more powerful.
You are forced to have the machine take an extra parameter that you
then need to constrain that the machine can not actually depend on it.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
But not the RIGHT computation.
Not the same computation that conventional wisdom expects.
SO not the compution DEFINED for the problem.
Remember, the problem STARTS with the mapping function, which defines
what the decider is allowed to have as inputs, and what answer each
value of those inputs should generate.
By simply defining a reconfiguration of a Turing machine
Olcott machines can compute when they themselves are
called in recursive simulation. H1 and H need to do that.
Right answer to the wrong question is still a WRONG ANSWER.
The right answer to a different question that can always
be construed as the right answer to the original question
by H ⟨Ĥ⟩ ⟨Ĥ⟩ is the right answer.
NOPE, more LIES.
If H(H^,H^) returns non-halting, then H^.H(H^,H^) will ALSO return
non-halting, and H^ will halt, meaning H was wrong, and you are LYING.
*No matter how many times I tell you that there is a third*
*input you always immediately forget this right when I tell you*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // must abort input
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // input halts
Olcott machines always have an extra input whenever
they need to determine whether or not their input
TMD is about to simulate itself with its same input.
It doesn't count as an input unless they use it.
On 3/8/2024 12:49 AM, Richard Damon wrote:
On 3/7/24 10:09 PM, olcott wrote:
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) and H(D,D) >>>>> because Olcott machines can correctly determine whether or not they
themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and 00001522 >>>>> For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
All you have done is show why your H / H1 have been disqualified
from being Halt Deciders.
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines
defines a machine that is exactly a Turing machine except can
always correctly determine whether or not itself is called in
recursive simulation.
Nope.
You tried, but failed.
All that you have done is disagree with verified facts.
You always said that H1(D,D) and H(D,D) cannot compute different
outputs. I proved exactly how they do this and how it is computable
and you simply ignore what I say.
When H1 and H both have access to their own machine address this is equivalent to H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ>
Your H and H1 likely will never answer when given the properly
designed H^ input.
You are just a total failure, again.
And are just lying about it because you refuse to face the facts.
They are not Computations using only the description of the
Computation to be decided on.
This PROVES that they are not correct Halt Deciders.
And you are proved to be just a pathetic and pathological liar.
On 3/8/2024 12:34 AM, Richard Damon wrote:
On 3/7/24 10:00 PM, olcott wrote:
On 3/7/2024 9:28 PM, Richard Damon wrote:
On 3/7/24 4:00 PM, olcott wrote:
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to >>>>>>>>> its output.
H(D,D) maps its input + its own machine address 00001522 to >>>>>>>>> its output.
Thus both H1 and H are computable functions of their input.
And thus you are admitting that Neither H or H1 are actually
correct Halt Deciders, as Halt Deciders must be only a function >>>>>>>> of the description of the Compuation to be decided.
It turns out that both H(D,D) and H1(D,D) do correctly determine >>>>>>> whether or not they must abort the simulation of their input.
Which isn't the halting question, so you are LYING.
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded
within these inputs have no answer at all.
In other words you argue by lying.
The QUESTION is, and always will be, does the computation described
by the input Halt when run.
The Computation so described is FIXED and UNCHANGING reguards of
what the decider that is deciding does, as is the behavior of the H
that it is built on.
That was FIXED and made UNCHANGING when it was defined.
Thus, the question does THIS H^(H^) halt? HAS a definite and fixed
answer. SO you LIE when you said it doesn't.
Your problem seems to be that you think "Get the Right Answer?" is a
valid program instruction, or that H can somehow "change" itself
after H^ gets defined. IT CAN'T.
YOU persistently ignore this fact, likely because you are too stupid
and ignorant to understand that fundamental nature of programs, that
they will do what their programming says they will do, and that
programming doesn't change, EVER, with out the creation of some NEW
program that is different from its predicesor.
YOU *NEVER* have the right to change the question for a problem.
You can try to point out the the problem is inconsistant, and
propose a NEW PROBLEM, but that doesn't change the old.
You can talk about your new problem that you think is more useful
than the actual Halting Problem, after all, someone might be more
interested in the incorrect opinion of an admittedly faulty
"Olcott-Halt Decider" than the actual behavior of the Computation
they are interested in.
NOT.
What you can't to is say you are working on one problem, while
trying to change it to mean something different. That is just call
LYING, and you seem to know that you doing it (you might feel you
have justified reasons to talk about a different problem) so the lie
is DELIBERATE.
That you or others consider this somehow improper does not change >>>>>>> the verified fact that they both correctly determine whether or
not they must abort their simulation.
Which isn't the Halting Question, which you claim you are working
on, so you are just LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
So, you think you can change the question and still be talking about
the same question.
You ARE the LIAR PARADOX.
It is also the case that both H1(D,D) and H(D,D) are a pure function >>>>>>> of their inputs when we construe their own machine address to be an >>>>>>> element of these inputs.
Which means they are not computing the Halting Function, which
isn't a function of the decider, so again, you are LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
Yes, you have ADMITTED that you are LYING about working on the
Halting Problem.
And breaks much of the background of Turing Machines,
And it isn't a Halt Decider even in Olcott machines as the
Turing machines don't even have the idea of their own machine >>>>>>>>> address so this exact same thing cannot be Turing computable. >>>>>>>>
algorithm is shown to vary by a parameter that it isn't allowed >>>>>>>> to vary to be a Halt Decider.
Olcott machines entirely anchored in Turing machine notions
can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than
conventional UTM's combined with Conventional Turing machine >>>>>>>>> descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional
space delimited Turing Machine input followed by four spaces. >>>>>>>>>
This is followed by the machine description of the machine
that the UTM is simulating followed by four more spaces.
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to
determine that they have been called with copies of their
own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does
not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs
when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in
mechanics, the H^ that needs to be generated will be a bit
different.
That Olcott machines always know their own TMD is unconventional. >>>>>>
Not at all. Not in the least little bit.
Olcott machines are 100% fully specified
in terms of Turing machines.
Yes, BUT if you talk about an Olcott machine, you MUST include the
added data as part of the description of that machine, or you are
just LYING.
so if you what to use ANY establish property of Turing Machine,
you must include that now extra data EXPLICITLY.
It is already explicitly included in the definition of an Olcott
machine.
Which means that you can't actually write an Olcott-Machine that
matches the requirements for a Halt Decider.
A Halt Decider MUST be able to defined as taking JUST the
description of the Computation to be decided (the Allgorithm and the
Data). In general this also holds, to be a Foo decider, the decider
must be give JUST the information about the thing that we are
deciding Foo on.
If Olcott machines that are essentially Turing machines configured in
a certain way can detect when they themselves are called in recursive
simulation then this reconfiguration defines a new machine that can
compute every function that a TM can and more.
Except that by having information that the ordinary Turing Machine
can't have, you have lost the assurance that it can't use information
that it shouldn't have.
This is merely conventions. When a slight reconfiguration of Turing
machines defines a new machine that computes every function that Turing machines compute and more then Church-Turing seems to be refuted.
The Linz machines really need to correctly determine whether or not
they have been called in recursive simulation. Olcott machines can do
that.
Since the mapping function for no practial problem actually will
depend on the decider that is deciding it, NO Olcott-Machine meets
the basic definition to be any of those deciders.
Olcott machines are always able to detect when they themselves
are called in recursive simulation. Since Turing machines cannot
possibly do that then Olcott machine are more powerful.
Nope. Since there "caller" can lie to them they can not know if THEY
have been "called" recursively.
Unless a machine intentionally breaks this feature it remains available. Making breaking changes to a machine doesn't change computability.
If they are doing a simulation, they MIGHT be able to detect that they
are simulation that exact descritption of them, but it is trivial to
make the description different, so they can't tell.
This is outside of the scope of refuting Linz.
I do not have enough time left to waste on unnecessary digression.
For instance, your OH never sees that the H^ that it is simulating has
a copy of it inside it, because the description changed by being
converted to a sub-machine, and that copy can't tell that it is
simulating a copy of the machine it is in becausse H^ told it that it
was a top level machine that was just H.
There is no such conversation to sub machine.
You just don't understand what is happening and tried to define thing
the way you wanted, but haven't actually acheived it.
You are forced to have the machine take an extra parameter that you
then need to constrain that the machine can not actually depend on it. >>>>
That their own TMD is correctly construed as an additional input >>>>>>> to their computation (whenever they don't ignore it) does provide >>>>>>> the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
But not the RIGHT computation.
Not the same computation that conventional wisdom expects.
SO not the compution DEFINED for the problem.
Remember, the problem STARTS with the mapping function, which
defines what the decider is allowed to have as inputs, and what
answer each value of those inputs should generate.
By simply defining a reconfiguration of a Turing machine
Olcott machines can compute when they themselves are
called in recursive simulation. H1 and H need to do that.
Nope.
How does H detect that the machine it is simulating is has a copy of
it in it?
Finally paying attention.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> performs a string comparison of its first param:⟨Ĥ⟩ with
its last param:<Ĥ> when they match Ĥ.H knows that it is about to
simulate itself.
Right answer to the wrong question is still a WRONG ANSWER.
The right answer to a different question that can always
be construed as the right answer to the original question
by H ⟨Ĥ⟩ ⟨Ĥ⟩ is the right answer.
NOPE, more LIES.
If H(H^,H^) returns non-halting, then H^.H(H^,H^) will ALSO return
non-halting, and H^ will halt, meaning H was wrong, and you are LYING. >>>>
*No matter how many times I tell you that there is a third*
*input you always immediately forget this right when I tell you*
This one performs string compare on its first param:⟨Ĥ⟩ withĤ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // must abort input
its last param:<Ĥ> proving that it *WILL* simulate itself.
This one performs string compare on its first param:⟨Ĥ⟩ with its last param:<H> proving that *WILL NOT* simulate itself.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // input halts
With all of these extra frills, aren't you working outside the premise
of the halting problem? Like how Andre pointed out.
The halting problem concerns itself with turing machines and what you
propose is not a turing machine.
On 3/7/24 6:16 PM, immibis wrote:
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute different
results and still be computations.
It's also the reason why you approach is fundamentally flawed.
Putting aside the question of whether your proposal is workable (or
even sane), if your 'Olcott Machines' automatically supply the
machines they emulate with a copy of their own machine descriptions,
then you are no longer working on the halting problem.
The halting problem asks, is it possible to construct a TM X that,
given a description of a second TM Y and an input string Z *and*
*only* *that* *input* *to* *work* *with*, is it possible for X to
determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a description
X, can X determine whether Y applied to Z halts, is an *entirely*
different question.
The answer to these two questions may well be entirely different, and
the answer to the second question tells us absolutely nothing about
the answer to the first, which is the only thing the halting problem
is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine which
does need its own description can be modified to include the
description it needs (which won't be "its own" description any more,
but it's impossible that it would need to be). Olcott is just grasping
at straws to explain why obvious facts are false.
The problem is that a Turing Machine doesn't have *A* description, but
an infinte number of them. It can assume one of them, but that is
worthless for trying to find a copy of itself in the input, because it
has no idea which of the infinte variations that will be.
On 3/8/2024 1:50 AM, Richard Damon wrote:
On 3/7/24 11:21 PM, olcott wrote:
On 3/8/2024 12:49 AM, Richard Damon wrote:
On 3/7/24 10:09 PM, olcott wrote:
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) and
H(D,D)
because Olcott machines can correctly determine whether or not they >>>>>>> themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and
00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
All you have done is show why your H / H1 have been disqualified
from being Halt Deciders.
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines
defines a machine that is exactly a Turing machine except can
always correctly determine whether or not itself is called in
recursive simulation.
Nope.
You tried, but failed.
All that you have done is disagree with verified facts.
You always said that H1(D,D) and H(D,D) cannot compute different
outputs. I proved exactly how they do this and how it is computable
and you simply ignore what I say.
They can't if they are copies of the same computation.
Exact copies of the same machine with different inputs can and
do compute different results. I really should not have to bring
this up again and again all day long for you to notice that
I said it at least once.
You are just proving that they aren't, as either they use a "Hidden
Input" in your x86UTM claiming to be Turing Equivalent model, or they
now have a different input in the Olcott-Machine model.
When H1 and H both have access to their own machine address this is
equivalent to H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ>
Right, so they are getting different inputs, so they can create
different outputs,
Yes.
but that also means they are not Halt Deciders, as they are USING that
extra data that Halt Deciders can't use (at least an be a CORRECT Halt
Decider).
They are using extra inputs that Turing machines cannot use.
Thus my proof does not show that halting is Turing computable.
Instead my proof shows that Church-Turing is not true.
Olcott machines compute everything that Turing Machines compute
and have the extra ability to correctly detect that they themselves
are about to simulate themselves in recursive simulation.
You are just showing how little you understand of the field and the
meaning of its words.
You have not correctly pointed out even a single mistake.
Your H and H1 likely will never answer when given the properly
designed H^ input.
You are just a total failure, again.
And are just lying about it because you refuse to face the facts.
They are not Computations using only the description of the
Computation to be decided on.
This PROVES that they are not correct Halt Deciders.
And you are proved to be just a pathetic and pathological liar.
On 3/8/2024 1:40 AM, Richard Damon wrote:
On 3/7/24 11:07 PM, olcott wrote:
On 3/8/2024 12:34 AM, Richard Damon wrote:
On 3/7/24 10:00 PM, olcott wrote:
On 3/7/2024 9:28 PM, Richard Damon wrote:
On 3/7/24 4:00 PM, olcott wrote:
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:Which isn't the halting question, so you are LYING.
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 to >>>>>>>>>>> its output.And thus you are admitting that Neither H or H1 are actually >>>>>>>>>> correct Halt Deciders, as Halt Deciders must be only a
H(D,D) maps its input + its own machine address 00001522 to >>>>>>>>>>> its output.
Thus both H1 and H are computable functions of their input. >>>>>>>>>>
function of the description of the Compuation to be decided. >>>>>>>>>>
It turns out that both H(D,D) and H1(D,D) do correctly determine >>>>>>>>> whether or not they must abort the simulation of their input. >>>>>>>>
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded
within these inputs have no answer at all.
In other words you argue by lying.
The QUESTION is, and always will be, does the computation
described by the input Halt when run.
The Computation so described is FIXED and UNCHANGING reguards of
what the decider that is deciding does, as is the behavior of the
H that it is built on.
That was FIXED and made UNCHANGING when it was defined.
Thus, the question does THIS H^(H^) halt? HAS a definite and fixed >>>>>> answer. SO you LIE when you said it doesn't.
Your problem seems to be that you think "Get the Right Answer?" is >>>>>> a valid program instruction, or that H can somehow "change" itself >>>>>> after H^ gets defined. IT CAN'T.
YOU persistently ignore this fact, likely because you are too
stupid and ignorant to understand that fundamental nature of
programs, that they will do what their programming says they will
do, and that programming doesn't change, EVER, with out the
creation of some NEW program that is different from its predicesor. >>>>>>
YOU *NEVER* have the right to change the question for a problem.
You can try to point out the the problem is inconsistant, and
propose a NEW PROBLEM, but that doesn't change the old.
You can talk about your new problem that you think is more useful
than the actual Halting Problem, after all, someone might be more
interested in the incorrect opinion of an admittedly faulty
"Olcott-Halt Decider" than the actual behavior of the Computation
they are interested in.
NOT.
What you can't to is say you are working on one problem, while
trying to change it to mean something different. That is just call >>>>>> LYING, and you seem to know that you doing it (you might feel you
have justified reasons to talk about a different problem) so the
lie is DELIBERATE.
That you or others consider this somehow improper does not change >>>>>>>>> the verified fact that they both correctly determine whether or >>>>>>>>> not they must abort their simulation.
Which isn't the Halting Question, which you claim you are
working on, so you are just LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
So, you think you can change the question and still be talking
about the same question.
You ARE the LIAR PARADOX.
It is also the case that both H1(D,D) and H(D,D) are a pure
function
of their inputs when we construe their own machine address to >>>>>>>>> be an
element of these inputs.
Which means they are not computing the Halting Function, which >>>>>>>> isn't a function of the decider, so again, you are LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
Yes, you have ADMITTED that you are LYING about working on the
Halting Problem.
And breaks much of the background of Turing Machines,
And it isn't a Halt Decider even in Olcott machines as the >>>>>>>>>> algorithm is shown to vary by a parameter that it isn't
Turing machines don't even have the idea of their own machine >>>>>>>>>>> address so this exact same thing cannot be Turing computable. >>>>>>>>>>
allowed to vary to be a Halt Decider.
Olcott machines entirely anchored in Turing machine notions >>>>>>>>>>> can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than >>>>>>>>>>> conventional UTM's combined with Conventional Turing machine >>>>>>>>>>> descriptions their essence is already fully understood.
The input to Olcott machines can simply be the conventional >>>>>>>>>>> space delimited Turing Machine input followed by four spaces. >>>>>>>>>>>
This is followed by the machine description of the machine >>>>>>>>>>> that the UTM is simulating followed by four more spaces. >>>>>>>>>>>
When this input is ignored Olcott machines compute the
exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to >>>>>>>>>>> determine that they have been called with copies of their >>>>>>>>>>> own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does
not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs >>>>>>>>>>> when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in
mechanics, the H^ that needs to be generated will be a bit >>>>>>>>>> different.
That Olcott machines always know their own TMD is unconventional. >>>>>>>>
Not at all. Not in the least little bit.
Olcott machines are 100% fully specified
in terms of Turing machines.
Yes, BUT if you talk about an Olcott machine, you MUST include the >>>>>> added data as part of the description of that machine, or you are
just LYING.
so if you what to use ANY establish property of Turing Machine, >>>>>>>> you must include that now extra data EXPLICITLY.
It is already explicitly included in the definition of an Olcott >>>>>>> machine.
Which means that you can't actually write an Olcott-Machine that
matches the requirements for a Halt Decider.
A Halt Decider MUST be able to defined as taking JUST the
description of the Computation to be decided (the Allgorithm and
the Data). In general this also holds, to be a Foo decider, the
decider must be give JUST the information about the thing that we
are deciding Foo on.
If Olcott machines that are essentially Turing machines configured in >>>>> a certain way can detect when they themselves are called in recursive >>>>> simulation then this reconfiguration defines a new machine that can
compute every function that a TM can and more.
Except that by having information that the ordinary Turing Machine
can't have, you have lost the assurance that it can't use
information that it shouldn't have.
This is merely conventions. When a slight reconfiguration of Turing
machines defines a new machine that computes every function that Turing
machines compute and more then Church-Turing seems to be refuted.
No, it is DEFINITON.
So, show a mapping that Olcott Machines can compute that a Turing
Machine can not.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Olcott machines have an ability that Turing machines do not
have they can correctly determine that they have been called
in recursive simulation thus giving them the same ability
that H(D,D) and H1(D,D) has.
*Criterion Measure*
H is assumed to be a simulating termination analyzer that aborts the simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.
A halt decider must compute halting indirectly otherwise
Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has no basis for any answer at all.
Both Linz Ĥ.H and Linz H have their basis when computed
as Olcott machines. When they compute haltiong indirect
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy
The Linz machines really need to correctly determine whether or not
they have been called in recursive simulation. Olcott machines can do
that.
Nope. Proven otherwise.
The Recursion doesn't matter, and you Olcotts machines can't reliably
detect it.
If you claim otherwise, show how H can detect that H^ contains a copy
of it, or how the H at H^.Hq0 (H^) (H^) <H> [NOT <H^>] can tell that
it is simulating an input that it is part of.
Or, explain why H^ can get to that state.
*I cannot allow divergence from Linz until we get closure on Linz*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> Does a string comparison between its first parameter
and its last parameter proving that it is about to simulate itself.
Since the mapping function for no practial problem actually will
depend on the decider that is deciding it, NO Olcott-Machine meets >>>>>> the basic definition to be any of those deciders.
Olcott machines are always able to detect when they themselves
are called in recursive simulation. Since Turing machines cannot
possibly do that then Olcott machine are more powerful.
Nope. Since there "caller" can lie to them they can not know if THEY
have been "called" recursively.
Unless a machine intentionally breaks this feature it remains available. >>> Making breaking changes to a machine doesn't change computability.
So, how does H compute halting when H^ is intentionally messing up H's
plan to detect the recusion.
H^ is ALLOWED to be antagonistic and intentionally "breaking" things.
You don't get to tell the opponent they can't run trick plays. It
isn't the Pro Bowl.
*I cannot allow divergence from Linz until we get closure on Linz*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> Does a string comparison between its first parameter
and its last parameter proving that it is about to simulate itself.
If they are doing a simulation, they MIGHT be able to detect that
they are simulation that exact descritption of them, but it is
trivial to make the description different, so they can't tell.
This is outside of the scope of refuting Linz.
I do not have enough time left to waste on unnecessary digression.
Nope, if you want to refute Linz, you need to actual PROVE what you
claim.
Linz does not include the scope that you are trying to expand.
I wasted 15 years of allowing Ben Bacarisse the {change the subject} rebuttal. Your question must be address, yet not now.
You are just proving you have nothing and are trying to get out of the
game.
THis proves you were just a liar.
For instance, your OH never sees that the H^ that it is simulating
has a copy of it inside it, because the description changed by being
converted to a sub-machine, and that copy can't tell that it is
simulating a copy of the machine it is in becausse H^ told it that
it was a top level machine that was just H.
There is no such conversation to sub machine.
Do you mean "converted"?
Note, "Sub-machine" is a term to understand functionality. It breaks
down the functionality of the full machine into manageable parts.
Yes, nothing in the machine itself indicates what is or is not a
sub-machine.
That is the part that immibis did not seem to understand.
But by KNOWING (by defining) a piece as a sub-machine, we can
mathematically handle that sub-piece from the desciption of the
machine that was embedded there.
But, I suppose you don't understand any of that which is why it takes
you so long to do anything.
You just don't understand what is happening and tried to define
thing the way you wanted, but haven't actually acheived it.
You are forced to have the machine take an extra parameter that
you then need to constrain that the machine can not actually
depend on it.
That their own TMD is correctly construed as an additional input >>>>>>>>> to their computation (whenever they don't ignore it) does provide >>>>>>>>> the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
But not the RIGHT computation.
Not the same computation that conventional wisdom expects.
SO not the compution DEFINED for the problem.
Remember, the problem STARTS with the mapping function, which
defines what the decider is allowed to have as inputs, and what
answer each value of those inputs should generate.
By simply defining a reconfiguration of a Turing machine
Olcott machines can compute when they themselves are
called in recursive simulation. H1 and H need to do that.
Nope.
How does H detect that the machine it is simulating is has a copy of
it in it?
Finally paying attention.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> performs a string comparison of its first param:⟨Ĥ⟩ with
its last param:<Ĥ> when they match Ĥ.H knows that it is about to
simulate itself.
Except that its last parameter was <H> not <H^>
I cannot afford the [change the subject] rebuttal that Ben Bacarisse
used to waste 15 years. Your question is relevant yet not at this
point in time.
*Once three people agree that this is correct then we can move on*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy
Can't you read?
Or, are you just still trying to Lie by ignoring the truth.
Just shows how stupid you are.
This one performs string compare on its first param:⟨Ĥ⟩ with
Right answer to the wrong question is still a WRONG ANSWER.
The right answer to a different question that can always
be construed as the right answer to the original question
by H ⟨Ĥ⟩ ⟨Ĥ⟩ is the right answer.
NOPE, more LIES.
If H(H^,H^) returns non-halting, then H^.H(H^,H^) will ALSO return >>>>>> non-halting, and H^ will halt, meaning H was wrong, and you are
LYING.
*No matter how many times I tell you that there is a third*
*input you always immediately forget this right when I tell you*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // must abort input
its last param:<Ĥ> proving that it *WILL* simulate itself.
But it last parameter is actually <H>
You are just lying with your strawmen again.
This one performs string compare on its first param:⟨Ĥ⟩ with its last >>> param:<H> proving that *WILL NOT* simulate itself.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // input halts
Yes, so, you agree that H doesn't know that H^ includes a copy of
itself in it.
Thus H will never stop its simulation.
Olcott machines merely give Turinng machines the same
ability to detect that they were called in recursive
simulation that H(D,D) and H1(D,D) has.
And when we fix your lie about what H^.H gets, ie (H^) (H^) <H>
we see that H can't tell this either, so will just continue simulating.
So we get the never abort case, and nobody answers.
If your only answer to the problem is to lie, I guess you are
conceeding that this path is just broken too.
And all you are it the pathetic ignorant pathological lyint idiot you
have shown yourself to be.
You know how I performed on the Mensa test (in the top 3%)
so you know that I am no idiot. You have not been able to
even show that what I say is false so you have no basis to
say that what I say is intentionally false.
That you believe that I am incorrect yet cannot even show
this is no rebuttal what-so-ever.
I have finally addressed how H(D,D) and H1(D,D) are able to
get their differing results thus addressing your very long
standing rebuttal.
I have also showed all of the details of how slightly adapted
Turing machines can do this same thing.
*That you ignore my correct rebuttals is no actual rebuttal at all*
On 3/8/2024 10:11 AM, immibis wrote:
On 8/03/24 04:31, Richard Damon wrote:
On 3/7/24 6:16 PM, immibis wrote:
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional.
That their own TMD is correctly construed as an additional input
to their computation (whenever they don't ignore it) does provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
It's also the reason why you approach is fundamentally flawed.
Putting aside the question of whether your proposal is workable (or
even sane), if your 'Olcott Machines' automatically supply the
machines they emulate with a copy of their own machine
descriptions, then you are no longer working on the halting problem. >>>>>
The halting problem asks, is it possible to construct a TM X that,
given a description of a second TM Y and an input string Z *and*
*only* *that* *input* *to* *work* *with*, is it possible for X to
determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a
description of a second TM Y, and input string Z, *and* a
description X, can X determine whether Y applied to Z halts, is an
*entirely* different question.
The answer to these two questions may well be entirely different,
and the answer to the second question tells us absolutely nothing
about the answer to the first, which is the only thing the halting
problem is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine which
does need its own description can be modified to include the
description it needs (which won't be "its own" description any more,
but it's impossible that it would need to be). Olcott is just
grasping at straws to explain why obvious facts are false.
The problem is that a Turing Machine doesn't have *A* description,
but an infinte number of them. It can assume one of them, but that is
worthless for trying to find a copy of itself in the input, because
it has no idea which of the infinte variations that will be.
that isn't the problem
The problem does not exist. A specific Turing Machine has a machine description that could be thought of as a unique string of integers.
It is not the compete set of all Turing Machine descriptions.
On 3/8/2024 11:47 AM, Richard Damon wrote:
On 3/8/24 9:33 AM, olcott wrote:
On 3/8/2024 1:50 AM, Richard Damon wrote:
On 3/7/24 11:21 PM, olcott wrote:
On 3/8/2024 12:49 AM, Richard Damon wrote:
On 3/7/24 10:09 PM, olcott wrote:
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) and >>>>>>>>> H(D,D)
because Olcott machines can correctly determine whether or not >>>>>>>>> they
themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and >>>>>>>>> 00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
All you have done is show why your H / H1 have been disqualified >>>>>>>> from being Halt Deciders.
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines
defines a machine that is exactly a Turing machine except can
always correctly determine whether or not itself is called in
recursive simulation.
Nope.
You tried, but failed.
All that you have done is disagree with verified facts.
You always said that H1(D,D) and H(D,D) cannot compute different
outputs. I proved exactly how they do this and how it is computable
and you simply ignore what I say.
They can't if they are copies of the same computation.
Exact copies of the same machine with different inputs can and
do compute different results. I really should not have to bring
this up again and again all day long for you to notice that
I said it at least once.
Yes, but they are given the same input, at least when yo follow the
rules an not use a strawwman.
The DEFINITION of H^ is that it uses an exact copy of the algorithm it
is refuting, and gives it the exact same input that it would have when
deciding on it.
The fact that you just rotely parrot the H^ for Turing Mchines when
you try to apply it to Olcott-Machine just says you don't understand
Linz's proof.
You are just proving that they aren't, as either they use a "Hidden
Input" in your x86UTM claiming to be Turing Equivalent model, or
they now have a different input in the Olcott-Machine model.
Right, so they are getting different inputs, so they can create
When H1 and H both have access to their own machine address this is
equivalent to H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> >>>>
different outputs,
Yes.
So H1 doesn't show that the algorithm of H gave the right answer.
but that also means they are not Halt Deciders, as they are USING
that extra data that Halt Deciders can't use (at least an be a
CORRECT Halt Decider).
They are using extra inputs that Turing machines cannot use.
Thus my proof does not show that halting is Turing computable.
Instead my proof shows that Church-Turing is not true.
Not "Can't", but weren't given.
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
You are just proving yourself to be an idiot.
My Mensa test showed I am in the top 3%.
Remember, the defition of a Computation includes ALL the inputs given,
so your Olcott machines are not doing the same computation as the
Turing Machines, and the Turing Machines COULD do that same
computation if given the extra data.
That is correct except:
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
All you have done is LIMIT what Olcott machines can be shown to
compute, and to claim they do the same computation as the Turing
Machine they appear to be, you have to first proe they don't use that
extra information.
Olcott machines (by definition) compute all of the functions
that Turing machines compute and have the extra ability to
always detect when they are about to simulate themselves in
recursive simulation.
Your whole problem is you don't understand what a "Compuation" is.
I consistently proved otherwise and you have not correctly
pointed out a single error.
Even H(D,D) really does prove that from its own POV its input
specifies a non-halting computation. So I never made a mistake
on that either. What I said about that is merely unconventional
it is not incorrect.
Olcott machines compute everything that Turing Machines compute
and have the extra ability to correctly detect that they themselves
are about to simulate themselves in recursive simulation.
Nope.
I have proven this and you provided no evidence to the contrary.
The above reply is exactly what I mean by you using dogma instead
of reasoning.
None-the-less when you do pay attention to a key detail
this does provide a good basis for me to debug my words.
It is not that my words were incorrect, they were simply
too difficult to understand.
You are just showing how little you understand of the field and the
meaning of its words.
You have not correctly pointed out even a single mistake.
Sure I have, you are just to stupid to understand, because you don't
know what you are talking about.
All of the "mistakes" that you pointed out have been false
assumptions that are based on your lack of attention to
the details of what I am saying.
Your H and H1 likely will never answer when given the properly
designed H^ input.
You are just a total failure, again.
And are just lying about it because you refuse to face the facts.
They are not Computations using only the description of the
Computation to be decided on.
This PROVES that they are not correct Halt Deciders.
And you are proved to be just a pathetic and pathological liar. >>>>>>>
On 3/8/2024 11:56 AM, Richard Damon wrote:
On 3/8/24 9:13 AM, olcott wrote:
On 3/8/2024 1:40 AM, Richard Damon wrote:
On 3/7/24 11:07 PM, olcott wrote:
On 3/8/2024 12:34 AM, Richard Damon wrote:
On 3/7/24 10:00 PM, olcott wrote:
On 3/7/2024 9:28 PM, Richard Damon wrote:
On 3/7/24 4:00 PM, olcott wrote:
On 3/7/2024 5:18 PM, Richard Damon wrote:
On 3/7/24 3:02 PM, olcott wrote:
On 3/7/2024 4:32 PM, Richard Damon wrote:Which isn't the halting question, so you are LYING.
On 3/7/24 1:05 PM, olcott wrote:
H1(D,D) maps its input + its own machine address 00001422 >>>>>>>>>>>>> to its output.And thus you are admitting that Neither H or H1 are actually >>>>>>>>>>>> correct Halt Deciders, as Halt Deciders must be only a >>>>>>>>>>>> function of the description of the Compuation to be decided. >>>>>>>>>>>>
H(D,D) maps its input + its own machine address 00001522 >>>>>>>>>>>>> to its output.
Thus both H1 and H are computable functions of their input. >>>>>>>>>>>>
It turns out that both H(D,D) and H1(D,D) do correctly determine >>>>>>>>>>> whether or not they must abort the simulation of their input. >>>>>>>>>>
As I completely explained yet you persistently ignore the
halting question can only be correctly answered indirectly
otherwise inputs that contradict the decider that is embedded >>>>>>>>> within these inputs have no answer at all.
In other words you argue by lying.
The QUESTION is, and always will be, does the computation
described by the input Halt when run.
The Computation so described is FIXED and UNCHANGING reguards of >>>>>>>> what the decider that is deciding does, as is the behavior of
the H that it is built on.
That was FIXED and made UNCHANGING when it was defined.
Thus, the question does THIS H^(H^) halt? HAS a definite and
fixed answer. SO you LIE when you said it doesn't.
Your problem seems to be that you think "Get the Right Answer?" >>>>>>>> is a valid program instruction, or that H can somehow "change" >>>>>>>> itself after H^ gets defined. IT CAN'T.
YOU persistently ignore this fact, likely because you are too
stupid and ignorant to understand that fundamental nature of
programs, that they will do what their programming says they
will do, and that programming doesn't change, EVER, with out the >>>>>>>> creation of some NEW program that is different from its predicesor. >>>>>>>>
YOU *NEVER* have the right to change the question for a problem. >>>>>>>>
You can try to point out the the problem is inconsistant, and
propose a NEW PROBLEM, but that doesn't change the old.
You can talk about your new problem that you think is more
useful than the actual Halting Problem, after all, someone might >>>>>>>> be more interested in the incorrect opinion of an admittedly
faulty "Olcott-Halt Decider" than the actual behavior of the
Computation they are interested in.
NOT.
What you can't to is say you are working on one problem, while >>>>>>>> trying to change it to mean something different. That is just
call LYING, and you seem to know that you doing it (you might
feel you have justified reasons to talk about a different
problem) so the lie is DELIBERATE.
That you or others consider this somehow improper does not >>>>>>>>>>> change
the verified fact that they both correctly determine whether or >>>>>>>>>>> not they must abort their simulation.
Which isn't the Halting Question, which you claim you are
working on, so you are just LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
So, you think you can change the question and still be talking >>>>>>>> about the same question.
You ARE the LIAR PARADOX.
It is also the case that both H1(D,D) and H(D,D) are a pure >>>>>>>>>>> function
of their inputs when we construe their own machine address to >>>>>>>>>>> be an
element of these inputs.
Which means they are not computing the Halting Function, which >>>>>>>>>> isn't a function of the decider, so again, you are LYING.
Already fully explained many many times (including above)
yet your ignorance is very persistent.
Yes, you have ADMITTED that you are LYING about working on the >>>>>>>> Halting Problem.
And it isn't a Halt Decider even in Olcott machines as the >>>>>>>>>>>> algorithm is shown to vary by a parameter that it isn't >>>>>>>>>>>> allowed to vary to be a Halt Decider.
Turing machines don't even have the idea of their own machine >>>>>>>>>>>>> address so this exact same thing cannot be Turing computable. >>>>>>>>>>>>
Olcott machines entirely anchored in Turing machine notions >>>>>>>>>>>>> can compute the equivalent of H1(D,D) and H(D,D).
Because Olcott machines are essentially nothing more than >>>>>>>>>>>>> conventional UTM's combined with Conventional Turing machine >>>>>>>>>>>>> descriptions their essence is already fully understood. >>>>>>>>>>>>>
The input to Olcott machines can simply be the conventional >>>>>>>>>>>>> space delimited Turing Machine input followed by four spaces. >>>>>>>>>>>>>
This is followed by the machine description of the machine >>>>>>>>>>>>> that the UTM is simulating followed by four more spaces. >>>>>>>>>>>>>
When this input is ignored Olcott machines compute the >>>>>>>>>>>>> exact same set as Turing machines.
Unlike Turing machines, Olcott machines have the basis to >>>>>>>>>>>>> determine that they have been called with copies of their >>>>>>>>>>>>> own TMD.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩
does not halt
With Olcott machines Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> do
not have the same inputs thus can compute different outputs >>>>>>>>>>>>> when they do not ignore their own TMD.
THen you build H^ wrong. Of course with your change in >>>>>>>>>>>> mechanics, the H^ that needs to be generated will be a bit >>>>>>>>>>>> different.
That Olcott machines always know their own TMD is
unconventional.
And breaks much of the background of Turing Machines,
Not at all. Not in the least little bit.
Olcott machines are 100% fully specified
in terms of Turing machines.
Yes, BUT if you talk about an Olcott machine, you MUST include >>>>>>>> the added data as part of the description of that machine, or
you are just LYING.
so if you what to use ANY establish property of Turing
Machine, you must include that now extra data EXPLICITLY.
It is already explicitly included in the definition of an
Olcott machine.
Which means that you can't actually write an Olcott-Machine that >>>>>>>> matches the requirements for a Halt Decider.
A Halt Decider MUST be able to defined as taking JUST the
description of the Computation to be decided (the Allgorithm and >>>>>>>> the Data). In general this also holds, to be a Foo decider, the >>>>>>>> decider must be give JUST the information about the thing that >>>>>>>> we are deciding Foo on.
If Olcott machines that are essentially Turing machines
configured in
a certain way can detect when they themselves are called in
recursive
simulation then this reconfiguration defines a new machine that can >>>>>>> compute every function that a TM can and more.
Except that by having information that the ordinary Turing Machine >>>>>> can't have, you have lost the assurance that it can't use
information that it shouldn't have.
This is merely conventions. When a slight reconfiguration of Turing
machines defines a new machine that computes every function that
Turing
machines compute and more then Church-Turing seems to be refuted.
No, it is DEFINITON.
So, show a mapping that Olcott Machines can compute that a Turing
Machine can not.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Olcott machines have an ability that Turing machines do not
have they can correctly determine that they have been called
in recursive simulation thus giving them the same ability
that H(D,D) and H1(D,D) has.
*Criterion Measure*
H is assumed to be a simulating termination analyzer that aborts the
simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.
A halt decider must compute halting indirectly otherwise
Linz Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has no basis for any answer at all.
Both Linz Ĥ.H and Linz H have their basis when computed
as Olcott machines. When they compute haltiong indirect
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy
The Linz machines really need to correctly determine whether or not
they have been called in recursive simulation. Olcott machines can do >>>>> that.
Nope. Proven otherwise.
The Recursion doesn't matter, and you Olcotts machines can't
reliably detect it.
If you claim otherwise, show how H can detect that H^ contains a
copy of it, or how the H at H^.Hq0 (H^) (H^) <H> [NOT <H^>] can tell
that it is simulating an input that it is part of.
Or, explain why H^ can get to that state.
*I cannot allow divergence from Linz until we get closure on Linz*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> Does a string comparison between its first parameter
and its last parameter proving that it is about to simulate itself.
Since the mapping function for no practial problem actually will >>>>>>>> depend on the decider that is deciding it, NO Olcott-Machine
meets the basic definition to be any of those deciders.
Olcott machines are always able to detect when they themselves
are called in recursive simulation. Since Turing machines cannot >>>>>>> possibly do that then Olcott machine are more powerful.
Nope. Since there "caller" can lie to them they can not know if
THEY have been "called" recursively.
Unless a machine intentionally breaks this feature it remains
available.
Making breaking changes to a machine doesn't change computability.
So, how does H compute halting when H^ is intentionally messing up
H's plan to detect the recusion.
H^ is ALLOWED to be antagonistic and intentionally "breaking" things.
You don't get to tell the opponent they can't run trick plays. It
isn't the Pro Bowl.
*I cannot allow divergence from Linz until we get closure on Linz*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> Does a string comparison between its first parameter
and its last parameter proving that it is about to simulate itself.
If they are doing a simulation, they MIGHT be able to detect that
they are simulation that exact descritption of them, but it is
trivial to make the description different, so they can't tell.
This is outside of the scope of refuting Linz.
I do not have enough time left to waste on unnecessary digression.
Nope, if you want to refute Linz, you need to actual PROVE what you
claim.
Linz does not include the scope that you are trying to expand.
I wasted 15 years of allowing Ben Bacarisse the {change the subject}
rebuttal. Your question must be address, yet not now.
You are just proving you have nothing and are trying to get out of
the game.
THis proves you were just a liar.
For instance, your OH never sees that the H^ that it is simulating >>>>>> has a copy of it inside it, because the description changed by
being converted to a sub-machine, and that copy can't tell that it >>>>>> is simulating a copy of the machine it is in becausse H^ told it
that it was a top level machine that was just H.
There is no such conversation to sub machine.
Do you mean "converted"?
Note, "Sub-machine" is a term to understand functionality. It breaks
down the functionality of the full machine into manageable parts.
Yes, nothing in the machine itself indicates what is or is not a
sub-machine.
That is the part that immibis did not seem to understand.
But by KNOWING (by defining) a piece as a sub-machine, we can
mathematically handle that sub-piece from the desciption of the
machine that was embedded there.
But, I suppose you don't understand any of that which is why it
takes you so long to do anything.
You just don't understand what is happening and tried to define
thing the way you wanted, but haven't actually acheived it.
You are forced to have the machine take an extra parameter that >>>>>>>> you then need to constrain that the machine can not actually
depend on it.
That their own TMD is correctly construed as an additional input >>>>>>>>>>> to their computation (whenever they don't ignore it) does >>>>>>>>>>> provide
the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
But not the RIGHT computation.
Not the same computation that conventional wisdom expects.
SO not the compution DEFINED for the problem.
Remember, the problem STARTS with the mapping function, which
defines what the decider is allowed to have as inputs, and what >>>>>>>> answer each value of those inputs should generate.
By simply defining a reconfiguration of a Turing machine
Olcott machines can compute when they themselves are
called in recursive simulation. H1 and H need to do that.
Nope.
How does H detect that the machine it is simulating is has a copy
of it in it?
Finally paying attention.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not
halt
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> performs a string comparison of its first param:⟨Ĥ⟩
with
its last param:<Ĥ> when they match Ĥ.H knows that it is about to
simulate itself.
Except that its last parameter was <H> not <H^>
I cannot afford the [change the subject] rebuttal that Ben Bacarisse
used to waste 15 years. Your question is relevant yet not at this
point in time.
*Once three people agree that this is correct then we can move on*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy
Can't you read?
Or, are you just still trying to Lie by ignoring the truth.
Just shows how stupid you are.
This one performs string compare on its first param:⟨Ĥ⟩ with
Right answer to the wrong question is still a WRONG ANSWER. >>>>>>>>>>
The right answer to a different question that can always
be construed as the right answer to the original question
by H ⟨Ĥ⟩ ⟨Ĥ⟩ is the right answer.
NOPE, more LIES.
If H(H^,H^) returns non-halting, then H^.H(H^,H^) will ALSO
return non-halting, and H^ will halt, meaning H was wrong, and >>>>>>>> you are LYING.
*No matter how many times I tell you that there is a third*
*input you always immediately forget this right when I tell you* >>>>>>>
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // must abort input
its last param:<Ĥ> proving that it *WILL* simulate itself.
But it last parameter is actually <H>
You are just lying with your strawmen again.
This one performs string compare on its first param:⟨Ĥ⟩ with its lastH ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // input halts
param:<H> proving that *WILL NOT* simulate itself.
Yes, so, you agree that H doesn't know that H^ includes a copy of
itself in it.
Thus H will never stop its simulation.
Olcott machines merely give Turinng machines the same
ability to detect that they were called in recursive
simulation that H(D,D) and H1(D,D) has.
Nope. They need an extra input that you could give to a Turing
Machine, thus the do no extra COMPUTATION.
Turing machines seem to leave a loophole open where
halting is uncomputable for some TM/input pairs.
If the Linz H was a Turing machine that implemented
the Olcott protocol this H could not detect that
itself is not called in recursive simulation.
This seems to make Olcott machines strictly more
powerful than Turing machines.
Also, the input doesn't help them.
I have proven that it does help them very many times.
That you keep ignoring what I said is no kind of
actual rebuttal at all.
Olcott machine termination analyzers always perform
a string comparison of their first param with their
last param.
This tells them whether or not their input is having
them simulate an exact copy of themselves in recursive
simulation.
Your H can't tell that D has a copy of it in it
H does determine this by its Olcott machine extra parameter
of its own machine address. I have told you this same idea
many many times. Everyone here knows that simply ignoring
what I said forms no actual rebuttal what-so-ever.
And the H in D can't tell it is looking at a copy of itself as D tell
it that it is the same H as above, so it doesn't know either.
And when we fix your lie about what H^.H gets, ie (H^) (H^) <H>
we see that H can't tell this either, so will just continue simulating. >>>>
So we get the never abort case, and nobody answers.
If your only answer to the problem is to lie, I guess you are
conceeding that this path is just broken too.
And all you are it the pathetic ignorant pathological lyint idiot
you have shown yourself to be.
You know how I performed on the Mensa test (in the top 3%)
so you know that I am no idiot. You have not been able to
even show that what I say is false so you have no basis to
say that what I say is intentionally false.
Can you PROVE your statement?
I have proven that most of your rebuttals simply ignore
what I said. My college grades prove that my IQ claim
is reasonably plausible.
The fact that you repeat know false statements and refuse to beleive
facts makes you an IDIOT.
I have not made any false statements they only seem that
way when you ignore what I said and merely speculate on
the truth of what I said on the basis of ignoring what
I actually said.
That you believe that I am incorrect yet cannot even show
this is no rebuttal what-so-ever.
The fact that virtually every time I comment, I provide a rebuttal to
your statements, referencing fundamental definitions shows that you
are just a pathological liar.
Not at all. I say that Olcott machines have a certain
ability and you use the strawman deception to say that
I am wrong Turing machines do not have that ability.
You may not recognise them as rebuttal, as you are ignorant of the
meaning of the words, so my statements SEEM "meaningless" to you, but
they are fully disproving your claims.
I recognize your strawman deceptions even if you don't.
I have finally addressed how H(D,D) and H1(D,D) are able to
get their differing results thus addressing your very long
standing rebuttal.
Right, by showing that youy have been LYING that they were the same
computation.
Thus, you have agreed that you arguement was invalid.
I never claimed that they are the same computation.
I only claimed that identical machines can and do get
different results. This claim was not fully coherent
until I noticed that H(D,D) and H1(D,D) essentially
have the Olcott machine extra input.
The x86 execution traces did prove that by knowing their
own machine address that H(D,D) and H1(D,D) did correctly
get different results.
When you said this was impossible your were always incorrect.
What you mean by "impossible" was never {totally impossible}
at all. It was merely not Turing computable.
I have also showed all of the details of how slightly adapted
Turing machines can do this same thing.
Nope.
Olcott machine termination analyzers always perform a string
comparison of their first param with their last param.
This enables them to know that they are about to simulate
an exact copy of themselves in recursive simulation.
Do I have to repeat that fifty times for you to notice
that I said it at least once?
You haven't even tried to answer my rebuttals, so you must be
admitting that this is just another of your ignorant lie.
All of your "rebuttals" are either the strawman deception,
pure dogma when your say "nope" or simply ignoring what I
already said.
One very important key exception to this is your insistence
that I explain exactly how H(D,D) and H1(D,D) can possibly
get different results.
I did explain this many times and in several ways but my only
fully satisfactory explanation is that they use the Olcott
machine protocol thus have an extra input.
*That you ignore my correct rebuttals is no actual rebuttal at all*
That you ignore MY correct rebuttal show that your rebuttal are just
lies.
WHen you TRY to rebut my statements, you just repeat the error that
was pointed out, You can not go more basic, because that just exposes
your lies more.
You are just proving that you are just a pathetic ignorant
pathological lying idiot.
On 3/7/2024 10:12 PM, Richard Damon wrote:
On 3/7/24 7:49 PM, olcott wrote:
On 3/7/2024 9:36 PM, Richard Damon wrote:
On 3/7/24 7:10 PM, olcott wrote:
On 3/7/2024 8:16 PM, immibis wrote:
On 8/03/24 03:06, André G. Isaak wrote:
On 2024-03-07 16:02, olcott wrote:
That Olcott machines always know their own TMD is unconventional. >>>>>>>>
That their own TMD is correctly construed as an additional input >>>>>>>> to their computation (whenever they don't ignore it) does provide >>>>>>>> the reason why Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> can compute
different
results and still be computations.
It's also the reason why you approach is fundamentally flawed.
Putting aside the question of whether your proposal is workable
(or even sane), if your 'Olcott Machines' automatically supply
the machines they emulate with a copy of their own machine
descriptions, then you are no longer working on the halting problem. >>>>>>>
The halting problem asks, is it possible to construct a TM X
that, given a description of a second TM Y and an input string Z >>>>>>> *and* *only* *that* *input* *to* *work* *with*, is it possible
for X to determine whether Y applied to Z halts.
Asking whether it is possible to construct a TM X which, given a >>>>>>> description of a second TM Y, and input string Z, *and* a
description X, can X determine whether Y applied to Z halts, is
an *entirely* different question.
The answer to these two questions may well be entirely different, >>>>>>> and the answer to the second question tells us absolutely nothing >>>>>>> about the answer to the first, which is the only thing the
halting problem is concerned with.
André
It turns out that they are the same answer, since a machine which
doesn't need its own description can ignore it, and a machine
which does need its own description can be modified to include the >>>>>> description it needs (which won't be "its own" description any
more, but it's impossible that it would need to be). Olcott is
just grasping at straws to explain why obvious facts are false.
It is possible for Ĥ to screw itself up and write an English poem
to the place where its own TMD is supposed to be. It is impossible
for Ĥ to write <H> to this location because it has no access or
knowledge of the existence of any separate <H>.
OF COURSE it has knowledge of the ONE SPECIAL H that it was written
to confound, so can have a (the) description of it.
Why wouldn't it.
You wouldn't send out an assissin without giving it complete
information about its target.
Once Olcott Machines get a description of themselves added, then H^
will be defined to confound just a particular description of H, but
one can be defined to confound ANY of the description of H, so we
can prove that ALL are confounded, just as the proof generalizes
from the specific H that this H^ was built on to any and all
machines that might be consider as a Halt Decider.
No Ĥ can possibly be defined to confound any H besides the one
that is embedded within it because Turing machines do not call
external functions.
Right, so whatever machine you want to claim to be an actual Halt
Decider, can have a input built from IT via the tempate, and it will
be confounded, and thus show NOT to be an actual Halt Decider.
Not when we understand that no Turing machine can actually
call any external Turing machine.
What ever machine you want to try to claim to be a Halt Decider has an
Achilles heal in the input machine built from it.
Thus, NO machine can ever be a correct Halt Decider for ALL inputs.
PERIOD.
Halting Theorem proven.
PERIOD.
Remember, claimed decider exists first, then confounder created to
prove it wrong.
In this game, second to move wins.
Not when we understand that no Turing machine can actually
call any external Turing machine.
On 3/8/2024 1:05 PM, Richard Damon wrote:
On 3/8/24 10:08 AM, olcott wrote:
On 3/8/2024 11:47 AM, Richard Damon wrote:
On 3/8/24 9:33 AM, olcott wrote:
On 3/8/2024 1:50 AM, Richard Damon wrote:
On 3/7/24 11:21 PM, olcott wrote:
On 3/8/2024 12:49 AM, Richard Damon wrote:
On 3/7/24 10:09 PM, olcott wrote:
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) >>>>>>>>>>> and H(D,D)All you have done is show why your H / H1 have been
because Olcott machines can correctly determine whether or >>>>>>>>>>> not they
themselves were called in recursive simulation.
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and >>>>>>>>>>> 00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are
shown.
When I keep repeating the above a few hundred more times >>>>>>>>>>> you will quit immediately forgetting that I ever said it. >>>>>>>>>>
disqualified from being Halt Deciders.
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines >>>>>>>>> defines a machine that is exactly a Turing machine except can >>>>>>>>> always correctly determine whether or not itself is called in >>>>>>>>> recursive simulation.
Nope.
You tried, but failed.
All that you have done is disagree with verified facts.
You always said that H1(D,D) and H(D,D) cannot compute different >>>>>>> outputs. I proved exactly how they do this and how it is computable >>>>>>> and you simply ignore what I say.
They can't if they are copies of the same computation.
Exact copies of the same machine with different inputs can and
do compute different results. I really should not have to bring
this up again and again all day long for you to notice that
I said it at least once.
Yes, but they are given the same input, at least when yo follow the
rules an not use a strawwman.
The DEFINITION of H^ is that it uses an exact copy of the algorithm
it is refuting, and gives it the exact same input that it would have
when deciding on it.
The fact that you just rotely parrot the H^ for Turing Mchines when
you try to apply it to Olcott-Machine just says you don't understand
Linz's proof.
You are just proving that they aren't, as either they use a
"Hidden Input" in your x86UTM claiming to be Turing Equivalent
model, or they now have a different input in the Olcott-Machine
model.
When H1 and H both have access to their own machine address this >>>>>>> is equivalent to H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ>
Right, so they are getting different inputs, so they can create
different outputs,
Yes.
So H1 doesn't show that the algorithm of H gave the right answer.
but that also means they are not Halt Deciders, as they are USING
that extra data that Halt Deciders can't use (at least an be a
CORRECT Halt Decider).
They are using extra inputs that Turing machines cannot use.
Thus my proof does not show that halting is Turing computable.
Instead my proof shows that Church-Turing is not true.
Not "Can't", but weren't given.
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
And thus can not be actually asked objective questions, but only a
subjective variation.
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.
You then need to PROVE that the subjective answer is in fact,
0objective. (Which you admit it isn't for Halt Deciders).
You are just proving yourself to be an idiot.
My Mensa test showed I am in the top 3%.
So, you made yourself stupid after that.
Remember, the defition of a Computation includes ALL the inputs
given, so your Olcott machines are not doing the same computation as
the Turing Machines, and the Turing Machines COULD do that same
computation if given the extra data.
That is correct except:
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
Nope.
All you have done is LIMIT what Olcott machines can be shown to
compute, and to claim they do the same computation as the Turing
Machine they appear to be, you have to first proe they don't use
that extra information.
Olcott machines (by definition) compute all of the functions
that Turing machines compute and have the extra ability to
always detect when they are about to simulate themselves in
recursive simulation.
Nope.
Olcott Machine can not be defined in a way that the machine MUST be
computing an Objective question, as it ALWAYS gets an "I" parameter.
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.
Thus, we can not on the face presume that an Olcott machine is doing
an objective function, but need to verify that it is infact not using
that extra input.
The key point of Turing Machines, and what makes them useful, is that
you KNOW, just from that fact that the algorithm has been expressed as
a Turing Machine, that the algorithm is a function of EXACTLY the
parameters given.
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.
You are just proving you utter ignorance of how the field of
Computation Theory works, or even what the core definitions are.
Your whole problem is you don't understand what a "Compuation" is.
I consistently proved otherwise and you have not correctly
pointed out a single error.
Nope.
Even H(D,D) really does prove that from its own POV its input
specifies a non-halting computation. So I never made a mistake
on that either. What I said about that is merely unconventional
it is not incorrect.
Nope. "Own Point of view" is based on the Strawman question, so a LIE.
MIT Professor Michael Sipser agreed that this verbatim paragraph is correct (a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
A simulating termination analyzer must determine when its input
would cause itself to never halt. When Turing machines cannot
do that and the Olcott reconfiguration of Turing machines can
then Olcott machines are more powerful than Turing machines.
The ONLY critera is does the computation represented by the input halt.
H(D,D) says No, but D(D) Halts, so H is wrong.
You saying it was "right" just shows you are a LIAR, in fact you are a
pathetic hypocritical pathological lying idiot.
Olcott machines compute everything that Turing Machines compute
and have the extra ability to correctly detect that they themselves
are about to simulate themselves in recursive simulation.
Nope.
I have proven this and you provided no evidence to the contrary.
The above reply is exactly what I mean by you using dogma instead
of reasoning.
So, show an ACTUAL COMPUTATION that an Olcott Machine can compute that
we can not make a Turing Machine do the same thing.
We cannot make the Turing Machine Linz H have the ability to
see whether or not it is about to simulate a copy of itself.
The Turing Machine Linz H can provide this ability to its
slaves. The copy of Linz H within Linz Ĥ would not be able
to use an ability that Linz H does not have.
Remember, that Turing Machine that computes the same thing as the
Olcott Machine could just be a UTM that has been modified to move the
description of the Olcott Machine given to it to the end of the
virutal Olcott's machines virtual tape and then running it.
None-the-less when you do pay attention to a key detail
this does provide a good basis for me to debug my words.
It is not that my words were incorrect, they were simply
too difficult to understand.
No they are incorrect.
You are just showing how little you understand of the field and
the meaning of its words.
You have not correctly pointed out even a single mistake.
Sure I have, you are just to stupid to understand, because you don't
know what you are talking about.
All of the "mistakes" that you pointed out have been false
assumptions that are based on your lack of attention to
the details of what I am saying.
Then point out the errors quoting SOURCES that show I am wrong. Not
just restate your INCORRECT ideas with no sources to back them up.
Your rebuttals are based on three things:
(a) Simply saying nope.
(b) Failing to pay attention to what I said.
(c) A strawman deception.
Your problem is you have no real sources backing you up, because you
haven't actually studied the real theory.
Because Olcott machines are fully anchored in a reconfiguration
of Turing machines and the extra ability that they have is derived
from simple string comparison of a pair of params what I have
said is already anchored in real sources.
Your H and H1 likely will never answer when given the properly >>>>>>>> designed H^ input.
You are just a total failure, again.
And are just lying about it because you refuse to face the facts. >>>>>>>>
They are not Computations using only the description of the >>>>>>>>>> Computation to be decided on.
This PROVES that they are not correct Halt Deciders.
And you are proved to be just a pathetic and pathological liar. >>>>>>>>>
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
On 3/8/24 10:58 AM, olcott wrote:
If the Linz H was a Turing machine that implemented
the Olcott protocol this H could not detect that
itself is not called in recursive simulation.
This seems to make Olcott machines strictly more
powerful than Turing machines.
Nope. Has been explained.
You just don't understand what the equivalence actually means, in part because you seem to have a incorrect definition of what a "Computation" is.
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise >>>> of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Another interesting question is whether your machines can solve
their own halting problem.
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise >>>>> of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Yes but this machine itself cannot be an Olcott machine. It may or may
not make a difference that this machine cannot be an Olcott machine.
Another interesting question is whether your machines can solve
their own halting problem.
I don't know the details of this yet I do know that the Linz Ĥ
can only fool itself and not any external H.
On 3/9/2024 10:06 AM, Mike Terry wrote:
On 09/03/2024 09:07, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the
premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Another interesting question is whether your machines can solve
their own halting problem.
Since (with just a little thought)
a) a PO-machine can simulate the running of any TM
b) a TM can simulate the running of any PO-machine
that implies that TMs and PO-machines can compute exactly the same
functions, and so are equally powerful.
Thanks for your review.
Yes I agree with this now.
The only possible caveat is that Turing Machine simulating an
Olcott machine doing this cannot itself be an Olcott machine.
Also it implies PO-machines cannot solve their own halting problem.
*I don't think so*
It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can compute *Criterion Measure* This by itself provides the basis
for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.
*Criterion Measure*
*Determine halt status from simulating halt deciders POV*
H is assumed to be a simulating termination analyzer that aborts the simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.
The above assumes our definition of TM allows a TM to find the last
input symbol on its tape. That's the case with Linz, since a Linz TM
can just search for the first blank character on the tape. The blank
character is not in the input character set.
If a TM has more than one input this will not work so I
extended this protocol to allow multiple inputs and
a final input that can be ignored.
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise >>>> of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Another interesting question is whether your machines can solve
their own halting problem.
On 3/9/2024 10:20 AM, immibis wrote:
On 9/03/24 16:49, olcott wrote:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the
premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what >>>>>>> you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Yes but this machine itself cannot be an Olcott machine. It may or may
not make a difference that this machine cannot be an Olcott machine.
It can, because any Turing machine can be an Olcott machine if it
simply ignores the machine description appended to its tape.
If the Turing machine that is not an Olcott machine can somehow
be fooled because it is not an Olcott machine then Turing machines
are not equivalent to Olcott machines, otherwise they are.
And any Olcott machine can become a Turing machine if you bundle it
together with a UTM that appends the description to the tape.
Yet equivalence might require every Turing machine to become an
Olcott machine and the outermost Turing machine cannot do this.
These show that every function that can be computed with an Olcott
machine can be computed with a Turing machine, and every function that
can be computed with a Turing machine can be computed with an Olcott
machine.
It may be the case that the outermost Turing machine that cannot
be an Olcott machine can be stumped on some input that an Olcott
machine could compute.
If an Olcott machine can compute the Olcott halting function, so can a
Turing machine.
Not necessarily.
Another interesting question is whether your machines can solve
their own halting problem.
I don't know the details of this yet I do know that the Linz Ĥ
can only fool itself and not any external H.
The Linz Ĥ is defined so that it always calculates the same result as H.
Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
these behaviors cannot possibly diverge. Verified facts do supersede
all theories to the contrary.
You tried to subvert this by inventing Olcott machines, but it doesn't
work. Any claim based on the fact that Ĥ calculates a different result
from H is dishonest.
*Verified facts do supersede all theories to the contrary*
On 3/9/2024 10:06 AM, Mike Terry wrote:
On 09/03/2024 09:07, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the
premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Another interesting question is whether your machines can solve
their own halting problem.
Since (with just a little thought)
a) a PO-machine can simulate the running of any TM
b) a TM can simulate the running of any PO-machine
that implies that TMs and PO-machines can compute exactly the same
functions, and so are equally powerful.
Thanks for your review.
Yes I agree with this now.
The only possible caveat is that Turing Machine simulating an
Olcott machine doing this cannot itself be an Olcott machine.
This seems probably moot. I cannot correctly determine that it
<is> moot without a categorically exhaustive complete search.
Also it implies PO-machines cannot solve their own halting problem.
*I don't think so*
It may still be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can compute *Criterion Measure* This by itself provides the basis
for a Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly transition to H.qy.
*Criterion Measure*
*Determine halt status from simulating halt deciders POV*
H is assumed to be a simulating termination analyzer that aborts the simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.
PO will surely be disappointed that he cannot add "refuting the
Turing-Church thesis" to his list of impressive refutations.
(Although PO would probably not follow or agree with this reasoning,
so he will probably add it anyway...)
You provided no reasoning to support your claim and I did provide
reasoning to possibly rebut whatever your reasoning might be.
If TM's can compute *Criterion Measure* then Olcott machines are
not needed.
The above assumes our definition of TM allows a TM to find the last
input symbol on its tape. That's the case with Linz, since a Linz TM
can just search for the first blank character on the tape. The blank
character is not in the input character set.
If a TM has more than one input this will not work so I
extended this protocol to allow multiple inputs and
a final input that can be ignored.
All inputs are followed by a single space. The last conventional
input is followed by four spaces. The TMD of the machine being
simulated is appended after this followed by four spaces. This
enables machines to use or ignore their own TMD.
Mike.
On 3/9/2024 10:20 AM, immibis wrote:
On 9/03/24 16:49, olcott wrote:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the
premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what >>>>>>> you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Yes but this machine itself cannot be an Olcott machine. It may or may
not make a difference that this machine cannot be an Olcott machine.
It can, because any Turing machine can be an Olcott machine if it
simply ignores the machine description appended to its tape.
If the Turing machine that is not an Olcott machine can somehow
be fooled because it is not an Olcott machine then Turing machines
are not equivalent to Olcott machines, otherwise they are.
And any Olcott machine can become a Turing machine if you bundle it
together with a UTM that appends the description to the tape.
Yet equivalence might require every Turing machine to become an
Olcott machine and the outermost Turing machine cannot do this.
These show that every function that can be computed with an Olcott
machine can be computed with a Turing machine, and every function that
can be computed with a Turing machine can be computed with an Olcott
machine.
It may be the case that the outermost Turing machine that cannot
be an Olcott machine can be stumped on some input that an Olcott
machine could compute.
If an Olcott machine can compute the Olcott halting function, so can a
Turing machine.
Not necessarily.
Another interesting question is whether your machines can solve
their own halting problem.
I don't know the details of this yet I do know that the Linz Ĥ
can only fool itself and not any external H.
The Linz Ĥ is defined so that it always calculates the same result as H.
Yet we can see that it is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort
its simulation and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort its simulation and in theory
these behaviors cannot possibly diverge. Verified facts do supersede
all theories to the contrary.
On 3/9/2024 10:45 AM, immibis wrote:
Any Turing Machine can be converted to an Olcott Machine if it just
deletes the extra input at the beginning before it does whatever it does.
Wrong you are doing the conversion backwards.
That is how you convert an Olcott machine into a Turing machine.
NO is the wrong answer for that input because that input does halt.
Your halt decider accidentally aborts inputs that do terminate or it
accidentally does not abort inputs that do not terminate. It is
impossible for a simulating halt decider to not make at least one of
these mistakes (possibly both).
It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input and verified facts supersede all theories to the contrary.
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise >>>>> of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
On 3/10/2024 7:25 AM, Mikko wrote:
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the
premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what >>>>>>> you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine.
On 3/10/2024 7:25 AM, Mikko wrote:
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise >>>>>>> of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine.
On 3/11/2024 4:51 AM, Mikko wrote:
On 2024-03-10 14:29:20 +0000, olcott said:
On 3/10/2024 7:25 AM, Mikko wrote:
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and what you >>>>>>>>> propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine.
That is not "ecept", that is containted in what the word "Truring machine" >> means.
Anway, a Truing machine can, with a simulation of your machine, compute
everything your machine can, so your machine cannot compute anyting a
Turing machine cannot.
Turing Machines, Olcott Machines, RASP machines and my C functions
can always correctly report on the behavior of their actual input
When they report on this question:
Will you halt if you never abort your simulation?
On 3/11/2024 4:51 AM, Mikko wrote:
On 2024-03-10 14:29:20 +0000, olcott said:
On 3/10/2024 7:25 AM, Mikko wrote:
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside the >>>>>>>>> premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and >>>>>>>>> what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and proofs >>>>>>>> for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the
end of its own tape.
An important question to answer is whether a Turing machine can
simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end
of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine.
That is not "ecept", that is containted in what the word "Truring
machine"
means.
Anway, a Truing machine can, with a simulation of your machine, compute
everything your machine can, so your machine cannot compute anyting a
Turing machine cannot.
Turing Machines, Olcott Machines, RASP machines and my C functions
can always correctly report on the behavior of their actual input
When they report on this question:
Will you halt if you never abort your simulation?
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
On 3/11/2024 11:51 AM, Richard Damon wrote:
On 3/11/24 7:31 AM, olcott wrote:H1(D,D) and H(D,D) know their own machine address so they can tell
On 3/11/2024 4:51 AM, Mikko wrote:
On 2024-03-10 14:29:20 +0000, olcott said:
On 3/10/2024 7:25 AM, Mikko wrote:
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside >>>>>>>>>>> the premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines and >>>>>>>>>>> what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and >>>>>>>>>> proofs
for other classes of machines.
I am working on the computability of the halting problem
(the exact same TMD / input pairs) by a slightly augmented
notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one >>>>>>>>> extra step that any UTM could perform, append the TMD to the >>>>>>>>> end of its own tape.
An important question to answer is whether a Turing machine can >>>>>>>> simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one
extra step that any UTM could perform, append the TMD to the end >>>>>>> of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine.
That is not "ecept", that is containted in what the word "Truring
machine"
means.
Anway, a Truing machine can, with a simulation of your machine, compute >>>> everything your machine can, so your machine cannot compute anyting a
Turing machine cannot.
Turing Machines, Olcott Machines, RASP machines and my C functions
can always correctly report on the behavior of their actual input
When they report on this question:
Will you halt if you never abort your simulation?
And to see the answer to that question for a machine that DOES abort
its simulation it mean giving that input to a DIFFERENT machine that
just doesn't abort its simulation, which means the input doesn't
change, and if it was using a copy of this machine, it doesn't change,
unless the input somehow breaks the ability of Turing Machines to
actually have a reference in to that says "The decider looking at me",
which H^ doesn't.
this input is looking at me.
Thus when H aborts, it needs to look as something like the simulationAs soon as H1(D,D) or H(D,D) sees that D is calling themselves with
that H1 does to see if it was right to abort, and it is proven wrong.
their same input and there are no conditional branch instructions
inbetween they have their abort criteria.
I don't think so.
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct* >>> (a) If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never stop
running unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
And he is using my definition above.
H1(D,D) and H(D,D) are being asked:
Will you halt if you never abort your simulation?
IF H(<M>,d) can correctly determine that UTM(<M>,d) would not halt,
then it is correct to abort its simulation and return non-halting.
You have to use the definitions that people intended,
I am saying that when we use a different definition that cannot
be self-contradictory then my C functions H1(D,D)==1 and H(D,D)==0
(that know their own machine) address both get the correct answer
for the new definition that cannot be contradicted:
Will you halt if you never abort your simulation?
not what you think they are when you interpret the statements.
Professor Sipser (incorrectly) assumed you knew the conventional
meaning of the words when he wrote his reply.
This is a fundamental problem with you, you don't get to inject your
(inaccurate) meaning into the meanings of what other people say.
On 3/11/2024 6:34 PM, Richard Damon wrote:
On 3/11/24 1:06 PM, olcott wrote:
On 3/11/2024 11:51 AM, Richard Damon wrote:
On 3/11/24 7:31 AM, olcott wrote:H1(D,D) and H(D,D) know their own machine address so they can tell
On 3/11/2024 4:51 AM, Mikko wrote:
On 2024-03-10 14:29:20 +0000, olcott said:
On 3/10/2024 7:25 AM, Mikko wrote:That is not "ecept", that is containted in what the word "Truring
On 2024-03-09 15:49:39 +0000, olcott said:
On 3/9/2024 3:07 AM, Mikko wrote:
On 2024-03-08 16:09:58 +0000, olcott said:
On 3/8/2024 9:29 AM, Mikko wrote:
On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
With all of these extra frills, aren't you working outside >>>>>>>>>>>>> the premise
of the halting problem? Like how Andre pointed out.
Yes, he is.
The halting problem concerns itself with turing machines >>>>>>>>>>>>> and what you
propose is not a turing machine.
That is true. However, we can formulate similar problems and >>>>>>>>>>>> proofs
for other classes of machines.
I am working on the computability of the halting problem >>>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented >>>>>>>>>>> notion of Turing machines as elaborated below:
Olcott machines are entirely comprised of a UTM + TMD and one >>>>>>>>>>> extra step that any UTM could perform, append the TMD to the >>>>>>>>>>> end of its own tape.
An important question to answer is whether a Turing machine can >>>>>>>>>> simulate your machines.
Olcott machines are entirely comprised of a UTM + TMD and one >>>>>>>>> extra step that any UTM could perform, append the TMD to the end >>>>>>>>> of its own tape.
Then a Turing machine can simulate your machine.
Yes, except the TM doing the simulating cannot be an Olcott machine. >>>>>>
machine"
means.
Anway, a Truing machine can, with a simulation of your machine,
compute
everything your machine can, so your machine cannot compute anyting a >>>>>> Turing machine cannot.
Turing Machines, Olcott Machines, RASP machines and my C functions
can always correctly report on the behavior of their actual input
When they report on this question:
Will you halt if you never abort your simulation?
And to see the answer to that question for a machine that DOES abort
its simulation it mean giving that input to a DIFFERENT machine that
just doesn't abort its simulation, which means the input doesn't
change, and if it was using a copy of this machine, it doesn't
change, unless the input somehow breaks the ability of Turing
Machines to actually have a reference in to that says "The decider
looking at me", which H^ doesn't.
this input is looking at me.
Right, but the question isn't do they call me, it is do I NEED to abort.
Do they call me? is one of three abort criteria along with infinite loop
and infinite recursion.
If they DO abort, the NEED has to be tested, but looking at a realWhen H(D,D) determines that D calls itself with its
simulator.
same inputs and there are no conditional branch instructions
between the beginning of D and its call to H(D,D) the
recursive simulation abort criteria has been met.
Of course, this isn't something THEY can do, as if they did, theyYou seem confused here.
would have already done it.
This is the test of "the quality department" that sees if the productIf it was me that didn't understand then you could explain
meets its specifications.
You are just proving your stupidity and utter lack of the
understanding of REQUIREMENTS.
Thus when H aborts, it needs to look as something like theAs soon as H1(D,D) or H(D,D) sees that D is calling themselves with
simulation that H1 does to see if it was right to abort, and it is
proven wrong.
their same input and there are no conditional branch instructions
inbetween they have their abort criteria.
Which gives them the wrong answer. You just don't understand that.
what I am missing. All that you have provided for this is
false assumptions.
Since they DO abort by that condition, that makes the input, whichIt is an easily verified fact that H(D,D) must abort
uses that same algorithm, halting, so THIS COPY didn't need to abort,
but it did anyways since that is what was programmed.
the simulation of its input or fail to terminate.
Since the input doesn't actually "Reference" this copy of the machine,You said that you understand assembly language. Do you
we can imagine changing it without touching the contents of the input,
and when we do that, we see that it would stop without the abort, thus
they didn't NEED to abort, but did.
really understand or were you bluffing?
You just are ignorant of the rules of REQUIREMENTS.
I don't think so.
*MIT Professor Michael Sipser agreed this verbatim paragraph is
correct*
(a) If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never stop
running unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
And he is using my definition above.
H1(D,D) and H(D,D) are being asked:
Will you halt if you never abort your simulation?
Right, but they are what the are, so that is the hypothetical "If I
changed this copy"
Is totally irrelevant because that is verifiably not what is happening.
H1 is as identical to H as it possibly can be within the limitations
of the x86 language.
The only differences that are not a direct result of H1 and H simply
being in different memory locations is that the Output() function's
text that says:
"H: Recursive Simulation Detected Simulation Stopped"
"H1: Recursive Simulation Detected Simulation Stopped"
not "If I changed all copies of me", as that is the meaning inNeither H1 nor H changes the other.
Computation Theory, since the input doesn't REFERENCE the decider, but
just has a copy. We can change this machine for hypotheticals without
changing the input.
The only significant difference between them is that they are at
different memory locations thus and use their own machine address
to compute whether or not they must abort their simulation
IF H(<M>,d) can correctly determine that UTM(<M>,d) would not halt,
then it is correct to abort its simulation and return non-halting.
You have to use the definitions that people intended,
I am saying that when we use a different definition that cannot
be self-contradictory then my C functions H1(D,D)==1 and H(D,D)==0
(that know their own machine) address both get the correct answer
for the new definition that cannot be contradicted:
Will you halt if you never abort your simulation?
In other words, you admit you are lying about doing the Halting Problem.
*I have said that I am using this criteria for years*
How is it that you keep forgetting this?
*Date 10/13/2022 11:29:23 AM*
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
Your version defies determinism and looks at things that are not, inThat the problem has cases where a correct YES/NO answer
otherwords, is a LIE.
Note, the ACTUAL problem doesn't HAVE the SELF-contradictory nature,
the input is only a SPECIFIC desider contradictory, which isn't "itself"
is logically impossible proves that these cases are
incorrect YES/NO questions.
*Logical impossibilities never ever place*
*any actual limit on anyone or anything*
*Logical impossibilities never ever place*
*any actual limit on anyone or anything*
*Logical impossibilities never ever place*
*any actual limit on anyone or anything*
That you always do a switch-a-roo to a less specific
version of the question that ignores who is being asked
does not change the fact that the specific question
that does pay attention to who is being asked is an
incorrect question.
Your changing the input from a specific instance of H^ built on a
specific instance of H is an invalid transformation.
not what you think they are when you interpret the statements.
Professor Sipser (incorrectly) assumed you knew the conventional
meaning of the words when he wrote his reply.
This is a fundamental problem with you, you don't get to inject your
(inaccurate) meaning into the meanings of what other people say.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 300 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 00:29:54 |
| Calls: | 6,706 |
| Calls today: | 6 |
| Files: | 12,235 |
| Messages: | 5,349,761 |