Re: Working out the details of the steps of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn

On 3/8/2024 5:29 PM, Richard Damon wrote:

On 3/8/24 2:37 PM, olcott wrote:

On 3/8/2024 3:57 PM, Richard Damon wrote:

On 3/8/24 1:34 PM, olcott wrote:

On 3/8/2024 2:29 PM, Richard Damon wrote:

On 3/8/24 11:17 AM, olcott wrote:

On 3/8/2024 12:40 PM, Richard Damon wrote:

On 3/8/24 10:11 AM, olcott wrote:

On 3/8/2024 12:00 PM, Richard Damon wrote:

On 3/8/24 7:59 AM, olcott wrote:

On 3/8/2024 5:26 AM, Mikko wrote:

On 2024-03-07 19:49:49 +0000, Dan Cross said:
>

What is it?  The olcott machine is a device that never halts and
generates infinite amounts of nonsense.  As a perpetual motion
device with no discernable input and unbounded output, it is
believed that it violates the laws of thermodynamics.

>
The olcott machine uses a hidden input.
>

>
It is not hidden. The master UTM of Olcott machines simply
appends the TMD to the end of the simulated TMD's tape.
>
Only those machines that need to see if themselves are
called in recursive simulation use this optional input.
>

>
Which means they ADMIT they are doing a different computation then the Turing Machine they are derived from.
>
So, there can not be an Olcott Machine that matches the signature of a Halt Decider.
>
PERIOD
>
And thus, you prove you have created another worthless field.

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

>
Nope.
>
You have PROVED (by your definition of an Olcott Machine) that ANYTHING an Olcott machine can do, there exists a Turing Machine that does the same thing.

There is no conventional Turing machine that can possibly
know that it is about to simulate a copy of itself in
recursive simulation.

>
It can know just as well as your Olcott machines, which apparently can only tell it the recusion is done by that EXACT same machine using the same description
>

>
How it this?
Conventional Turing machines do not generally have access to their
own machine description and generally cannot even know that they
are being provided with their own machine description unless they
are Olcott machines where this is anchored in their fundamental
architecture.

>
But if the mapping includes the description, it can be given to it.

>
I am only going to respond to this one thread
(until I complete my design)
and will stop responding to this one too if you don't provide
very well thought out rebuttals or replies.

 Suit yourself. YOU are the one on a time limit and trying to develope something "useful".

It should not take very long to figure the details steps
of what H ⟨H⟩ ⟨H⟩ <H> would do.

>
If a machine is given its own description unless the fundamental
architecture of the system guarantees that this is its true
description then the machine cannot rely on this being its own
description.

 Right, so copies of a machine embedded in another machine can not get that guarantee, so you idea fails.
 

Not at all. Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> can definitely verify that it is about to
simulate a copy of its own machine description with a copy of its own
machine description.

It is a FUNDAMENTAL property of Turing Machines that you can embed a copy of one machine in another, and provide it with whatever input tape you can compute.
 If you want your new property to apply to such "submachines" you are going to need some careful thought, and understanding how Turing Machine actually work is going to be a requirement.
 

>

>
Anchoring it in the architecture means you now need to PROVE they don't use it if the mapping doesn't have it (like most don't)

>
Not at all as I just explained above.

 Nope.
 If the mapping is Halting( M, d) -> Halt/non-Halt
 but the machine is H (M) d <H>, then if H depends on the final <H> that means that not all copies of H answer correctly, so "H" isn't a halt decider.
 You might be able to say just one representation is the true decider, but the we just need to build H^ to contradict that one, and you now can't do your H / H1 trick, as you were forced to declare that it was H, the one that H^ was built on was the decider.

I think that you may be disingenuous here.
I have gone though the details so many times that you
should know all these details by now.
Or maybe you never understood how this has the side-effect
of correctly deciding halting whenever it is not impossible.
*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.

>

So you have added to your work to prove the behavior of the machine.

>
I don't see how.

 Of course you don't see, because you don't understand the problem.
 If the requirement is to find a Computation of X that computes a mapping of X to Y, and you build a machine M that takes in X and <M> and you show that one of them

As a rebuttal this still makes no sense to me.
*Here <are> the mappings*
// rejects input that prevents Ĥ.H from halting
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
// Accepts input that does not prevent H from halting
// This has the side-effect of correctly deciding its input
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // accepts input input that d

>

>

So, H (H) (H) <H> (if all the H's use the same description can be detected), but not H (H^) (H^) <H> as the description of H at H^.H has different state numbering than H so the description will be different.

>
Olcott machines only need to be able to detect that they themselves
about about to simulate a copy of themselves with their same input.
I am working out all of the details of this so I will be less responsive
to your many posts until I get this worked out.

>
So, the H / H^ pairing doesn't need to be able to do that?

>
Unless a machine can certainly know that it has its own machine
description as guaranteed by the architecture of this system it
cannot rely on this.
>

Right, so copies of a machine embedded in another machine can not get that guarantee, so you idea fails.

The copies of a machine embedded in another machine only
need the TMD of the machine that they are embedded within.

 It is a FUNDAMENTAL property of Turing Machines that you can embed a copy of one machine in another, and provide it with whatever input tape you can compute.
 If you want your new property to apply to such "submachines" you are going to need some careful thought, and understanding how Turing Machine actually work is going to be a requirement.
 

H needs to verify that it is not being called with its own
description. I am working out the details of what happens
when H ⟨H⟩ ⟨H⟩ <H> is invoked.

 That isn't the problem, That H can deterimine that it is being asked to decide itself (but that doesn't imply an infinte recursion)

Currently I don't know the exact steps that it would take.

THe problem is that H^.H (H^) (H^) <H> doesn't detect the recursion, and there is nothing the code in H that can detect this issue.

I am not going to spend any time looking at that until 100%
complete closure on The Linz H and the Linz Ĥ as executed as
Olcott machines is achieved.
*You are failing to stay within the boundaries of the stated scope*
The exact Linz Ĥ executed as an Olcott machine.
I cannot afford to tolerate the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.

>

I thought that was the whole reason for adding it.
>
You just did it wrong.
>

>
It would be best that you carefully study my future posts so that
you don't keep rebutting the same things that I have already fully
addressed. I generally spent a lot of time on your posts carefully
studying the exact words that you said. This is not very fruitful
when you do not do the same.

>
So, you are ok with the fact that H.q0 (H^) (H^) <H> will never return an answer?

>
*You are failing to stay within the boundaries of the stated scope*

 Nope, unless you are admitting to working on a Strawman,
 You CAN'T use Linz's exact template with Olcott machines, as the requirement is that H and H^ are Turing Machines.
 

Olcott machines only operate on Turing Machine descriptions.
Thus would operate on exact elements of the Linz templates.

Thus you get caught in a LIE.
 

>
The exact Linz Ĥ executed as an Olcott machine. Variations of the
exact Linz Ĥ will never be looked at until we have 100% complete
closure on the exact Linz Ĥ executed as an Olcott machine.

 But the Linz H^ template is for Turing Machines and was designed for Turing Machines, and thus becomes a strawman if use exactly on some other type of machine.
 

>
I cannot afford to tolerate the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.

 I.E, if people won't let you waste time doing it wrong, you won't take there help.

Ben was only interested in rebuttal and his change the subject
rebuttal worked for 15 years.

You can spend you time on the strawman, or listen to reason and get yourself on the right track.
 What good is it to look at the machine that isn't the one that would be used in the proof for you "new" machine type.
 

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:

>
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // working out the details of how
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // necessarily correct & details seem self-evident

 And, you might be able to work out that, but there is still the ACTUAL pathological input of
 H^q0 (H^) (H^) <H^> |-> H^.Hqo (H^) (H^) <H> |-> ? that will show you decider is broken.
 

I cannot afford to tolerate the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.
I am not saying that you don't have a possibly valid point.
*I am saying that I cannot tolerate never getting closure on any points*
*I am saying that I cannot tolerate never getting closure on any points*
*I am saying that I cannot tolerate never getting closure on any points*
*I am saying that I cannot tolerate never getting closure on any points*
When we get closure on the current point thenn (then and only then)
we can move on to the next point.
I may not enforce this same thing with others because each
of their replies take only a few minutes to address.
I have spent much more time addressing your posts and will no
longer do that when you insist on never fully incorporating my
rebuttals of your words.
When you simply keep ignoring what I said you prove to be
too disingenuous to spend much time on.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer