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

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.

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

And since H^ can "lie" to that embedded H^.H about what its description is, that H can't tell that it is part of an H^ computation that is simulating an H^ computation.

That subject must be postponed until after the Olcott refutation
of the exact Linz proof is either fully accepted by three people
or actual errors or gaps are found that cannot be addressed or
corrected.

>
Olcott machines make it impossible for a machine to not
know its own machine description.

 It know *A* version of its machine description, not ALL of them (as that is an infinte amount of data)
 

The Olcott machine Linz H does correctly determine the halt status
of every Olcott machine Linz Ĥ the exactly matches the Linz Ĥ template.

>
When we construct an Olcott machine on the basis of Turing
machines then within this limited environment every machine
has the same ability as an Olcott machine.
>
Outside of this environment the Linz H can implement this
protocol for all of its inputs. It cannot implement this
protocol for itself. This seems to be a key point of failure
for Turing Machines.
>

 But, as shown above, it doesn't actually give the machine any adantage over handling ALL inputs.

The Olcott machine Linz H does correctly determine the halt status
of every Olcott machine Linz Ĥ the exactly matches the Linz Ĥ template.
Everything else is out-of-scope until the above is accepted by
three people or the above is completely and finally refuted.

It might help on a small number, but not all.
 And, since your descripition doesn't check the parameters, it doesn't even reliably detect attempts at INFINITE recursion.

Olcott machines are fully specified. Some of the details of the
exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
abort the simulation of it input to prevent is own infinite
execution must be worked out.
Even this is somewhat moot because we see that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must
abort its simulation.
When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ DOES abort its simulation then that forces
H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy to be correct. Thus the Linz Ĥ ⟨Ĥ⟩ only fools
itself and does not fool H ⟨Ĥ⟩ ⟨Ĥ⟩.

A recursive implementaton of factorial will see fact(n) calling fact(n-1) and think that was infinite recursion, not knowing that the machine handles the 0 input seperately.
 

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