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

- Dan C.

On 7/03/24 20:49, Dan Cross wrote:
> 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. Amazing!
>
> - Dan C.
>

He's God, so of course he can violate thermodynamics.

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.

--
Mikko

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.

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

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.

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

We just build a UTM (from a Turing Machine of course) then modify it as
you have defined (to replicate the description of the Olcott machine it
has been given) to the end of the Olcott-machine virtual tape, and then
run it.

Thus ANY Olcott Machine you create, has a Turing Machine Equivalent, and
thus any computation that an Olcott Machine can do, so can a Turing Machine.

You don't seem to understand that basic proof.

It is why RASP machines are Turing Equivalenets, as it has been shown
that we can make a RASP Machine emulator with a Turing Machine (in fact,
YOU only seem to think of them as that implementation).

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.

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

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.

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

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.

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.

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

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

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.

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.

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

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.

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)

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

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

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?

Since it won't detect that H^ is H, and the H^.Hq0 (H^) (H^) <H> won't
detect that it is about to simulate itself.

I guess you are just admitting that you are just a liar that this solves
the problem.

The fact that YOU aren't reading the replies seems evident, as YOU
haven't given thought to the problem pointed out as you don't understand
what the problem is, since you don't actually know how any of this works.

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

So, how are you addressing the actual problems that I have pointed out.

That by your current definition, neither H nor H^.H will abort their
simulation of their input so we end up with an infinitely nested set of
simulations.

Just like how you kept ignoring that H^ could put <H> onto its tape.

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

Nope, not the Linz H^ templete that meets the SEMANTIC requirements of
the template, not the syntax base on them being Turing Machines.

That is just working with a strawman.

Making the "Pathological Program" non-pathological by changing how the
machines run, when there is a proper pathhological version is just a LIE.

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

Nope, not the Linz H^ templete that meets the SEMANTIC requirements of
the template, not the syntax base on them being Turing Machines.

That is just working with a strawman.

Making the "Pathological Program" non-pathological by changing how the
machines run, when there is a proper pathhological version is just a LIE.

>
> Everything else is out-of-scope until the above is accepted by
> three people or the above is completely and finally refuted.

In other words, only your lies matter.

It doesn't matter if your new H can answer the H^ that isn't built right
for the compuation system. That is irrelevent. It needs to handle the
properly pathological program, since it needs to handle ALL inputs.

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

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.

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.

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

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

I don't see how.

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

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.

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

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.

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

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

> Since it won't detect that H^ is H, and the H^.Hq0 (H^) (H^) <H> won't
> detect that it is about to simulate itself.

*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 guess you are just admitting that you are just a liar that this solves
> the problem.
>
> The fact that YOU aren't reading the replies seems evident, as YOU
> haven't given thought to the problem pointed out as you don't understand
> what the problem is, since you don't actually know how any of this works.
>

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

>>
>>> 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.
>
> So, how are you addressing the actual problems that I have pointed out.

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

> That by your current definition, neither H nor H^.H will abort their
> simulation of their input so we end up with an infinitely nested set of
> simulations.

*You are merely failing to pay attention to what I said*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn // working out the details of how
therefore
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ⊢* H.qy // necessarily correct & details seem self-evident

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

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

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

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)

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

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.

On 3/8/24 4:26 PM, olcott wrote:
> 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.

Right, but

H (H) (H) <H> is asking what
H (H) <H> will do which is asking about what
H <H> will do, which is asking about the Halting Property of a
no-description, which will be defined by the fine details of your rules,
but will definitely Halt
So even without doing any aborting, the last machine halts, and thus the
whole chain will reach a final state of qy.

Thus, what it SHOULD do is not abort, finish its simulation and thus
report Halting.

Which sort of goes against your initial plan.

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

Yes, but the issue is that isn't what will happen in the pathological
program, so shouldn't be your focus.

Note, if your decision on processing this doesn't handle the FULL input,
you can easily get the wrong answer, as

H^.H (H^) (H) <H^> will then do

H^.H (H) (H) <H^> which is asking about

H (H) <H> which we looked at above, and the whole chain will end and all
will return halting.

Just matching the machine to itself doesn't mean infinite recursion.

For that you needed the outer most H to see that we got to H^.H with the
same paratmeters it started with, but H can't recognize H^.H, since its
description will have changed due to the state remapping.

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

On 3/8/2024 7:18 PM, Richard Damon wrote:
> On 3/8/24 4:26 PM, olcott wrote:
>> 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.
>
> Right, but
>
> H (H) (H) <H> is asking what
> H (H) <H> will do which is asking about what
> H <H> will do, which is asking about the Halting Property of a
> no-description, which will be defined by the fine details of your rules,
> but will definitely Halt
> So even without doing any aborting, the last machine halts, and thus the
> whole chain will reach a final state of qy.
>
> Thus, what it SHOULD do is not abort, finish its simulation and thus
> report Halting.
>
> Which sort of goes against your initial plan.
>
>>
>>>>
>>>> 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.
>
> Yes, but the issue is that isn't what will happen in the pathological
> program, so shouldn't be your focus.

H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
When we specify how the pathological program will transition to Ĥ.Hqn
then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.

--
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/8/2024 7:18 PM, Richard Damon wrote:
> On 3/8/24 4:26 PM, olcott wrote:
>> 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.
>
> Right, but
>
> H (H) (H) <H> is asking what
> H (H) <H> will do which is asking about what
> H <H> will do, which is asking about the Halting Property of a
> no-description, which will be defined by the fine details of your rules,
> but will definitely Halt
> So even without doing any aborting, the last machine halts, and thus the
> whole chain will reach a final state of qy.
>
> Thus, what it SHOULD do is not abort, finish its simulation and thus
> report Halting.
>
> Which sort of goes against your initial plan.
>
>>
>>>>
>>>> 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.
>
> Yes, but the issue is that isn't what will happen in the pathological
> program, so shouldn't be your focus.
>
> Note, if your decision on processing this doesn't handle the FULL input,
> you can easily get the wrong answer, as
>
> H^.H (H^) (H) <H^> will then do
>
> H^.H (H) (H) <H^> which is asking about
>
> H (H) <H> which we looked at above, and the whole chain will end and all
> will return halting.
>
> Just matching the machine to itself doesn't mean infinite recursion.
>
> For that you needed the outer most H to see that we got to H^.H with the
> same paratmeters it started with, but H can't recognize H^.H, since its
> description will have changed due to the state remapping.
>
>>
>>> 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.
>
> Nope, because what you end up with fails to meet the requirements of a
> DECIDER.
>
> You might have a machine that gets this one question right, but that
> doesn't make it a DECIDER.
>
>>
>> *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.
>
> Which isn't the Halting Question, so you are just lying when you say you
> are working on the Halting Problem.
>
>>
>>>>
>>>>> 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*
>
> Do you even know what a "Mapping" is?

On 3/8/24 5:54 PM, olcott wrote:
> On 3/8/2024 7:18 PM, Richard Damon wrote:
>> On 3/8/24 4:26 PM, olcott wrote:
>>> 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.
>>
>> Right, but
>>
>> H (H) (H) <H> is asking what
>> H (H) <H> will do which is asking about what
>> H <H> will do, which is asking about the Halting Property of a
>> no-description, which will be defined by the fine details of your
>> rules, but will definitely Halt
>> So even without doing any aborting, the last machine halts, and thus
>> the whole chain will reach a final state of qy.
>>
>> Thus, what it SHOULD do is not abort, finish its simulation and thus
>> report Halting.
>>
>> Which sort of goes against your initial plan.
>>
>>>
>>>>>
>>>>> 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.
>>
>> Yes, but the issue is that isn't what will happen in the pathological
>> program, so shouldn't be your focus.
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
> When we specify how the pathological program will transition to Ĥ.Hqn
> then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.
>
>

The problem is that the direct application of the Linz Turing Machine
template doesn't generate the Pathological Olcott-Machine template,
because their execution semantics are diffferent, due to the
modification caused by the master UTM.

The actual Pathological input for Olcot-Machines needs to get to the
state H^.H with (H^) (H^) <H> on the tape, as that is what is needed to
meet the requirement to ask H to decide on this machine exactly like it
would as a top level decider (since that is what the pathology is based on).

This is why I have been pointing out what you probably want to be
working on.

IF you want to work on your version, go ahead, tell me the algorithm you
are going to put in H (which will be the same for H and H^.H) and we can
look at what happens.

On 3/8/24 5:59 PM, olcott wrote:
> On 3/8/2024 7:18 PM, Richard Damon wrote:
>> On 3/8/24 4:26 PM, olcott wrote:
>>> 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.
>>
>> Right, but
>>
>> H (H) (H) <H> is asking what
>> H (H) <H> will do which is asking about what
>> H <H> will do, which is asking about the Halting Property of a
>> no-description, which will be defined by the fine details of your
>> rules, but will definitely Halt
>> So even without doing any aborting, the last machine halts, and thus
>> the whole chain will reach a final state of qy.
>>
>> Thus, what it SHOULD do is not abort, finish its simulation and thus
>> report Halting.
>>
>> Which sort of goes against your initial plan.
>>
>>>
>>>>>
>>>>> 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.
>>
>> Yes, but the issue is that isn't what will happen in the pathological
>> program, so shouldn't be your focus.
>>
>> Note, if your decision on processing this doesn't handle the FULL
>> input, you can easily get the wrong answer, as
>>
>> H^.H (H^) (H) <H^> will then do
>>
>> H^.H (H) (H) <H^> which is asking about
>>
>> H (H) <H> which we looked at above, and the whole chain will end and
>> all will return halting.
>>
>> Just matching the machine to itself doesn't mean infinite recursion.
>>
>> For that you needed the outer most H to see that we got to H^.H with
>> the same paratmeters it started with, but H can't recognize H^.H,
>> since its description will have changed due to the state remapping.
>>
>>>
>>>> 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.
>>
>> Nope, because what you end up with fails to meet the requirements of a
>> DECIDER.
>>
>> You might have a machine that gets this one question right, but that
>> doesn't make it a DECIDER.
>>
>>>
>>> *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.
>>
>> Which isn't the Halting Question, so you are just lying when you say
>> you are working on the Halting Problem.
>>
>>>
>>>>>
>>>>>> 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*
>>
>> Do you even know what a "Mapping" is?
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
> Says that Ĥ.H maps its inputs to its own internal state Ĥ.Hqn
>

On 3/8/2024 8:16 PM, Richard Damon wrote:
> On 3/8/24 5:54 PM, olcott wrote:
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
>> When we specify how the pathological program will transition to Ĥ.Hqn
>> then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.
>>
>>
>
> The problem is that the direct application of the Linz Turing Machine
> template doesn't generate the Pathological Olcott-Machine template,
> because their execution semantics are diffferent, due to the
> modification caused by the master UTM.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> is smarter than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly be.

> The actual Pathological input for Olcot-Machines needs to get to the
> state H^.H with (H^) (H^) <H> on the tape,

That is not how Olcott machines are stipulated to operate.
Ĥ ⟨Ĥ⟩ has <Ĥ> appended to its own tape.
H ⟨Ĥ⟩ ⟨Ĥ⟩ has <H> appended to its own tape.

*You are just ignoring how Olcott machines are specified to work*

--
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/8/2024 8:24 PM, Richard Damon wrote:
> On 3/8/24 5:59 PM, olcott wrote:
>> On 3/8/2024 7:18 PM, Richard Damon wrote:
>>> On 3/8/24 4:26 PM, olcott wrote:
>>>> 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.
>>>
>>> Right, but
>>>
>>> H (H) (H) <H> is asking what
>>> H (H) <H> will do which is asking about what
>>> H <H> will do, which is asking about the Halting Property of a
>>> no-description, which will be defined by the fine details of your
>>> rules, but will definitely Halt
>>> So even without doing any aborting, the last machine halts, and thus
>>> the whole chain will reach a final state of qy.
>>>
>>> Thus, what it SHOULD do is not abort, finish its simulation and thus
>>> report Halting.
>>>
>>> Which sort of goes against your initial plan.
>>>
>>>>
>>>>>>
>>>>>> 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.
>>>
>>> Yes, but the issue is that isn't what will happen in the pathological
>>> program, so shouldn't be your focus.
>>>
>>> Note, if your decision on processing this doesn't handle the FULL
>>> input, you can easily get the wrong answer, as
>>>
>>> H^.H (H^) (H) <H^> will then do
>>>
>>> H^.H (H) (H) <H^> which is asking about
>>>
>>> H (H) <H> which we looked at above, and the whole chain will end and
>>> all will return halting.
>>>
>>> Just matching the machine to itself doesn't mean infinite recursion.
>>>
>>> For that you needed the outer most H to see that we got to H^.H with
>>> the same paratmeters it started with, but H can't recognize H^.H,
>>> since its description will have changed due to the state remapping.
>>>
>>>>
>>>>> 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.
>>>
>>> Nope, because what you end up with fails to meet the requirements of
>>> a DECIDER.
>>>
>>> You might have a machine that gets this one question right, but that
>>> doesn't make it a DECIDER.
>>>
>>>>
>>>> *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.
>>>
>>> Which isn't the Halting Question, so you are just lying when you say
>>> you are working on the Halting Problem.
>>>
>>>>
>>>>>>
>>>>>>> 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*
>>>
>>> Do you even know what a "Mapping" is?
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
>> Says that Ĥ.H maps its inputs to its own internal state Ĥ.Hqn
>>
>
> That is just H^.H computing an instance of the mapping, not the mapping
> itself.

On 3/8/24 6:25 PM, olcott wrote:
> On 3/8/2024 8:16 PM, Richard Damon wrote:
>> On 3/8/24 5:54 PM, olcott wrote:
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
>>> When we specify how the pathological program will transition to Ĥ.Hqn
>>> then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.
>>>
>>>
>>
>> The problem is that the direct application of the Linz Turing Machine
>> template doesn't generate the Pathological Olcott-Machine template,
>> because their execution semantics are diffferent, due to the
>> modification caused by the master UTM.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> is smarter than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly be.

Irreverent.

THe ^ templete has a DEFINITION of the semantics of what it is to do.

Don't follow them, and you are just lying about what you are doing.

>
>> The actual Pathological input for Olcot-Machines needs to get to the
>> state H^.H with (H^) (H^) <H> on the tape,
>
> That is not how Olcott machines are stipulated to operate.
> Ĥ ⟨Ĥ⟩ has <Ĥ> appended to its own tape.
> H ⟨Ĥ⟩ ⟨Ĥ⟩ has <H> appended to its own tape.
>
> *You are just ignoring how Olcott machines are specified to work*
>

And, after H^ starts, it can do whatever it wants to the tape.

Thus, it can get to H^.H with the values (H^) (H^) <H> on it.

If you think not, what is stopping it?

If you want ot change that, you need to change you definitions.

And watch out, that you don't make you system less than Turing Complete.

On 3/8/24 6:34 PM, olcott wrote:
> On 3/8/2024 8:24 PM, Richard Damon wrote:
>> On 3/8/24 5:59 PM, olcott wrote:
>>> On 3/8/2024 7:18 PM, Richard Damon wrote:
>>>> On 3/8/24 4:26 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> Right, but
>>>>
>>>> H (H) (H) <H> is asking what
>>>> H (H) <H> will do which is asking about what
>>>> H <H> will do, which is asking about the Halting Property of a
>>>> no-description, which will be defined by the fine details of your
>>>> rules, but will definitely Halt
>>>> So even without doing any aborting, the last machine halts, and thus
>>>> the whole chain will reach a final state of qy.
>>>>
>>>> Thus, what it SHOULD do is not abort, finish its simulation and thus
>>>> report Halting.
>>>>
>>>> Which sort of goes against your initial plan.
>>>>
>>>>>
>>>>>>>
>>>>>>> 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.
>>>>
>>>> Yes, but the issue is that isn't what will happen in the
>>>> pathological program, so shouldn't be your focus.
>>>>
>>>> Note, if your decision on processing this doesn't handle the FULL
>>>> input, you can easily get the wrong answer, as
>>>>
>>>> H^.H (H^) (H) <H^> will then do
>>>>
>>>> H^.H (H) (H) <H^> which is asking about
>>>>
>>>> H (H) <H> which we looked at above, and the whole chain will end and
>>>> all will return halting.
>>>>
>>>> Just matching the machine to itself doesn't mean infinite recursion.
>>>>
>>>> For that you needed the outer most H to see that we got to H^.H with
>>>> the same paratmeters it started with, but H can't recognize H^.H,
>>>> since its description will have changed due to the state remapping.
>>>>
>>>>>
>>>>>> 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.
>>>>
>>>> Nope, because what you end up with fails to meet the requirements of
>>>> a DECIDER.
>>>>
>>>> You might have a machine that gets this one question right, but that
>>>> doesn't make it a DECIDER.
>>>>
>>>>>
>>>>> *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.
>>>>
>>>> Which isn't the Halting Question, so you are just lying when you say
>>>> you are working on the Halting Problem.
>>>>
>>>>>
>>>>>>>
>>>>>>>> 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*
>>>>
>>>> Do you even know what a "Mapping" is?
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ⊢* Ĥ.Hqn
>>> Says that Ĥ.H maps its inputs to its own internal state Ĥ.Hqn
>>>
>>
>> That is just H^.H computing an instance of the mapping, not the
>> mapping itself.
>
> Yes I forgot the exact words.
> Ĥ.H computes the mapping from its inputs:
> ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to its own final state Ĥ.Hqn

On 3/8/2024 8:47 PM, Richard Damon wrote:
> On 3/8/24 6:25 PM, olcott wrote:
>> On 3/8/2024 8:16 PM, Richard Damon wrote:
>>> On 3/8/24 5:54 PM, olcott wrote:
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
>>>> When we specify how the pathological program will transition to Ĥ.Hqn
>>>> then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.
>>>>
>>>>
>>>
>>> The problem is that the direct application of the Linz Turing Machine
>>> template doesn't generate the Pathological Olcott-Machine template,
>>> because their execution semantics are diffferent, due to the
>>> modification caused by the master UTM.
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> is smarter than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly be.
>
> Irreverent.
>
> THe ^ templete has a DEFINITION of the semantics of what it is to do.
>
> Don't follow them, and you are just lying about what you are doing.

H ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt

I was agreeing with you in that Olcott machines include sequences
specified by their ⊢* that Turing Machines do not have.

>>
>>> The actual Pathological input for Olcot-Machines needs to get to the
>>> state H^.H with (H^) (H^) <H> on the tape,
>>
>> That is not how Olcott machines are stipulated to operate.
>> Ĥ ⟨Ĥ⟩ has <Ĥ> appended to its own tape.
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ has <H> appended to its own tape.
>>
>> *You are just ignoring how Olcott machines are specified to work*
>>
>
> And, after H^ starts, it can do whatever it wants to the tape.
That is off topic for now because:

*I cannot tolerate never getting closure on anything*
*I cannot tolerate never getting closure on anything*
*I cannot tolerate never getting closure on anything*

Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
therefore
H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy

I still don't know the detailed steps of how
H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
YET WE CAN SEE THAT IT IS CORRECT

You still don't understand how the indirect
criteria does compute halting as a side-effect.

--
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/8/2024 9:03 PM, Richard Damon wrote:
> On 3/8/24 6:34 PM, olcott wrote:
>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>> The Mapping describes the answer that we want for ALL possible
>>> inputs. It becomes the specification of the problem.
>>>
>>
>> You still can't understand how computing the mapping
>> from all inputs to final state Ĥ.Hqn or non final state
>> Ĥ.Hqy on the basis of the indirect criteria also causes
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>
>
> Because your "indirect Criteria" map differs from the DEFINED DIRECT
> Criteria map.
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

The indirect criteria provides Ĥ.H the basis for
which wrong answer it must return and provides
H with the basis to return the correct halt status.

So far everyone in world the has no idea what
basis Ĥ.H could use to determine its wrong answer.
*They leave it wide open with a question mark*

When we hypothesize a basis such that H gets
the correct answer and Ĥ.H can provide some
answer then this question mark is resolved.

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