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.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

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

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.

Since H will get on its tape the string (H^) (H^) (H), that is exactly
what H^ (H^) must put on its tape, so since H^ starts its tape with the
values (M) (H^), 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.

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.

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*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

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

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

>
>>>
>>> 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, so if you what to
use ANY establish property of Turing Machine, you must include that now
extra data EXPLICITLY.

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

Right answer to the wrong question is still a WRONG 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, 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,
>
> 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.

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.

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.

You can't (successfully) argue with facts.

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

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

On 7/03/24 22:05, 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.

Yes. Two different computable functions. Any proof based on the fact
they are the same is a lie, because they are actually different.

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

Modify H1 so that instead of checking its own address, it always checks
address 00001522. Then it will always give the same answer as H. Then
Modified_H1 and H are the same computable function, so all the proofs work.

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é

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

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:06 PM, 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.
>

*Thanks for your feedback, I really appreciate it*
All actual feedback helps me to debug my words.

I would phrase that more precisely that I am no longer working
on the computability of the halting problem by Turing 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.

Olcott machines that ignore this extra input compute the exact
same set of functions that Turing machines compute.

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

Sure. When an Olcott machine correctly decides some of the elements
of the TMD/Input pairs that a Turing machine cannot decide then Church-
Turing would refuted.

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

Sure. None-the-less when an Olcott machine computes everything that
a Turing Machine can compute (by definition) and can compute TMD/Input
pairs that a TM cannot compute then Church-Turing would refuted.

> 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é
>

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/7/2024 7:40 PM, immibis wrote:
> On 7/03/24 22:05, 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.
>
> Yes. Two different computable functions. Any proof based on the fact
> they are the same is a lie, because they are actually different.

Great. It takes me a long long time to put my intuitions into words.

>
>> 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.
>
> Modify H1 so that instead of checking its own address, it always checks
> address 00001522. Then it will always give the same answer as H. Then
> Modified_H1 and H are the same computable function, so all the proofs work.
>

Instead of trying to make my own code cease to work correctly
I defined Olcott machines that can compute H1(D,D) and H(D,D)
the same way that mine do.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

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.

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.

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

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

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.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

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.

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.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

- Yax

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?

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/7/2024 10:53 PM, Yaxley Peaks wrote:
> 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.
>
> - Yax

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.

Olcott machines that ignore this extra input compute the exact
same set of functions that Turing machines compute.

Olcott machines can do something that no Turing machine can
possibly do correctly determine that they themselves are called
in recursive simulation

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

Only Olcott machines can correctly determine that they themselves
are called in recursive simulation, Turing machines cannot possibly
do that.

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

On 3/7/24 8:56 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.
>>
>
> Which must be answered incorrectly indirectly otherwise Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> literally has nothing to say.

So you admit to not understand how problem work.

Good to know you admit to being stupid.

The Question has an Answer.

That H can't give it just show that the question might not be COMPUTABLE.

Nothing wrong with uncomputable questions, just that it shows the
limitation of mechanical computation.

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

Nope. For every H^ that you can possible imagine, the question has
either a yes or no answer depending on what the H that H^ was built on
will return from H (H^) (H^) which is fully defined by the algorithm
that H was defined to have.

If H (H^) (H^) goes to qy, then the answer to the question is No.

If H (H^) (H^) goes to qn, then the answer to the question is Yes.

If H (H^) (H^) never halts, then the answer to the question in No.

If H (H^) (H^) halts somewhere else, then the answer to the question is Yes.

So for every consivable H^, built from its defined H, we have an
definite answer. Thus the question is valid.

And you are shown to be a stupid liar.
>
> Thus we ask the question indirectly:

Why?

It had an answer, even if you don't think so, as you are wrong.

On what grounds are you trying this?

The answer is, you are just a pathological LIAR.

You NEVER have the authority to present an alternate question unless you
are admitting to working on an alternate problem (and thus, have no
grounds to comment on the original)

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

But H^.H (H^) (H^) must give the same answer as H (H^) (H^) as it, BY
DEFINITION of construction, is the exact same algorithm given the exact
same input. So, you are LYING that H^.H and H give different answers.

Note, if you are talking about Olcott Machines, then H^, to be the
semantically required program, is a bit different (as it MUST be) so
when it get to H^.H, the tape is (H^) (H^) <H> just as it is when H is
actually started by the Master UTM.

So, you are proven to be LYING.

On 3/7/24 9:18 PM, olcott wrote:
> 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.
>

So, have you forgotten where H^ came from?

Of course it knows that Turing Machine H exists, its whole purpose in
life is to make that particular Decider wrong.

Metaphorically, it has a wanted poster for it in its back pocket, and
the full dossier in its breifcase.

In fact, it has an exact copy of it built into it.

Remember how Linz built H^?

I guess you want to forget that since it gives you problems.

That is why you are nothing but a stupid and ignorant pathological lying
idiot.

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.

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.