Generic halt deciding principle for inputs having the pathological
self-reference error

(a) Halt deciding simulator H only affects the behavior of input P in
one way and only under one condition. In all other cases a halt deciding
simulator H has no effect what-so-ever on the behavior of input P and
acts exactly like pure simulator S on input P.

(b) When an infinite computation is specified as input P to a simulating
halt decider H the halt decider H must stop the simulation of this input
P. When this same input is simulated by simulator S, its simulation
never stops.

(c) When a finite computation is specified as input P to a simulating
halt decider H the halt decider H simulates its input exactly as if H
was simulator S.

Because of the above simulating halt decider H can decide input P having
the pathological self-reference error on the basis of the proxy input P2
having the pathological self-reference error removed.

When input P invokes embedded simulating halt decider H on itself H
creates proxy input P2 replacing H with simulator S. The embedded halt
decider H examines the execution trace of proxy input P2. The embedded
halt decider correctly decides its input P on the basis of how it
decides input P2.

When we apply *the Generic halt deciding principle* to the embedded
simulating halt decider at state Ĥ.qx to its input ([Ĥ],[Ĥ]) we find
that the simulation of this input must be aborted.

Because the necessity to abort the simulation of an input is equated
with this input specifying an infinite computation the simulating halt
decider Ĥ.qx correctly transitions to its final Ĥ.qn state deciding not
halting on its input.

http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/23/21 3:02 PM, olcott wrote:
> Generic halt deciding principle for inputs having the pathological
> self-reference error
>
> (a) Halt deciding simulator H only affects the behavior of input P in
> one way and only under one condition. In all other cases a halt deciding
> simulator H has no effect what-so-ever on the behavior of input P and
> acts exactly like pure simulator S on input P.
>
> (b) When an infinite computation is specified as input P to a simulating
> halt decider H the halt decider H must stop the simulation of this input
> P. When this same input is simulated by simulator S, its simulation
> never stops.
>
> (c) When a finite computation is specified as input P to a simulating
> halt decider H the halt decider H simulates its input exactly as if H
> was simulator S.
>
> Because of the above simulating halt decider H can decide input P having
> the pathological self-reference error on the basis of the proxy input P2
> having the pathological self-reference error removed.

And may I ask HOW does is correctly decide to meet conditions (b) and
(c). To properly make this decision, your Halt Decider needs a Halt
Decider to tell it wha to do.

Since it has been proved that it is impossible to make a 100% accurate
Halt Decider, it is impossible to make a 100% accurate Simulating Halt
Decider.

You are ASSUMING

>
> When input P invokes embedded simulating halt decider H on itself H
> creates proxy input P2 replacing H with simulator S. The embedded halt
> decider H examines the execution trace of proxy input P2. The embedded
> halt decider correctly decides its input P on the basis of how it
> decides input P2.

This step FAILS. Note, Either you re-wrote the whole machine P, at which
point it is no longer machine P, or you applied the transformation
singly, which may be allowable. The problem is that you algorithm now
has to do infinite loop if P uses a simulating Halt Decider to decide on
P. THIS say that the above rule is NOT a finite operation, and thus is
not valid.

Since this says that the answer you get differs from that basic answer
you get by actually running the machiine P(I), we can show that this
transform is NOT valid for the conventional Halting Problem of
Computation Theory.

>
> When we apply *the Generic halt deciding principle* to the embedded
> simulating halt decider at state Ĥ.qx to its input ([Ĥ],[Ĥ]) we find
> that the simulation of this input must be aborted.
>
> Because the necessity to abort the simulation of an input is equated
> with this input specifying an infinite computation the simulating halt
> decider Ĥ.qx correctly transitions to its final Ĥ.qn state deciding not
> halting on its input.
>
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>
>

Face it. H^(H^) IS Halting when H(H^,H^) will say it is non-Halting.
Thus by ANY proper definition it is wrong.

All you have done is hide an infinite loop into your logic, to hide your
falsehood.

Fundamental Truisms:

A computation that Halts, IS a Halting Computation

Wrong Ansswer ARE Wrong Answers

Remember, you can't refute a proof with a counter example. You can only
refute an unproven Theory with a Counter Example.

A Counter Example to a proof is just a sign that either there is a
mistake somewhere or the logic system is inconsistent, the error can
just as easily be in the counter example as the proof.

On 5/23/2021 2:47 PM, Richard Damon wrote:
> On 5/23/21 3:02 PM, olcott wrote:
>> Generic halt deciding principle for inputs having the pathological
>> self-reference error
>>
>> (a) Halt deciding simulator H only affects the behavior of input P in
>> one way and only under one condition. In all other cases a halt deciding
>> simulator H has no effect what-so-ever on the behavior of input P and
>> acts exactly like pure simulator S on input P.
>>
>> (b) When an infinite computation is specified as input P to a simulating
>> halt decider H the halt decider H must stop the simulation of this input
>> P. When this same input is simulated by simulator S, its simulation
>> never stops.
>>
>> (c) When a finite computation is specified as input P to a simulating
>> halt decider H the halt decider H simulates its input exactly as if H
>> was simulator S.
>>
>> Because of the above simulating halt decider H can decide input P having
>> the pathological self-reference error on the basis of the proxy input P2
>> having the pathological self-reference error removed.
>
> And may I ask HOW does is correctly decide to meet conditions (b) and
> (c). To properly make this decision, your Halt Decider needs a Halt
> Decider to tell it wha to do.
>
> Since it has been proved that it is impossible to make a 100% accurate
> Halt Decider, it is impossible to make a 100% accurate Simulating Halt
> Decider.
>
> You are ASSUMING
>
>>
>> When input P invokes embedded simulating halt decider H on itself H
>> creates proxy input P2 replacing H with simulator S. The embedded halt
>> decider H examines the execution trace of proxy input P2. The embedded
>> halt decider correctly decides its input P on the basis of how it
>> decides input P2.
>
> This step FAILS. Note, Either you re-wrote the whole machine P, at which
> point it is no longer machine P, or you applied the transformation
> singly, which may be allowable. The problem is that you algorithm now
> has to do infinite loop if P uses a simulating Halt Decider to decide on
> P. THIS say that the above rule is NOT a finite operation, and thus is
> not valid.
>
> Since this says that the answer you get differs from that basic answer
> you get by actually running the machiine P(I), we can show that this
> transform is NOT valid for the conventional Halting Problem of
> Computation Theory.

We haven't gotten to the point where running the machine is possible.

Before we can possibly run the machine we have to define and validate
the architectural basis for a simulating halt decider that correctly
decides inputs having the pathological self-reference error(Olcott 2004).

https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/23/21 4:33 PM, olcott wrote:
> On 5/23/2021 2:47 PM, Richard Damon wrote:
>> On 5/23/21 3:02 PM, olcott wrote:
>>> Generic halt deciding principle for inputs having the pathological
>>> self-reference error
>>>
>>> (a) Halt deciding simulator H only affects the behavior of input P in
>>> one way and only under one condition. In all other cases a halt deciding
>>> simulator H has no effect what-so-ever on the behavior of input P and
>>> acts exactly like pure simulator S on input P.
>>>
>>> (b) When an infinite computation is specified as input P to a simulating
>>> halt decider H the halt decider H must stop the simulation of this input
>>> P. When this same input is simulated by simulator S, its simulation
>>> never stops.
>>>
>>> (c) When a finite computation is specified as input P to a simulating
>>> halt decider H the halt decider H simulates its input exactly as if H
>>> was simulator S.
>>>
>>> Because of the above simulating halt decider H can decide input P having
>>> the pathological self-reference error on the basis of the proxy input P2
>>> having the pathological self-reference error removed.
>>
>> And may I ask HOW does is correctly decide to meet conditions (b) and
>> (c). To properly make this decision, your Halt Decider needs a Halt
>> Decider to tell it wha to do.
>>
>> Since it has been proved that it is impossible to make a 100% accurate
>> Halt Decider, it is impossible to make a 100% accurate Simulating Halt
>> Decider.
>>
>> You are ASSUMING
>>
>>>
>>> When input P invokes embedded simulating halt decider H on itself H
>>> creates proxy input P2 replacing H with simulator S. The embedded halt
>>> decider H examines the execution trace of proxy input P2. The embedded
>>> halt decider correctly decides its input P on the basis of how it
>>> decides input P2.
>>
>> This step FAILS. Note, Either you re-wrote the whole machine P, at which
>> point it is no longer machine P, or you applied the transformation
>> singly, which may be allowable. The problem is that you algorithm now
>> has to do infinite loop if P uses a simulating Halt Decider to decide on
>> P. THIS say that the above rule is NOT a finite operation, and thus is
>> not valid.
>>
>> Since this says that the answer you get differs from that basic answer
>> you get by actually running the machiine P(I), we can show that this
>> transform is NOT valid for the conventional Halting Problem of
>> Computation Theory.
>
> We haven't gotten to the point where running the machine is possible.

You can't have a machine description until you have an actual machine,
as defined by its state transition table.

PERIOD.

Once you have a machine, in the form of a state transition table, it it
by definition runable. You might not have a program designed to do this,
but once a Turing Machine is specified, it is runable. At worse, a
person can step through it manually.

>
> Before we can possibly run the machine we have to define and validate
> the architectural basis for a simulating halt decider that correctly
> decides inputs having the pathological self-reference error(Olcott 2004).
>
> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>

WRONG. A Turing Machine, once it has been 'described' as a State
Transition Table, is runable. That has ALL the information needed to do so.

Remember, Turing Machines are theoretical constructs, NOT 'physical'
machines. Once 'defined' all there properties, like halting behavior is
fixed (which is one of the flaws of you 'proxie argument')

It is in fact impossible to make a physical machine that can act as a
TRUE Universal Turing Machine runner, as Turing Machines are potentially
unbounded, and the physical universe is bounded.

On 5/23/2021 4:10 PM, Richard Damon wrote:
> On 5/23/21 4:33 PM, olcott wrote:
>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>> On 5/23/21 3:02 PM, olcott wrote:
>>>> Generic halt deciding principle for inputs having the pathological
>>>> self-reference error
>>>>
>>>> (a) Halt deciding simulator H only affects the behavior of input P in
>>>> one way and only under one condition. In all other cases a halt deciding
>>>> simulator H has no effect what-so-ever on the behavior of input P and
>>>> acts exactly like pure simulator S on input P.
>>>>
>>>> (b) When an infinite computation is specified as input P to a simulating
>>>> halt decider H the halt decider H must stop the simulation of this input
>>>> P. When this same input is simulated by simulator S, its simulation
>>>> never stops.
>>>>
>>>> (c) When a finite computation is specified as input P to a simulating
>>>> halt decider H the halt decider H simulates its input exactly as if H
>>>> was simulator S.
>>>>
>>>> Because of the above simulating halt decider H can decide input P having
>>>> the pathological self-reference error on the basis of the proxy input P2
>>>> having the pathological self-reference error removed.
>>>
>>> And may I ask HOW does is correctly decide to meet conditions (b) and
>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>> Decider to tell it wha to do.
>>>
>>> Since it has been proved that it is impossible to make a 100% accurate
>>> Halt Decider, it is impossible to make a 100% accurate Simulating Halt
>>> Decider.
>>>
>>> You are ASSUMING
>>>
>>>>
>>>> When input P invokes embedded simulating halt decider H on itself H
>>>> creates proxy input P2 replacing H with simulator S. The embedded halt
>>>> decider H examines the execution trace of proxy input P2. The embedded
>>>> halt decider correctly decides its input P on the basis of how it
>>>> decides input P2.
>>>
>>> This step FAILS. Note, Either you re-wrote the whole machine P, at which
>>> point it is no longer machine P, or you applied the transformation
>>> singly, which may be allowable. The problem is that you algorithm now
>>> has to do infinite loop if P uses a simulating Halt Decider to decide on
>>> P. THIS say that the above rule is NOT a finite operation, and thus is
>>> not valid.
>>>
>>> Since this says that the answer you get differs from that basic answer
>>> you get by actually running the machiine P(I), we can show that this
>>> transform is NOT valid for the conventional Halting Problem of
>>> Computation Theory.
>>
>> We haven't gotten to the point where running the machine is possible.
>
> You can't have a machine description until you have an actual machine,
> as defined by its state transition table.
>
> PERIOD.
>
> Once you have a machine, in the form of a state transition table, it it
> by definition runable. You might not have a program designed to do this,
> but once a Turing Machine is specified, it is runable. At worse, a
> person can step through it manually.
>
>>
>> Before we can possibly run the machine we have to define and validate
>> the architectural basis for a simulating halt decider that correctly
>> decides inputs having the pathological self-reference error(Olcott 2004).
>>
>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>
>
> WRONG. A Turing Machine, once it has been 'described' as a State
> Transition Table, is runable. That has ALL the information needed to do so.

Yes, however you were running P(I) before it was even defined at the
architectural level of detail:

On 5/23/2021 2:47 PM, Richard Damon wrote:
> Since this says that the answer you get differs from that basic answer
> you get by actually running the machine P(I),

We must proceed through every aspect of the architectural level of
detail long before the details of any set of state transitions can
possibly be inferred.

> Remember, Turing Machines are theoretical constructs, NOT 'physical'
> machines. Once 'defined' all there properties, like halting behavior is
> fixed (which is one of the flaws of you 'proxie argument')
>
> It is in fact impossible to make a physical machine that can act as a
> TRUE Universal Turing Machine runner, as Turing Machines are potentially
> unbounded, and the physical universe is bounded.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/23/21 5:21 PM, olcott wrote:
> On 5/23/2021 4:10 PM, Richard Damon wrote:
>> On 5/23/21 4:33 PM, olcott wrote:
>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>> Generic halt deciding principle for inputs having the pathological
>>>>> self-reference error
>>>>>
>>>>> (a) Halt deciding simulator H only affects the behavior of input P in
>>>>> one way and only under one condition. In all other cases a halt
>>>>> deciding
>>>>> simulator H has no effect what-so-ever on the behavior of input P and
>>>>> acts exactly like pure simulator S on input P.
>>>>>
>>>>> (b) When an infinite computation is specified as input P to a
>>>>> simulating
>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>> input
>>>>> P. When this same input is simulated by simulator S, its simulation
>>>>> never stops.
>>>>>
>>>>> (c) When a finite computation is specified as input P to a simulating
>>>>> halt decider H the halt decider H simulates its input exactly as if H
>>>>> was simulator S.
>>>>>
>>>>> Because of the above simulating halt decider H can decide input P
>>>>> having
>>>>> the pathological self-reference error on the basis of the proxy
>>>>> input P2
>>>>> having the pathological self-reference error removed.
>>>>
>>>> And may I ask HOW does is correctly decide to meet conditions (b) and
>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>> Decider to tell it wha to do.
>>>>
>>>> Since it has been proved that it is impossible to make a 100% accurate
>>>> Halt Decider, it is impossible to make a 100% accurate Simulating Halt
>>>> Decider.
>>>>
>>>> You are ASSUMING
>>>>
>>>>>
>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>> creates proxy input P2 replacing H with simulator S. The embedded halt
>>>>> decider H examines the execution trace of proxy input P2. The embedded
>>>>> halt decider correctly decides its input P on the basis of how it
>>>>> decides input P2.
>>>>
>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>> which
>>>> point it is no longer machine P, or you applied the transformation
>>>> singly, which may be allowable. The problem is that you algorithm now
>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>> decide on
>>>> P. THIS say that the above rule is NOT a finite operation, and thus is
>>>> not valid.
>>>>
>>>> Since this says that the answer you get differs from that basic answer
>>>> you get by actually running the machiine P(I), we can show that this
>>>> transform is NOT valid for the conventional Halting Problem of
>>>> Computation Theory.
>>>
>>> We haven't gotten to the point where running the machine is possible.
>>
>> You can't have a machine description until you have an actual machine,
>> as defined by its state transition table.
>>
>> PERIOD.
>>
>> Once you have a machine, in the form of a state transition table, it it
>> by definition runable. You might not have a program designed to do this,
>> but once a Turing Machine is specified, it is runable. At worse, a
>> person can step through it manually.
>>
>>>
>>> Before we can possibly run the machine we have to define and validate
>>> the architectural basis for a simulating halt decider that correctly
>>> decides inputs having the pathological self-reference error(Olcott
>>> 2004).
>>>
>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>
>>
>> WRONG. A Turing Machine, once it has been 'described' as a State
>> Transition Table, is runable. That has ALL the information needed to
>> do so.
>
> Yes, however you were running P(I) before it was even defined at the
> architectural level of detail:

But then you can't simulate it either.

Note, and you're not going to like this, this is exactly the statements
you DO make about H^, and we KNOW that H^(H^) is a finite halting
computation when we actually run it. You try to force your broken logic
fumblings to have precedence over the actual operation of the machine.

In one sense, you HAVE poisoned this well, and if you want to try to go
over it again, you need to do something to make it very clear that you
aren't just trying to reuse your old disproven logic.

>
> On 5/23/2021 2:47 PM, Richard Damon wrote:
>> Since this says that the answer you get differs from that basic answer
>> you get by actually running the machine P(I),
>
> We must proceed through every aspect of the architectural level of
> detail long before the details of any set of state transitions can
> possibly be inferred.

But that isn't what you SAID you were doing.

You claimed at the end that this now what you are saying is not yet
existent decider, got the right answer. You Whole logic is flawed by
presuming that such a decider is possible to create.

Note, this is different then the Linz proof, which begins with a
hypothetical assumption, but remembers it is under a hypothetical, and
thus possibly not existing case, and then showing that having such an
assumption leads to an impossibility. THAT is a valid logic form.

Assuming something to exist, and then 'proving' that it exists from that
is not.

>
>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>> machines. Once 'defined' all there properties, like halting behavior is
>> fixed (which is one of the flaws of you 'proxie argument')
>>
>> It is in fact impossible to make a physical machine that can act as a
>> TRUE Universal Turing Machine runner, as Turing Machines are potentially
>> unbounded, and the physical universe is bounded.
>>
>
>

In another post you said:

>> When input P invokes embedded simulating halt decider H on itself H creates proxy input P2 replacing H with simulator S. >
> This is the same thing as H simply excluding its own execution from halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);

And I will ask you, why does it make sense to exclude looking at a
significant piece of a Turing Machine to see how it behaves?

Why does the behavior of a DIFFERENT behaving Turing Machine tell you
anything about another machine.

This is like critiquing and 3 hour play after watching the first 3
minutes and then leaving.

On 5/23/2021 9:24 PM, Richard Damon wrote:
> On 5/23/21 5:21 PM, olcott wrote:
>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>> On 5/23/21 4:33 PM, olcott wrote:
>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>> self-reference error
>>>>>>
>>>>>> (a) Halt deciding simulator H only affects the behavior of input P in
>>>>>> one way and only under one condition. In all other cases a halt
>>>>>> deciding
>>>>>> simulator H has no effect what-so-ever on the behavior of input P and
>>>>>> acts exactly like pure simulator S on input P.
>>>>>>
>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>> simulating
>>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>>> input
>>>>>> P. When this same input is simulated by simulator S, its simulation
>>>>>> never stops.
>>>>>>
>>>>>> (c) When a finite computation is specified as input P to a simulating
>>>>>> halt decider H the halt decider H simulates its input exactly as if H
>>>>>> was simulator S.
>>>>>>
>>>>>> Because of the above simulating halt decider H can decide input P
>>>>>> having
>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>> input P2
>>>>>> having the pathological self-reference error removed.
>>>>>
>>>>> And may I ask HOW does is correctly decide to meet conditions (b) and
>>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>>> Decider to tell it wha to do.
>>>>>
>>>>> Since it has been proved that it is impossible to make a 100% accurate
>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating Halt
>>>>> Decider.
>>>>>
>>>>> You are ASSUMING
>>>>>
>>>>>>
>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>> creates proxy input P2 replacing H with simulator S. The embedded halt
>>>>>> decider H examines the execution trace of proxy input P2. The embedded
>>>>>> halt decider correctly decides its input P on the basis of how it
>>>>>> decides input P2.
>>>>>
>>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>>> which
>>>>> point it is no longer machine P, or you applied the transformation
>>>>> singly, which may be allowable. The problem is that you algorithm now
>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>> decide on
>>>>> P. THIS say that the above rule is NOT a finite operation, and thus is
>>>>> not valid.
>>>>>
>>>>> Since this says that the answer you get differs from that basic answer
>>>>> you get by actually running the machiine P(I), we can show that this
>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>> Computation Theory.
>>>>
>>>> We haven't gotten to the point where running the machine is possible.
>>>
>>> You can't have a machine description until you have an actual machine,
>>> as defined by its state transition table.
>>>
>>> PERIOD.
>>>
>>> Once you have a machine, in the form of a state transition table, it it
>>> by definition runable. You might not have a program designed to do this,
>>> but once a Turing Machine is specified, it is runable. At worse, a
>>> person can step through it manually.
>>>
>>>>
>>>> Before we can possibly run the machine we have to define and validate
>>>> the architectural basis for a simulating halt decider that correctly
>>>> decides inputs having the pathological self-reference error(Olcott
>>>> 2004).
>>>>
>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>
>>>
>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>> Transition Table, is runable. That has ALL the information needed to
>>> do so.
>>
>> Yes, however you were running P(I) before it was even defined at the
>> architectural level of detail:
>
> But then you can't simulate it either.
>
> Note, and you're not going to like this, this is exactly the statements
> you DO make about H^, and we KNOW that H^(H^) is a finite halting
> computation when we actually run it. You try to force your broken logic
> fumblings to have precedence over the actual operation of the machine.
>
> In one sense, you HAVE poisoned this well, and if you want to try to go
> over it again, you need to do something to make it very clear that you
> aren't just trying to reuse your old disproven logic.
>
>>
>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>> Since this says that the answer you get differs from that basic answer
>>> you get by actually running the machine P(I),
>>
>> We must proceed through every aspect of the architectural level of
>> detail long before the details of any set of state transitions can
>> possibly be inferred.
>
> But that isn't what you SAID you were doing.
>
> You claimed at the end that this now what you are saying is not yet
> existent decider, got the right answer. You Whole logic is flawed by
> presuming that such a decider is possible to create.
>
> Note, this is different then the Linz proof, which begins with a
> hypothetical assumption, but remembers it is under a hypothetical, and
> thus possibly not existing case, and then showing that having such an
> assumption leads to an impossibility. THAT is a valid logic form.
>
> Assuming something to exist, and then 'proving' that it exists from that
> is not.
>

My proof begins after page 319 of the Linz proof before page 320 of the
Linz proof.

We cannot begin my proof until after we define and validate every detail
of the architectural design of the simulating halt decider that
correctly decides inputs having the pathological self-reference error in
V9.

>>
>>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>>> machines. Once 'defined' all there properties, like halting behavior is
>>> fixed (which is one of the flaws of you 'proxie argument')
>>>
>>> It is in fact impossible to make a physical machine that can act as a
>>> TRUE Universal Turing Machine runner, as Turing Machines are potentially
>>> unbounded, and the physical universe is bounded.
>>>
>>
>>
>
> In another post you said:
>
>>> When input P invokes embedded simulating halt decider H on itself H creates proxy input P2 replacing H with simulator S. >
>> This is the same thing as H simply excluding its own execution from halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>
> And I will ask you, why does it make sense to exclude looking at a
> significant piece of a Turing Machine to see how it behaves?
>
> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
> anything about another machine.
>
> This is like critiquing and 3 hour play after watching the first 3
> minutes and then leaving.

You keep skipping the steps of this. You have to read the steps of my
proof with enough focused concentration as if these steps may actually
be correct. It may take two hours per half page. (V9) is the key half page.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/23/21 10:42 PM, olcott wrote:
> On 5/23/2021 9:24 PM, Richard Damon wrote:
>> On 5/23/21 5:21 PM, olcott wrote:
>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>>> self-reference error
>>>>>>>
>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>> P in
>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>> deciding
>>>>>>> simulator H has no effect what-so-ever on the behavior of input P
>>>>>>> and
>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>
>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>> simulating
>>>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>>>> input
>>>>>>> P. When this same input is simulated by simulator S, its simulation
>>>>>>> never stops.
>>>>>>>
>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>> simulating
>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>> if H
>>>>>>> was simulator S.
>>>>>>>
>>>>>>> Because of the above simulating halt decider H can decide input P
>>>>>>> having
>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>> input P2
>>>>>>> having the pathological self-reference error removed.
>>>>>>
>>>>>> And may I ask HOW does is correctly decide to meet conditions (b) and
>>>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>>>> Decider to tell it wha to do.
>>>>>>
>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>> accurate
>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>> Halt
>>>>>> Decider.
>>>>>>
>>>>>> You are ASSUMING
>>>>>>
>>>>>>>
>>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>>> creates proxy input P2 replacing H with simulator S. The embedded
>>>>>>> halt
>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>> embedded
>>>>>>> halt decider correctly decides its input P on the basis of how it
>>>>>>> decides input P2.
>>>>>>
>>>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>>>> which
>>>>>> point it is no longer machine P, or you applied the transformation
>>>>>> singly, which may be allowable. The problem is that you algorithm now
>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>> decide on
>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>> thus is
>>>>>> not valid.
>>>>>>
>>>>>> Since this says that the answer you get differs from that basic
>>>>>> answer
>>>>>> you get by actually running the machiine P(I), we can show that this
>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>> Computation Theory.
>>>>>
>>>>> We haven't gotten to the point where running the machine is possible.
>>>>
>>>> You can't have a machine description until you have an actual machine,
>>>> as defined by its state transition table.
>>>>
>>>> PERIOD.
>>>>
>>>> Once you have a machine, in the form of a state transition table, it it
>>>> by definition runable. You might not have a program designed to do
>>>> this,
>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>> person can step through it manually.
>>>>
>>>>>
>>>>> Before we can possibly run the machine we have to define and validate
>>>>> the architectural basis for a simulating halt decider that correctly
>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>> 2004).
>>>>>
>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>
>>>>
>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>> Transition Table, is runable. That has ALL the information needed to
>>>> do so.
>>>
>>> Yes, however you were running P(I) before it was even defined at the
>>> architectural level of detail:
>>
>> But then you can't simulate it either.
>>
>> Note, and you're not going to like this, this is exactly the statements
>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>> computation when we actually run it. You try to force your broken logic
>> fumblings to have precedence over the actual operation of the machine.
>>
>> In one sense, you HAVE poisoned this well, and if you want to try to go
>> over it again, you need to do something to make it very clear that you
>> aren't just trying to reuse your old disproven logic.
>>
>>>
>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>> Since this says that the answer you get differs from that basic answer
>>>> you get by actually running the machine P(I),
>>>
>>> We must proceed through every aspect of the architectural level of
>>> detail long before the details of any set of state transitions can
>>> possibly be inferred.
>>
>> But that isn't what you SAID you were doing.
>>
>> You claimed at the end that this now what you are saying is not yet
>> existent decider, got the right answer. You Whole logic is flawed by
>> presuming that such a decider is possible to create.
>>
>> Note, this is different then the Linz proof, which begins with a
>> hypothetical assumption, but remembers it is under a hypothetical, and
>> thus possibly not existing case, and then showing that having such an
>> assumption leads to an impossibility. THAT is a valid logic form.
>>
>> Assuming something to exist, and then 'proving' that it exists from that
>> is not.
>>
>
> My proof begins after page 319 of the Linz proof before page 320 of the
> Linz proof.
>
> We cannot begin my proof until after we define and validate every detail
> of the architectural design of the simulating halt decider that
> correctly decides inputs having the pathological self-reference error in
> V9.
>
>>>
>>>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>>>> machines. Once 'defined' all there properties, like halting behavior is
>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>
>>>> It is in fact impossible to make a physical machine that can act as a
>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>> potentially
>>>> unbounded, and the physical universe is bounded.
>>>>
>>>
>>>
>>
>> In another post you said:
>>
>>>> When input P invokes embedded simulating halt decider H on itself H
>>>> creates proxy input P2 replacing H with simulator S. >
>>> This is the same thing as H simply excluding its own execution from
>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>
>> And I will ask you, why does it make sense to exclude looking at a
>> significant piece of a Turing Machine to see how it behaves?
>>
>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>> anything about another machine.
>>
>> This is like critiquing and 3 hour play after watching the first 3
>> minutes and then leaving.
>
> You keep skipping the steps of this. You have to read the steps of my
> proof with enough focused concentration as if these steps may actually
> be correct. It may take two hours per half page. (V9) is the key half page.
>
>

On 5/24/2021 6:12 AM, Richard Damon wrote:
> On 5/23/21 10:42 PM, olcott wrote:
>> On 5/23/2021 9:24 PM, Richard Damon wrote:
>>> On 5/23/21 5:21 PM, olcott wrote:
>>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>>>> self-reference error
>>>>>>>>
>>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>>> P in
>>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>>> deciding
>>>>>>>> simulator H has no effect what-so-ever on the behavior of input P
>>>>>>>> and
>>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>>
>>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>>> simulating
>>>>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>>>>> input
>>>>>>>> P. When this same input is simulated by simulator S, its simulation
>>>>>>>> never stops.
>>>>>>>>
>>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>>> simulating
>>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>>> if H
>>>>>>>> was simulator S.
>>>>>>>>
>>>>>>>> Because of the above simulating halt decider H can decide input P
>>>>>>>> having
>>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>>> input P2
>>>>>>>> having the pathological self-reference error removed.
>>>>>>>
>>>>>>> And may I ask HOW does is correctly decide to meet conditions (b) and
>>>>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>>>>> Decider to tell it wha to do.
>>>>>>>
>>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>>> accurate
>>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>>> Halt
>>>>>>> Decider.
>>>>>>>
>>>>>>> You are ASSUMING
>>>>>>>
>>>>>>>>
>>>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>>>> creates proxy input P2 replacing H with simulator S. The embedded
>>>>>>>> halt
>>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>>> embedded
>>>>>>>> halt decider correctly decides its input P on the basis of how it
>>>>>>>> decides input P2.
>>>>>>>
>>>>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>>>>> which
>>>>>>> point it is no longer machine P, or you applied the transformation
>>>>>>> singly, which may be allowable. The problem is that you algorithm now
>>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>>> decide on
>>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>>> thus is
>>>>>>> not valid.
>>>>>>>
>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>> answer
>>>>>>> you get by actually running the machiine P(I), we can show that this
>>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>>> Computation Theory.
>>>>>>
>>>>>> We haven't gotten to the point where running the machine is possible.
>>>>>
>>>>> You can't have a machine description until you have an actual machine,
>>>>> as defined by its state transition table.
>>>>>
>>>>> PERIOD.
>>>>>
>>>>> Once you have a machine, in the form of a state transition table, it it
>>>>> by definition runable. You might not have a program designed to do
>>>>> this,
>>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>>> person can step through it manually.
>>>>>
>>>>>>
>>>>>> Before we can possibly run the machine we have to define and validate
>>>>>> the architectural basis for a simulating halt decider that correctly
>>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>>> 2004).
>>>>>>
>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>
>>>>>
>>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>>> Transition Table, is runable. That has ALL the information needed to
>>>>> do so.
>>>>
>>>> Yes, however you were running P(I) before it was even defined at the
>>>> architectural level of detail:
>>>
>>> But then you can't simulate it either.
>>>
>>> Note, and you're not going to like this, this is exactly the statements
>>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>>> computation when we actually run it. You try to force your broken logic
>>> fumblings to have precedence over the actual operation of the machine.
>>>
>>> In one sense, you HAVE poisoned this well, and if you want to try to go
>>> over it again, you need to do something to make it very clear that you
>>> aren't just trying to reuse your old disproven logic.
>>>
>>>>
>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>> Since this says that the answer you get differs from that basic answer
>>>>> you get by actually running the machine P(I),
>>>>
>>>> We must proceed through every aspect of the architectural level of
>>>> detail long before the details of any set of state transitions can
>>>> possibly be inferred.
>>>
>>> But that isn't what you SAID you were doing.
>>>
>>> You claimed at the end that this now what you are saying is not yet
>>> existent decider, got the right answer. You Whole logic is flawed by
>>> presuming that such a decider is possible to create.
>>>
>>> Note, this is different then the Linz proof, which begins with a
>>> hypothetical assumption, but remembers it is under a hypothetical, and
>>> thus possibly not existing case, and then showing that having such an
>>> assumption leads to an impossibility. THAT is a valid logic form.
>>>
>>> Assuming something to exist, and then 'proving' that it exists from that
>>> is not.
>>>
>>
>> My proof begins after page 319 of the Linz proof before page 320 of the
>> Linz proof.
>>
>> We cannot begin my proof until after we define and validate every detail
>> of the architectural design of the simulating halt decider that
>> correctly decides inputs having the pathological self-reference error in
>> V9.
>>
>>>>
>>>>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>>>>> machines. Once 'defined' all there properties, like halting behavior is
>>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>>
>>>>> It is in fact impossible to make a physical machine that can act as a
>>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>>> potentially
>>>>> unbounded, and the physical universe is bounded.
>>>>>
>>>>
>>>>
>>>
>>> In another post you said:
>>>
>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>> creates proxy input P2 replacing H with simulator S. >
>>>> This is the same thing as H simply excluding its own execution from
>>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>>
>>> And I will ask you, why does it make sense to exclude looking at a
>>> significant piece of a Turing Machine to see how it behaves?
>>>
>>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>>> anything about another machine.
>>>
>>> This is like critiquing and 3 hour play after watching the first 3
>>> minutes and then leaving.
>>
>> You keep skipping the steps of this. You have to read the steps of my
>> proof with enough focused concentration as if these steps may actually
>> be correct. It may take two hours per half page. (V9) is the key half page.
>>
>>
>
> No. I read it, understand it and see the errors in it.
>
> For instance, one BIG problem is how does H recognize copies of itself in P?

On Monday, 24 May 2021 at 13:34:42 UTC+1, olcott wrote:
> On 5/24/2021 6:12 AM, Richard Damon wrote:
>
> Yet another dishonest dodge off the topic of using proxy inputs to
> circumvent the pathological self-reference error.
> > The logic you are trying to do is FULL of these sorts of errors. It
> > seems you SO much want to get a given results that you can't see what is
> > really true.
> >
> It only seems to be full of errors because you utterly refuse to stay
> laser focused on the single topic that
>
> translating inputs with the PSRE into equivalent inputs not having the
> PSRE is the proxy input correct halt deciding basis of the original input.
>
> We do not need to examine how this is done because this is only the
> teaching basis for a whole other different process.
>
Well I haven't been following every thread with full attention. But the phrase
"proxy inputs" is one that seems to have only cropped up only recently.

I thought we had established that you had an infinite-loop detecting simulator
which stepped the input until unbounded recursion was detected, then aborted
the simulation. In order to overcome the obvious problem, it was then declared
that this "abort" was different to a "halt", and didn't count for the purposes
of halt deciding.

"Proxy inputs" are a new development.

On 5/24/2021 8:11 AM, Malcolm McLean wrote:
> On Monday, 24 May 2021 at 13:34:42 UTC+1, olcott wrote:
>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>
>> Yet another dishonest dodge off the topic of using proxy inputs to
>> circumvent the pathological self-reference error.
>>> The logic you are trying to do is FULL of these sorts of errors. It
>>> seems you SO much want to get a given results that you can't see what is
>>> really true.
>>>
>> It only seems to be full of errors because you utterly refuse to stay
>> laser focused on the single topic that
>>
>> translating inputs with the PSRE into equivalent inputs not having the
>> PSRE is the proxy input correct halt deciding basis of the original input.
>>
>> We do not need to examine how this is done because this is only the
>> teaching basis for a whole other different process.
>>
> Well I haven't been following every thread with full attention. But the phrase
> "proxy inputs" is one that seems to have only cropped up only recently.
>
> I thought we had established that you had an infinite-loop detecting simulator
> which stepped the input until unbounded recursion was detected, then aborted
> the simulation. In order to overcome the obvious problem, it was then declared
> that this "abort" was different to a "halt", and didn't count for the purposes
> of halt deciding.
>
> "Proxy inputs" are a new development.
>

Yes, I just came up with this much clearer wording yesterday. I am
relatively terrible at communicating the insights that I have in my mind
because they are not stored in my mind as words.

To be fair and honest when I do get published I must give credit to the
reviewers of comp.theory because it would have been totally impossible
for me to improve the wording of my proof without these reviewers acting
as the fitness function to my genetic algorithm process of progressive
refinement.

There are a small set of reviewers that I would be happy to specifically
name when my proof is published. I intend to be very generous with this
such that anyone that helped getting key points of my proof understood
will get credit even if most of the time most of their reviews were not
much more than denigrating. You helped getting key points of my proof
understood.

Reviewers that were nothing besides denigrating will get no credit
unless they change their ways and start providing actual critiques.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/24/2021 8:11 AM, Malcolm McLean wrote:
> On Monday, 24 May 2021 at 13:34:42 UTC+1, olcott wrote:
>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>
>> Yet another dishonest dodge off the topic of using proxy inputs to
>> circumvent the pathological self-reference error.
>>> The logic you are trying to do is FULL of these sorts of errors. It
>>> seems you SO much want to get a given results that you can't see what is
>>> really true.
>>>
>> It only seems to be full of errors because you utterly refuse to stay
>> laser focused on the single topic that
>>
>> translating inputs with the PSRE into equivalent inputs not having the
>> PSRE is the proxy input correct halt deciding basis of the original input.
>>
>> We do not need to examine how this is done because this is only the
>> teaching basis for a whole other different process.
>>
> Well I haven't been following every thread with full attention. But the phrase
> "proxy inputs" is one that seems to have only cropped up only recently.
>
> I thought we had established that you had an infinite-loop detecting simulator
> which stepped the input until unbounded recursion was detected, then aborted
> the simulation. In order to overcome the obvious problem, it was then declared
> that this "abort" was different to a "halt", and didn't count for the purposes
> of halt deciding.
>
> "Proxy inputs" are a new development.
>

The concept of proxy inputs to a simulating halt decider having inputs
with the pathological self-reference error (PSRE) is a teaching device.
This teaching device is used to prove that another equivalent process
does correctly decide the halting status of these original inputs.

The first step of beginning to understand proxy inputs is understanding
this hypothetical situation:

If there is a decidable equivalent proxy input P2 to undecidable
decision problem Question/Input:P pairs then deciding this proxy input
P2 is equivalent to deciding the original input P.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Monday, 24 May 2021 at 13:34:42 UTC+1, olcott wrote:
>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>
>> Yet another dishonest dodge off the topic of using proxy inputs to
>> circumvent the pathological self-reference error.
>> > The logic you are trying to do is FULL of these sorts of errors. It
>> > seems you SO much want to get a given results that you can't see what is
>> > really true.
>> >
>> It only seems to be full of errors because you utterly refuse to stay
>> laser focused on the single topic that
>>
>> translating inputs with the PSRE into equivalent inputs not having the
>> PSRE is the proxy input correct halt deciding basis of the original input.
>>
>> We do not need to examine how this is done because this is only the
>> teaching basis for a whole other different process.
>>
> Well I haven't been following every thread with full attention. But the phrase
> "proxy inputs" is one that seems to have only cropped up only recently.
>
> I thought we had established that you had an infinite-loop detecting simulator
> which stepped the input until unbounded recursion was detected, then aborted
> the simulation. In order to overcome the obvious problem, it was then declared
> that this "abort" was different to a "halt", and didn't count for the purposes
> of halt deciding.
>
> "Proxy inputs" are a new development.

No, it is a new way to say the same old thing. The "not-really-halting"
answer for computation X is determined by what X' does, where X' is X
with some bits removed/changed or, as he once said very clearly, with
"line 15 commented out". The proxy input is this other computation, and
the proxy question is would this other computation halt?.

The evolution is only in the language. He keeps trying to find some way
of putting it that hides the obvious silliness of this "solution". The
advantage of the word "proxy" is that it sounds like it just stands in
for the proper input. It's a reasonable try, but trying to hide what
one is doing in a technical discussion is an odd approach.

It all very odd. With the switch away from TMs and whole mess of as x86
"operating system" I was expecting a trick that gave the right answer
for the key computation, Halts(H_Hat, H_Hat). He could have hidden the
trick for years since he has no plans to ever show the code. But
instead he decided simply to give the wrong answer and declare it to be
correct. The work now is all about making this look like it's still the
halting problem. Hence his refusal to use another name.

--
Ben.

On 5/24/2021 11:45 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Monday, 24 May 2021 at 13:34:42 UTC+1, olcott wrote:
>>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>>
>>> Yet another dishonest dodge off the topic of using proxy inputs to
>>> circumvent the pathological self-reference error.
>>>> The logic you are trying to do is FULL of these sorts of errors. It
>>>> seems you SO much want to get a given results that you can't see what is
>>>> really true.
>>>>
>>> It only seems to be full of errors because you utterly refuse to stay
>>> laser focused on the single topic that
>>>
>>> translating inputs with the PSRE into equivalent inputs not having the
>>> PSRE is the proxy input correct halt deciding basis of the original input.
>>>
>>> We do not need to examine how this is done because this is only the
>>> teaching basis for a whole other different process.
>>>
>> Well I haven't been following every thread with full attention. But the phrase
>> "proxy inputs" is one that seems to have only cropped up only recently.
>>
>> I thought we had established that you had an infinite-loop detecting simulator
>> which stepped the input until unbounded recursion was detected, then aborted
>> the simulation. In order to overcome the obvious problem, it was then declared
>> that this "abort" was different to a "halt", and didn't count for the purposes
>> of halt deciding.
>>
>> "Proxy inputs" are a new development.
>
> No, it is a new way to say the same old thing. The "not-really-halting"
> answer for computation X is determined by what X' does, where X' is X
> with some bits removed/changed or, as he once said very clearly, with
> "line 15 commented out". The proxy input is this other computation, and
> the proxy question is would this other computation halt?.
>
> The evolution is only in the language. He keeps trying to find some way
> of putting it that hides the obvious silliness of this "solution". The
> advantage of the word "proxy" is that it sounds like it just stands in
> for the proper input. It's a reasonable try, but trying to hide what
> one is doing in a technical discussion is an odd approach.
>
> It all very odd. With the switch away from TMs and whole mess of as x86
> "operating system" I was expecting a trick that gave the right answer
> for the key computation, Halts(H_Hat, H_Hat). He could have hidden the
> trick for years since he has no plans to ever show the code. But
> instead he decided simply to give the wrong answer and declare it to be
> correct. The work now is all about making this look like it's still the
> halting problem. Hence his refusal to use another name.
>

The concept of proxy inputs to a simulating halt decider having inputs
with the pathological self-reference error (PSRE) is a teaching device.
This teaching device is used to prove that another equivalent process
does correctly decide the halting status of these original inputs.

The first step of beginning to understand proxy inputs is understanding
this hypothetical situation: If there is a decidable equivalent proxy
input P2 to undecidable decision problem Question/Input:P pair then
deciding this proxy input P2 is equivalent to deciding the original
input P.

V9 is a step-by-step proof that my basis is correct for anyone that is
not so biased against my position that they can carefully analyze these
steps instead is simply dismissing them out-of-hand.

V9 still may not be nearly clear enough. I am relatively terrible at
communicating these key ideas because they are not stored in my mind as
words.

The first page of my paper is completely rewritten to provide key
background for V9:

http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf

The V9 proof that this key basis is correct immediately follows this
background. It is still probably woefully deficient.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/24/21 8:34 AM, olcott wrote:
> On 5/24/2021 6:12 AM, Richard Damon wrote:
>> On 5/23/21 10:42 PM, olcott wrote:
>>> On 5/23/2021 9:24 PM, Richard Damon wrote:
>>>> On 5/23/21 5:21 PM, olcott wrote:
>>>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>>>>> self-reference error
>>>>>>>>>
>>>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>>>> P in
>>>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>>>> deciding
>>>>>>>>> simulator H has no effect what-so-ever on the behavior of input P
>>>>>>>>> and
>>>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>>>
>>>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>>>> simulating
>>>>>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>>>>>> input
>>>>>>>>> P. When this same input is simulated by simulator S, its
>>>>>>>>> simulation
>>>>>>>>> never stops.
>>>>>>>>>
>>>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>>>> simulating
>>>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>>>> if H
>>>>>>>>> was simulator S.
>>>>>>>>>
>>>>>>>>> Because of the above simulating halt decider H can decide input P
>>>>>>>>> having
>>>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>>>> input P2
>>>>>>>>> having the pathological self-reference error removed.
>>>>>>>>
>>>>>>>> And may I ask HOW does is correctly decide to meet conditions
>>>>>>>> (b) and
>>>>>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>>>>>> Decider to tell it wha to do.
>>>>>>>>
>>>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>>>> accurate
>>>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>>>> Halt
>>>>>>>> Decider.
>>>>>>>>
>>>>>>>> You are ASSUMING
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When input P invokes embedded simulating halt decider H on
>>>>>>>>> itself H
>>>>>>>>> creates proxy input P2 replacing H with simulator S. The embedded
>>>>>>>>> halt
>>>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>>>> embedded
>>>>>>>>> halt decider correctly decides its input P on the basis of how it
>>>>>>>>> decides input P2.
>>>>>>>>
>>>>>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>>>>>> which
>>>>>>>> point it is no longer machine P, or you applied the transformation
>>>>>>>> singly, which may be allowable. The problem is that you
>>>>>>>> algorithm now
>>>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>>>> decide on
>>>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>>>> thus is
>>>>>>>> not valid.
>>>>>>>>
>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>> answer
>>>>>>>> you get by actually running the machiine P(I), we can show that
>>>>>>>> this
>>>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>>>> Computation Theory.
>>>>>>>
>>>>>>> We haven't gotten to the point where running the machine is
>>>>>>> possible.
>>>>>>
>>>>>> You can't have a machine description until you have an actual
>>>>>> machine,
>>>>>> as defined by its state transition table.
>>>>>>
>>>>>> PERIOD.
>>>>>>
>>>>>> Once you have a machine, in the form of a state transition table,
>>>>>> it it
>>>>>> by definition runable. You might not have a program designed to do
>>>>>> this,
>>>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>>>> person can step through it manually.
>>>>>>
>>>>>>>
>>>>>>> Before we can possibly run the machine we have to define and
>>>>>>> validate
>>>>>>> the architectural basis for a simulating halt decider that correctly
>>>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>>>> 2004).
>>>>>>>
>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>
>>>>>>
>>>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>>>> Transition Table, is runable. That has ALL the information needed to
>>>>>> do so.
>>>>>
>>>>> Yes, however you were running P(I) before it was even defined at the
>>>>> architectural level of detail:
>>>>
>>>> But then you can't simulate it either.
>>>>
>>>> Note, and you're not going to like this, this is exactly the statements
>>>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>>>> computation when we actually run it. You try to force your broken logic
>>>> fumblings to have precedence over the actual operation of the machine.
>>>>
>>>> In one sense, you HAVE poisoned this well, and if you want to try to go
>>>> over it again, you need to do something to make it very clear that you
>>>> aren't just trying to reuse your old disproven logic.
>>>>
>>>>>
>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>> Since this says that the answer you get differs from that basic
>>>>>> answer
>>>>>> you get by actually running the machine P(I),
>>>>>
>>>>> We must proceed through every aspect of the architectural level of
>>>>> detail long before the details of any set of state transitions can
>>>>> possibly be inferred.
>>>>
>>>> But that isn't what you SAID you were doing.
>>>>
>>>> You claimed at the end that this now what you are saying is not yet
>>>> existent decider, got the right answer. You Whole logic is flawed by
>>>> presuming that such a decider is possible to create.
>>>>
>>>> Note, this is different then the Linz proof, which begins with a
>>>> hypothetical assumption, but remembers it is under a hypothetical, and
>>>> thus possibly not existing case, and then showing that having such an
>>>> assumption leads to an impossibility. THAT is a valid logic form.
>>>>
>>>> Assuming something to exist, and then 'proving' that it exists from
>>>> that
>>>> is not.
>>>>
>>>
>>> My proof begins after page 319 of the Linz proof before page 320 of the
>>> Linz proof.
>>>
>>> We cannot begin my proof until after we define and validate every detail
>>> of the architectural design of the simulating halt decider that
>>> correctly decides inputs having the pathological self-reference error in
>>> V9.
>>>
>>>>>
>>>>>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>>>>>> machines. Once 'defined' all there properties, like halting
>>>>>> behavior is
>>>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>>>
>>>>>> It is in fact impossible to make a physical machine that can act as a
>>>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>>>> potentially
>>>>>> unbounded, and the physical universe is bounded.
>>>>>>
>>>>>
>>>>>
>>>>
>>>> In another post you said:
>>>>
>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>> creates proxy input P2 replacing H with simulator S. >
>>>>> This is the same thing as H simply excluding its own execution from
>>>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>>>
>>>> And I will ask you, why does it make sense to exclude looking at a
>>>> significant piece of a Turing Machine to see how it behaves?
>>>>
>>>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>>>> anything about another machine.
>>>>
>>>> This is like critiquing and 3 hour play after watching the first 3
>>>> minutes and then leaving.
>>>
>>> You keep skipping the steps of this. You have to read the steps of my
>>> proof with enough focused concentration as if these steps may actually
>>> be correct. It may take two hours per half page. (V9) is the key half
>>> page.
>>>
>>>
>>
>> No. I read it, understand it and see the errors in it.
>>
>> For instance, one BIG problem is how does H recognize copies of itself
>> in P?
>
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>
> We are only talking about the simulating halt decider at state Ĥ.qx
> invoking its actual self in the computation Ĥ([Ĥ]).

On 5/24/2021 7:39 PM, Richard Damon wrote:
> On 5/24/21 8:34 AM, olcott wrote:
>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>> On 5/23/21 10:42 PM, olcott wrote:
>>>> On 5/23/2021 9:24 PM, Richard Damon wrote:
>>>>> On 5/23/21 5:21 PM, olcott wrote:
>>>>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>>>>>> self-reference error
>>>>>>>>>>
>>>>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>>>>> P in
>>>>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>>>>> deciding
>>>>>>>>>> simulator H has no effect what-so-ever on the behavior of input P
>>>>>>>>>> and
>>>>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>>>>
>>>>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>>>>> simulating
>>>>>>>>>> halt decider H the halt decider H must stop the simulation of this
>>>>>>>>>> input
>>>>>>>>>> P. When this same input is simulated by simulator S, its
>>>>>>>>>> simulation
>>>>>>>>>> never stops.
>>>>>>>>>>
>>>>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>>>>> simulating
>>>>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>>>>> if H
>>>>>>>>>> was simulator S.
>>>>>>>>>>
>>>>>>>>>> Because of the above simulating halt decider H can decide input P
>>>>>>>>>> having
>>>>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>>>>> input P2
>>>>>>>>>> having the pathological self-reference error removed.
>>>>>>>>>
>>>>>>>>> And may I ask HOW does is correctly decide to meet conditions
>>>>>>>>> (b) and
>>>>>>>>> (c). To properly make this decision, your Halt Decider needs a Halt
>>>>>>>>> Decider to tell it wha to do.
>>>>>>>>>
>>>>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>>>>> accurate
>>>>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>>>>> Halt
>>>>>>>>> Decider.
>>>>>>>>>
>>>>>>>>> You are ASSUMING
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When input P invokes embedded simulating halt decider H on
>>>>>>>>>> itself H
>>>>>>>>>> creates proxy input P2 replacing H with simulator S. The embedded
>>>>>>>>>> halt
>>>>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>>>>> embedded
>>>>>>>>>> halt decider correctly decides its input P on the basis of how it
>>>>>>>>>> decides input P2.
>>>>>>>>>
>>>>>>>>> This step FAILS. Note, Either you re-wrote the whole machine P, at
>>>>>>>>> which
>>>>>>>>> point it is no longer machine P, or you applied the transformation
>>>>>>>>> singly, which may be allowable. The problem is that you
>>>>>>>>> algorithm now
>>>>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>>>>> decide on
>>>>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>>>>> thus is
>>>>>>>>> not valid.
>>>>>>>>>
>>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>>> answer
>>>>>>>>> you get by actually running the machiine P(I), we can show that
>>>>>>>>> this
>>>>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>>>>> Computation Theory.
>>>>>>>>
>>>>>>>> We haven't gotten to the point where running the machine is
>>>>>>>> possible.
>>>>>>>
>>>>>>> You can't have a machine description until you have an actual
>>>>>>> machine,
>>>>>>> as defined by its state transition table.
>>>>>>>
>>>>>>> PERIOD.
>>>>>>>
>>>>>>> Once you have a machine, in the form of a state transition table,
>>>>>>> it it
>>>>>>> by definition runable. You might not have a program designed to do
>>>>>>> this,
>>>>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>>>>> person can step through it manually.
>>>>>>>
>>>>>>>>
>>>>>>>> Before we can possibly run the machine we have to define and
>>>>>>>> validate
>>>>>>>> the architectural basis for a simulating halt decider that correctly
>>>>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>>>>> 2004).
>>>>>>>>
>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>
>>>>>>>
>>>>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>>>>> Transition Table, is runable. That has ALL the information needed to
>>>>>>> do so.
>>>>>>
>>>>>> Yes, however you were running P(I) before it was even defined at the
>>>>>> architectural level of detail:
>>>>>
>>>>> But then you can't simulate it either.
>>>>>
>>>>> Note, and you're not going to like this, this is exactly the statements
>>>>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>>>>> computation when we actually run it. You try to force your broken logic
>>>>> fumblings to have precedence over the actual operation of the machine.
>>>>>
>>>>> In one sense, you HAVE poisoned this well, and if you want to try to go
>>>>> over it again, you need to do something to make it very clear that you
>>>>> aren't just trying to reuse your old disproven logic.
>>>>>
>>>>>>
>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>> answer
>>>>>>> you get by actually running the machine P(I),
>>>>>>
>>>>>> We must proceed through every aspect of the architectural level of
>>>>>> detail long before the details of any set of state transitions can
>>>>>> possibly be inferred.
>>>>>
>>>>> But that isn't what you SAID you were doing.
>>>>>
>>>>> You claimed at the end that this now what you are saying is not yet
>>>>> existent decider, got the right answer. You Whole logic is flawed by
>>>>> presuming that such a decider is possible to create.
>>>>>
>>>>> Note, this is different then the Linz proof, which begins with a
>>>>> hypothetical assumption, but remembers it is under a hypothetical, and
>>>>> thus possibly not existing case, and then showing that having such an
>>>>> assumption leads to an impossibility. THAT is a valid logic form.
>>>>>
>>>>> Assuming something to exist, and then 'proving' that it exists from
>>>>> that
>>>>> is not.
>>>>>
>>>>
>>>> My proof begins after page 319 of the Linz proof before page 320 of the
>>>> Linz proof.
>>>>
>>>> We cannot begin my proof until after we define and validate every detail
>>>> of the architectural design of the simulating halt decider that
>>>> correctly decides inputs having the pathological self-reference error in
>>>> V9.
>>>>
>>>>>>
>>>>>>> Remember, Turing Machines are theoretical constructs, NOT 'physical'
>>>>>>> machines. Once 'defined' all there properties, like halting
>>>>>>> behavior is
>>>>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>>>>
>>>>>>> It is in fact impossible to make a physical machine that can act as a
>>>>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>>>>> potentially
>>>>>>> unbounded, and the physical universe is bounded.
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> In another post you said:
>>>>>
>>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>>> creates proxy input P2 replacing H with simulator S. >
>>>>>> This is the same thing as H simply excluding its own execution from
>>>>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>>>>
>>>>> And I will ask you, why does it make sense to exclude looking at a
>>>>> significant piece of a Turing Machine to see how it behaves?
>>>>>
>>>>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>>>>> anything about another machine.
>>>>>
>>>>> This is like critiquing and 3 hour play after watching the first 3
>>>>> minutes and then leaving.
>>>>
>>>> You keep skipping the steps of this. You have to read the steps of my
>>>> proof with enough focused concentration as if these steps may actually
>>>> be correct. It may take two hours per half page. (V9) is the key half
>>>> page.
>>>>
>>>>
>>>
>>> No. I read it, understand it and see the errors in it.
>>>
>>> For instance, one BIG problem is how does H recognize copies of itself
>>> in P?
>>
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>
>> We are only talking about the simulating halt decider at state Ĥ.qx
>> invoking its actual self in the computation Ĥ([Ĥ]).
>
> And, as already previously mentioned, this NEVER happens. Your H NEVER

On 5/24/21 10:04 PM, olcott wrote:
> On 5/24/2021 7:39 PM, Richard Damon wrote:
>> On 5/24/21 8:34 AM, olcott wrote:
>>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>>> On 5/23/21 10:42 PM, olcott wrote:
>>>>> On 5/23/2021 9:24 PM, Richard Damon wrote:
>>>>>> On 5/23/21 5:21 PM, olcott wrote:
>>>>>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>>>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>>>>>> Generic halt deciding principle for inputs having the
>>>>>>>>>>> pathological
>>>>>>>>>>> self-reference error
>>>>>>>>>>>
>>>>>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>>>>>> P in
>>>>>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>>>>>> deciding
>>>>>>>>>>> simulator H has no effect what-so-ever on the behavior of
>>>>>>>>>>> input P
>>>>>>>>>>> and
>>>>>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>>>>>
>>>>>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>>>>>> simulating
>>>>>>>>>>> halt decider H the halt decider H must stop the simulation of
>>>>>>>>>>> this
>>>>>>>>>>> input
>>>>>>>>>>> P. When this same input is simulated by simulator S, its
>>>>>>>>>>> simulation
>>>>>>>>>>> never stops.
>>>>>>>>>>>
>>>>>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>>>>>> simulating
>>>>>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>>>>>> if H
>>>>>>>>>>> was simulator S.
>>>>>>>>>>>
>>>>>>>>>>> Because of the above simulating halt decider H can decide
>>>>>>>>>>> input P
>>>>>>>>>>> having
>>>>>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>>>>>> input P2
>>>>>>>>>>> having the pathological self-reference error removed.
>>>>>>>>>>
>>>>>>>>>> And may I ask HOW does is correctly decide to meet conditions
>>>>>>>>>> (b) and
>>>>>>>>>> (c). To properly make this decision, your Halt Decider needs a
>>>>>>>>>> Halt
>>>>>>>>>> Decider to tell it wha to do.
>>>>>>>>>>
>>>>>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>>>>>> accurate
>>>>>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>>>>>> Halt
>>>>>>>>>> Decider.
>>>>>>>>>>
>>>>>>>>>> You are ASSUMING
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When input P invokes embedded simulating halt decider H on
>>>>>>>>>>> itself H
>>>>>>>>>>> creates proxy input P2 replacing H with simulator S. The
>>>>>>>>>>> embedded
>>>>>>>>>>> halt
>>>>>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>>>>>> embedded
>>>>>>>>>>> halt decider correctly decides its input P on the basis of
>>>>>>>>>>> how it
>>>>>>>>>>> decides input P2.
>>>>>>>>>>
>>>>>>>>>> This step FAILS. Note, Either you re-wrote the whole machine
>>>>>>>>>> P, at
>>>>>>>>>> which
>>>>>>>>>> point it is no longer machine P, or you applied the
>>>>>>>>>> transformation
>>>>>>>>>> singly, which may be allowable. The problem is that you
>>>>>>>>>> algorithm now
>>>>>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>>>>>> decide on
>>>>>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>>>>>> thus is
>>>>>>>>>> not valid.
>>>>>>>>>>
>>>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>>>> answer
>>>>>>>>>> you get by actually running the machiine P(I), we can show that
>>>>>>>>>> this
>>>>>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>>>>>> Computation Theory.
>>>>>>>>>
>>>>>>>>> We haven't gotten to the point where running the machine is
>>>>>>>>> possible.
>>>>>>>>
>>>>>>>> You can't have a machine description until you have an actual
>>>>>>>> machine,
>>>>>>>> as defined by its state transition table.
>>>>>>>>
>>>>>>>> PERIOD.
>>>>>>>>
>>>>>>>> Once you have a machine, in the form of a state transition table,
>>>>>>>> it it
>>>>>>>> by definition runable. You might not have a program designed to do
>>>>>>>> this,
>>>>>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>>>>>> person can step through it manually.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Before we can possibly run the machine we have to define and
>>>>>>>>> validate
>>>>>>>>> the architectural basis for a simulating halt decider that
>>>>>>>>> correctly
>>>>>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>>>>>> 2004).
>>>>>>>>>
>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>>>>>> Transition Table, is runable. That has ALL the information
>>>>>>>> needed to
>>>>>>>> do so.
>>>>>>>
>>>>>>> Yes, however you were running P(I) before it was even defined at the
>>>>>>> architectural level of detail:
>>>>>>
>>>>>> But then you can't simulate it either.
>>>>>>
>>>>>> Note, and you're not going to like this, this is exactly the
>>>>>> statements
>>>>>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>>>>>> computation when we actually run it. You try to force your broken
>>>>>> logic
>>>>>> fumblings to have precedence over the actual operation of the
>>>>>> machine.
>>>>>>
>>>>>> In one sense, you HAVE poisoned this well, and if you want to try
>>>>>> to go
>>>>>> over it again, you need to do something to make it very clear that
>>>>>> you
>>>>>> aren't just trying to reuse your old disproven logic.
>>>>>>
>>>>>>>
>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>> answer
>>>>>>>> you get by actually running the machine P(I),
>>>>>>>
>>>>>>> We must proceed through every aspect of the architectural level of
>>>>>>> detail long before the details of any set of state transitions can
>>>>>>> possibly be inferred.
>>>>>>
>>>>>> But that isn't what you SAID you were doing.
>>>>>>
>>>>>> You claimed at the end that this now what you are saying is not yet
>>>>>> existent decider, got the right answer. You Whole logic is flawed by
>>>>>> presuming that such a decider is possible to create.
>>>>>>
>>>>>> Note, this is different then the Linz proof, which begins with a
>>>>>> hypothetical assumption, but remembers it is under a hypothetical,
>>>>>> and
>>>>>> thus possibly not existing case, and then showing that having such an
>>>>>> assumption leads to an impossibility. THAT is a valid logic form.
>>>>>>
>>>>>> Assuming something to exist, and then 'proving' that it exists from
>>>>>> that
>>>>>> is not.
>>>>>>
>>>>>
>>>>> My proof begins after page 319 of the Linz proof before page 320 of
>>>>> the
>>>>> Linz proof.
>>>>>
>>>>> We cannot begin my proof until after we define and validate every
>>>>> detail
>>>>> of the architectural design of the simulating halt decider that
>>>>> correctly decides inputs having the pathological self-reference
>>>>> error in
>>>>> V9.
>>>>>
>>>>>>>
>>>>>>>> Remember, Turing Machines are theoretical constructs, NOT
>>>>>>>> 'physical'
>>>>>>>> machines. Once 'defined' all there properties, like halting
>>>>>>>> behavior is
>>>>>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>>>>>
>>>>>>>> It is in fact impossible to make a physical machine that can act
>>>>>>>> as a
>>>>>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>>>>>> potentially
>>>>>>>> unbounded, and the physical universe is bounded.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> In another post you said:
>>>>>>
>>>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>>>> creates proxy input P2 replacing H with simulator S. >
>>>>>>> This is the same thing as H simply excluding its own execution from
>>>>>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>
>>>>>> And I will ask you, why does it make sense to exclude looking at a
>>>>>> significant piece of a Turing Machine to see how it behaves?
>>>>>>
>>>>>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>>>>>> anything about another machine.
>>>>>>
>>>>>> This is like critiquing and 3 hour play after watching the first 3
>>>>>> minutes and then leaving.
>>>>>
>>>>> You keep skipping the steps of this. You have to read the steps of my
>>>>> proof with enough focused concentration as if these steps may actually
>>>>> be correct. It may take two hours per half page. (V9) is the key half
>>>>> page.
>>>>>
>>>>>
>>>>
>>>> No. I read it, understand it and see the errors in it.
>>>>
>>>> For instance, one BIG problem is how does H recognize copies of itself
>>>> in P?
>>>
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>
>>> We are only talking about the simulating halt decider at state Ĥ.qx
>>> invoking its actual self in the computation Ĥ([Ĥ]).
>>
>> And, as already previously mentioned, this NEVER happens. Your H NEVER
>
> There is no freaking H. I am stopping here.

On 5/25/2021 6:10 AM, Richard Damon wrote:
> On 5/24/21 10:04 PM, olcott wrote:
>> On 5/24/2021 7:39 PM, Richard Damon wrote:
>>> On 5/24/21 8:34 AM, olcott wrote:
>>>> On 5/24/2021 6:12 AM, Richard Damon wrote:
>>>>> On 5/23/21 10:42 PM, olcott wrote:
>>>>>> On 5/23/2021 9:24 PM, Richard Damon wrote:
>>>>>>> On 5/23/21 5:21 PM, olcott wrote:
>>>>>>>> On 5/23/2021 4:10 PM, Richard Damon wrote:
>>>>>>>>> On 5/23/21 4:33 PM, olcott wrote:
>>>>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/23/21 3:02 PM, olcott wrote:
>>>>>>>>>>>> Generic halt deciding principle for inputs having the
>>>>>>>>>>>> pathological
>>>>>>>>>>>> self-reference error
>>>>>>>>>>>>
>>>>>>>>>>>> (a) Halt deciding simulator H only affects the behavior of input
>>>>>>>>>>>> P in
>>>>>>>>>>>> one way and only under one condition. In all other cases a halt
>>>>>>>>>>>> deciding
>>>>>>>>>>>> simulator H has no effect what-so-ever on the behavior of
>>>>>>>>>>>> input P
>>>>>>>>>>>> and
>>>>>>>>>>>> acts exactly like pure simulator S on input P.
>>>>>>>>>>>>
>>>>>>>>>>>> (b) When an infinite computation is specified as input P to a
>>>>>>>>>>>> simulating
>>>>>>>>>>>> halt decider H the halt decider H must stop the simulation of
>>>>>>>>>>>> this
>>>>>>>>>>>> input
>>>>>>>>>>>> P. When this same input is simulated by simulator S, its
>>>>>>>>>>>> simulation
>>>>>>>>>>>> never stops.
>>>>>>>>>>>>
>>>>>>>>>>>> (c) When a finite computation is specified as input P to a
>>>>>>>>>>>> simulating
>>>>>>>>>>>> halt decider H the halt decider H simulates its input exactly as
>>>>>>>>>>>> if H
>>>>>>>>>>>> was simulator S.
>>>>>>>>>>>>
>>>>>>>>>>>> Because of the above simulating halt decider H can decide
>>>>>>>>>>>> input P
>>>>>>>>>>>> having
>>>>>>>>>>>> the pathological self-reference error on the basis of the proxy
>>>>>>>>>>>> input P2
>>>>>>>>>>>> having the pathological self-reference error removed.
>>>>>>>>>>>
>>>>>>>>>>> And may I ask HOW does is correctly decide to meet conditions
>>>>>>>>>>> (b) and
>>>>>>>>>>> (c). To properly make this decision, your Halt Decider needs a
>>>>>>>>>>> Halt
>>>>>>>>>>> Decider to tell it wha to do.
>>>>>>>>>>>
>>>>>>>>>>> Since it has been proved that it is impossible to make a 100%
>>>>>>>>>>> accurate
>>>>>>>>>>> Halt Decider, it is impossible to make a 100% accurate Simulating
>>>>>>>>>>> Halt
>>>>>>>>>>> Decider.
>>>>>>>>>>>
>>>>>>>>>>> You are ASSUMING
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When input P invokes embedded simulating halt decider H on
>>>>>>>>>>>> itself H
>>>>>>>>>>>> creates proxy input P2 replacing H with simulator S. The
>>>>>>>>>>>> embedded
>>>>>>>>>>>> halt
>>>>>>>>>>>> decider H examines the execution trace of proxy input P2. The
>>>>>>>>>>>> embedded
>>>>>>>>>>>> halt decider correctly decides its input P on the basis of
>>>>>>>>>>>> how it
>>>>>>>>>>>> decides input P2.
>>>>>>>>>>>
>>>>>>>>>>> This step FAILS. Note, Either you re-wrote the whole machine
>>>>>>>>>>> P, at
>>>>>>>>>>> which
>>>>>>>>>>> point it is no longer machine P, or you applied the
>>>>>>>>>>> transformation
>>>>>>>>>>> singly, which may be allowable. The problem is that you
>>>>>>>>>>> algorithm now
>>>>>>>>>>> has to do infinite loop if P uses a simulating Halt Decider to
>>>>>>>>>>> decide on
>>>>>>>>>>> P. THIS say that the above rule is NOT a finite operation, and
>>>>>>>>>>> thus is
>>>>>>>>>>> not valid.
>>>>>>>>>>>
>>>>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>>>>> answer
>>>>>>>>>>> you get by actually running the machiine P(I), we can show that
>>>>>>>>>>> this
>>>>>>>>>>> transform is NOT valid for the conventional Halting Problem of
>>>>>>>>>>> Computation Theory.
>>>>>>>>>>
>>>>>>>>>> We haven't gotten to the point where running the machine is
>>>>>>>>>> possible.
>>>>>>>>>
>>>>>>>>> You can't have a machine description until you have an actual
>>>>>>>>> machine,
>>>>>>>>> as defined by its state transition table.
>>>>>>>>>
>>>>>>>>> PERIOD.
>>>>>>>>>
>>>>>>>>> Once you have a machine, in the form of a state transition table,
>>>>>>>>> it it
>>>>>>>>> by definition runable. You might not have a program designed to do
>>>>>>>>> this,
>>>>>>>>> but once a Turing Machine is specified, it is runable. At worse, a
>>>>>>>>> person can step through it manually.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Before we can possibly run the machine we have to define and
>>>>>>>>>> validate
>>>>>>>>>> the architectural basis for a simulating halt decider that
>>>>>>>>>> correctly
>>>>>>>>>> decides inputs having the pathological self-reference error(Olcott
>>>>>>>>>> 2004).
>>>>>>>>>>
>>>>>>>>>> https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG. A Turing Machine, once it has been 'described' as a State
>>>>>>>>> Transition Table, is runable. That has ALL the information
>>>>>>>>> needed to
>>>>>>>>> do so.
>>>>>>>>
>>>>>>>> Yes, however you were running P(I) before it was even defined at the
>>>>>>>> architectural level of detail:
>>>>>>>
>>>>>>> But then you can't simulate it either.
>>>>>>>
>>>>>>> Note, and you're not going to like this, this is exactly the
>>>>>>> statements
>>>>>>> you DO make about H^, and we KNOW that H^(H^) is a finite halting
>>>>>>> computation when we actually run it. You try to force your broken
>>>>>>> logic
>>>>>>> fumblings to have precedence over the actual operation of the
>>>>>>> machine.
>>>>>>>
>>>>>>> In one sense, you HAVE poisoned this well, and if you want to try
>>>>>>> to go
>>>>>>> over it again, you need to do something to make it very clear that
>>>>>>> you
>>>>>>> aren't just trying to reuse your old disproven logic.
>>>>>>>
>>>>>>>>
>>>>>>>> On 5/23/2021 2:47 PM, Richard Damon wrote:
>>>>>>>>> Since this says that the answer you get differs from that basic
>>>>>>>>> answer
>>>>>>>>> you get by actually running the machine P(I),
>>>>>>>>
>>>>>>>> We must proceed through every aspect of the architectural level of
>>>>>>>> detail long before the details of any set of state transitions can
>>>>>>>> possibly be inferred.
>>>>>>>
>>>>>>> But that isn't what you SAID you were doing.
>>>>>>>
>>>>>>> You claimed at the end that this now what you are saying is not yet
>>>>>>> existent decider, got the right answer. You Whole logic is flawed by
>>>>>>> presuming that such a decider is possible to create.
>>>>>>>
>>>>>>> Note, this is different then the Linz proof, which begins with a
>>>>>>> hypothetical assumption, but remembers it is under a hypothetical,
>>>>>>> and
>>>>>>> thus possibly not existing case, and then showing that having such an
>>>>>>> assumption leads to an impossibility. THAT is a valid logic form.
>>>>>>>
>>>>>>> Assuming something to exist, and then 'proving' that it exists from
>>>>>>> that
>>>>>>> is not.
>>>>>>>
>>>>>>
>>>>>> My proof begins after page 319 of the Linz proof before page 320 of
>>>>>> the
>>>>>> Linz proof.
>>>>>>
>>>>>> We cannot begin my proof until after we define and validate every
>>>>>> detail
>>>>>> of the architectural design of the simulating halt decider that
>>>>>> correctly decides inputs having the pathological self-reference
>>>>>> error in
>>>>>> V9.
>>>>>>
>>>>>>>>
>>>>>>>>> Remember, Turing Machines are theoretical constructs, NOT
>>>>>>>>> 'physical'
>>>>>>>>> machines. Once 'defined' all there properties, like halting
>>>>>>>>> behavior is
>>>>>>>>> fixed (which is one of the flaws of you 'proxie argument')
>>>>>>>>>
>>>>>>>>> It is in fact impossible to make a physical machine that can act
>>>>>>>>> as a
>>>>>>>>> TRUE Universal Turing Machine runner, as Turing Machines are
>>>>>>>>> potentially
>>>>>>>>> unbounded, and the physical universe is bounded.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> In another post you said:
>>>>>>>
>>>>>>>>> When input P invokes embedded simulating halt decider H on itself H
>>>>>>>>> creates proxy input P2 replacing H with simulator S. >
>>>>>>>> This is the same thing as H simply excluding its own execution from
>>>>>>>> halting analysis as was done with Halts((u32)H_Hat, (u32)H_Hat);
>>>>>>>
>>>>>>> And I will ask you, why does it make sense to exclude looking at a
>>>>>>> significant piece of a Turing Machine to see how it behaves?
>>>>>>>
>>>>>>> Why does the behavior of a DIFFERENT behaving Turing Machine tell you
>>>>>>> anything about another machine.
>>>>>>>
>>>>>>> This is like critiquing and 3 hour play after watching the first 3
>>>>>>> minutes and then leaving.
>>>>>>
>>>>>> You keep skipping the steps of this. You have to read the steps of my
>>>>>> proof with enough focused concentration as if these steps may actually
>>>>>> be correct. It may take two hours per half page. (V9) is the key half
>>>>>> page.
>>>>>>
>>>>>>
>>>>>
>>>>> No. I read it, understand it and see the errors in it.
>>>>>
>>>>> For instance, one BIG problem is how does H recognize copies of itself
>>>>> in P?
>>>>
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>
>>>> We are only talking about the simulating halt decider at state Ĥ.qx
>>>> invoking its actual self in the computation Ĥ([Ĥ]).
>>>
>>> And, as already previously mentioned, this NEVER happens. Your H NEVER
>>
>> There is no freaking H. I am stopping here.
>
> H^ is based on H, and H^.qx is the q0 of H and H^.qy is the qy of H and
> H^.qn is the qn of H. THAT is the definition of H.
>

On 5/25/21 10:04 AM, olcott wrote:
> On 5/25/2021 6:10 AM, Richard Damon wrote:
>> On 5/24/21 10:04 PM, olcott wrote:
>>> On 5/24/2021 7:39 PM, Richard Damon wrote:
>>>>
>>>> And, as already previously mentioned, this NEVER happens. Your H NEVER
>>>
>>> There is no freaking H. I am stopping here.
>>
>> H^ is based on H, and H^.qx is the q0 of H and H^.qy is the qy of H and
>> H^.qn is the qn of H. THAT is the definition of H.
>>
>
> Sure that was your mistake the required cutting off discussion. Once you
> base the rest of your discussion on a false assumption we must stop.

See below. It is NOT a mistake.

H still exsits, as Turing Machines are eternal.

If H cease to be important, than H^ has no purpose, as its ONLY purpose
is to confound H. It means NOTHING if some other machine can decide it.

Now, Shall I hold you at your word and complain 'foul' if you resurrect
H after declaring it to be no more?

>
>> If there is no H then there is no H^ to talk about, so there is no truth
>> in the proof, and no intelligence in Peter Olcott.
>
> After H has been copied to Ĥ.qx it is no longer called H. By referring
> to H you are referring to a different computation that I am not
> referring to. H([Ĥ],[Ĥ]) is a different computation than Ĥ([Ĥ]).

Turing Machine NEVER go away. Once created they are eternal.

Also, once you throw away H, then H^ has no more purpose, because H is
the ONLY machine that H^ is designed to confound. It means NOTHING to
prove that any other decider can decide H^, that is perfectly allowed by
the proof. ONLY H is confounded.

If you have some other Halt Decider you wish to claim can pass the Linz
test, you need to make the ^ version o THAT machine.

>
>>
>> If you want to ignore that H^ got that code from H, then how does H^
>> identify itself on the tape?
>>
>
> In the typical case machines comprised of finite states are referenced
> by their integer ordinal in the set of finite states. It is the
> equivalent of their machine address.

Except that the numbering is NOT unique, so you have AT LEAST N!
representtions. Also, state N of one machine doesn't necessarily match
state N of another, so you can't use 'address match' to detect that you
are in the same machine.

>
>> That is still an impossible task.
>>
>>
>
>

On 5/25/2021 6:19 PM, Richard Damon wrote:
> On 5/25/21 10:04 AM, olcott wrote:
>> On 5/25/2021 6:10 AM, Richard Damon wrote:
>>> On 5/24/21 10:04 PM, olcott wrote:
>>>> On 5/24/2021 7:39 PM, Richard Damon wrote:
>>>>>
>>>>> And, as already previously mentioned, this NEVER happens. Your H NEVER
>>>>
>>>> There is no freaking H. I am stopping here.
>>>
>>> H^ is based on H, and H^.qx is the q0 of H and H^.qy is the qy of H and
>>> H^.qn is the qn of H. THAT is the definition of H.
>>>
>>
>> Sure that was your mistake the required cutting off discussion. Once you
>> base the rest of your discussion on a false assumption we must stop.
>
> See below. It is NOT a mistake.
>
> H still exsits, as Turing Machines are eternal.
>
> If H cease to be important, than H^ has no purpose, as its ONLY purpose
> is to confound H. It means NOTHING if some other machine can decide it.
>

The computation H([Ĥ],[Ĥ]) is twice as complex as the Ĥ([Ĥ]) computation
because the former requires analyzing the effects of two halt deciders
on each other.

> Now, Shall I hold you at your word and complain 'foul' if you resurrect
> H after declaring it to be no more?
>
>>
>>> If there is no H then there is no H^ to talk about, so there is no truth
>>> in the proof, and no intelligence in Peter Olcott.
>>
>> After H has been copied to Ĥ.qx it is no longer called H. By referring
>> to H you are referring to a different computation that I am not
>> referring to. H([Ĥ],[Ĥ]) is a different computation than Ĥ([Ĥ]).
>
> Turing Machine NEVER go away. Once created they are eternal.
>
> Also, once you throw away H, then H^ has no more purpose, because H is
> the ONLY machine that H^ is designed to confound. It means NOTHING to
> prove that any other decider can decide H^, that is perfectly allowed by
> the proof. ONLY H is confounded.
>
> If you have some other Halt Decider you wish to claim can pass the Linz
> test, you need to make the ^ version o THAT machine.
>
>>
>>>
>>> If you want to ignore that H^ got that code from H, then how does H^
>>> identify itself on the tape?
>>>
>>
>> In the typical case machines comprised of finite states are referenced
>> by their integer ordinal in the set of finite states. It is the
>> equivalent of their machine address.
>
> Except that the numbering is NOT unique, so you have AT LEAST N!
> representtions. Also, state N of one machine doesn't necessarily match
> state N of another, so you can't use 'address match' to detect that you
> are in the same machine.
>
>>
>>> That is still an impossible task.
>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 5/25/21 8:17 PM, olcott wrote:
> On 5/25/2021 6:19 PM, Richard Damon wrote:
>>
>> H still exsits, as Turing Machines are eternal.
>>
>> If H cease to be important, than H^ has no purpose, as its ONLY purpose
>> is to confound H. It means NOTHING if some other machine can decide it.
>>
>
> The computation H([Ĥ],[Ĥ]) is twice as complex as the Ĥ([Ĥ]) computation
> because the former requires analyzing the effects of two halt deciders
> on each other.
>

It CAN'T be because H^([H^]) includes as part of it H([H^],[H^])

Only by not actually looking at the machine can you make such a claim,
which is why you are wrong.

THAT is the core of your problem, you NEED to change something to a
nob-equivlent 'equivalent' to pull of your deception.

That is the FLAW with your proxy argument.

On 5/25/2021 8:50 PM, Richard Damon wrote:
> On 5/25/21 8:17 PM, olcott wrote:
>> On 5/25/2021 6:19 PM, Richard Damon wrote:
>>>
>>> H still exsits, as Turing Machines are eternal.
>>>
>>> If H cease to be important, than H^ has no purpose, as its ONLY purpose
>>> is to confound H. It means NOTHING if some other machine can decide it.
>>>
>>
>> The computation H([Ĥ],[Ĥ]) is twice as complex as the Ĥ([Ĥ]) computation
>> because the former requires analyzing the effects of two halt deciders
>> on each other.
>>
>
> It CAN'T be because H^([H^]) includes as part of it H([H^],[H^])
>
> Only by not actually looking at the machine can you make such a claim,
> which is why you are wrong.
>
>

You just don't understand these things well enough.
Maybe Ben or Kaz can explain to you the no TM is ever searching for any
name to know what state to transition to.

> THAT is the core of your problem, you NEED to change something to a
> nob-equivlent 'equivalent' to pull of your deception.
>
> That is the FLAW with your proxy argument.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein