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

We are proposing that when an input P has an embedded simulating halt
decider H we can replace H with Simulator S defining proxy input P2.

When the original simulating halt decider H decides halting on the proxy
input P2 this decision can be correctly used as a proxy decision for the
original input.

The following analyzes why we can replace the invocations of halt
decider H embedded in input P with a simulator S defining input S2 as
the proxy halt deciding basis for deciding P.

The following must be analyzed at the architectural level of detail
ignoring how an embedded simulating halt decider is recognized and
replaced. These issues become moot at the next level of analysis.

(a) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that halt.

(b) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that do not halt up to the point where H
stops simulating P.

(c) When we replace embedded halt decider H in input P with embedded
simulator S defining proxy input P2 and the simulation of P2 halts
because of (a) we can know that H would decide halting on P.

(d) When we replace embedded halt decider H in input P with an embedded
simulator S defining proxy input P2 and the simulation of P2 does not
halt because of (b) we can know that H would decide not halting on P.

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

Constantly updated:
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

*Halting problem undecidability and infinitely nested simulation*

When input P to simulating halt decider H has the pathological
self-reference error (PSRE) simulating halt decider H decides this input
P on the basis of proxy input P2 that has the pathological
self-reference error removed.

void H_Hat(u32 P)
{ u32 Input_Halts = Halts(P, P);
if (Input_Halts)
HERE: goto HERE;
}

The pathological self-reference error arises in the halting theorem from
the fact that both return values: {0, 1} from Halts() to H_Hat() are
incorrect when H_Hat() is invoked with its own machine address as input.

The above input is defined to immediately halt if the halt decider
decides that it will never halt and to run forever when the halt decider
decides that it will halt.

In computability theory and computational complexity theory, a decision
problem is a problem that can be posed as a yes-no question of the input
values. (Wikipedia: Decision problem)

Every decision problem: Question/Input lacking a correct yes/no return
value is incorrect.

A yes or no question lacking a correct yes or no answer is an incorrect
question. When an incorrect question is translated into a correct
equivalent question then the original question can be answered by its
equivalent proxy question.

When define H_Hat2() by replacing the call to Halts() with a call to
Simulate()

u32 Simulate(u32 P, u32 I)
{ ((void(*)(int))P)(I);
return 1;
}

H_Hat2() never halts on its own machine address as input.
This key fact is leveraged to correctly decide halting:
Halts((u32)H_Hat, (u32)H_Hat);

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.

The following will analyze the generic notion of proxy inputs P2 to
undecidable halting problem instances thus showing that H_Hat2() is such
a proxy input for input H_Hat().

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

We are proposing that when an input P has an embedded simulating halt
decider H we can replace H with Simulator S defining proxy input P2.

When the original simulating halt decider H decides halting on the proxy
input P2 this decision can be correctly used as a proxy decision for the
original input.

The following analyzes why we can replace the invocations of halt
decider H embedded in input P with a simulator S defining input S2 as
the proxy halt deciding basis for deciding P.

The following must be analyzed at the architectural level of detail
ignoring how an embedded simulating halt decider is recognized and
replaced. These issues become moot at the next level of analysis.

(a) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that halt.

(b) Simulating halt decider H and simulator S are equivalent
computations for all inputs P that do not halt up to the point where H
stops simulating P.

(c) When we replace embedded halt decider H in input P with embedded
simulator S defining proxy input P2 and the simulation of P2 halts
because of (a) we can know that H would decide halting on P.

(d) When we replace embedded halt decider H in input P with an embedded
simulator S defining proxy input P2 and the simulation of P2 does not
halt because of (b) we can know that H would decide not halting on P.

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

--
Copyright 2021 Pete Olcott

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

On 5/24/21 2:43 PM, olcott wrote:
> Generic halt deciding principle for inputs having the pathological
> self-reference error
>
> We are proposing that when an input P has an embedded simulating halt
> decider H we can replace H with Simulator S defining proxy input P2.
>
> When the original simulating halt decider H decides halting on the proxy
> input P2 this decision can be correctly used as a proxy decision for the
> original input.
>
> The following analyzes why we can replace the invocations of halt
> decider H embedded in input P with a simulator S defining input S2 as
> the proxy halt deciding basis for deciding P.
>
> The following must be analyzed at the architectural level of detail
> ignoring how an embedded simulating halt decider is recognized and
> replaced. These issues become moot at the next level of analysis.
>
> (a) Simulating halt decider H and simulator S are equivalent
> computations for all inputs P that halt.

Somewhat. The time to halt, which normally isn't important, can change,
so this rule can only be applied a finite number of times.

>
> (b) Simulating halt decider H and simulator S are equivalent
> computations for all inputs P that do not halt up to the point where H
> stops simulating P.

BUT DOES affect the computation after that.

>
> (c) When we replace embedded halt decider H in input P with embedded
> simulator S defining proxy input P2 and the simulation of P2 halts
> because of (a) we can know that H would decide halting on P.

Only as long as this was done only a finite number of times in the
execution path. The addition of a finite amount of work doesn't affect
the time to finish, but doing that in infinite number of times does.

The replacement of a call to H(P,I) with P(I) which calls H(P,I) is a
case where the substitution adds time, thus we need to apply this only a
finite number of times.

Since you have done this an infinite number of times, you substitution
is invalid.

>
> (d) When we replace embedded halt decider H in input P with an embedded
> simulator S defining proxy input P2 and the simulation of P2 does not
> halt because of (b) we can know that H would decide not halting on P.

BUT, if P decides not-Halting this action changes the behavior of the
machine that H was in,
>
> Because of the above simulating halt decider H decides input P having
> the pathological self-reference error on the basis of the proxy input P2
> having the pathological self-reference error removed.
>
> Constantly updated:
> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>
>

You STILL haven't shown how you will detect the nested H to do the
substitution or the nested recursion as real Turing machines, so even if
you did make this proof, you don't have you answer yet, so you are
premature.

We can also demonstart that this logic MUST be flawed as we do have that
the H^(H^) logic that this tries to say in non-halting is halting, and
that H2 and H1 disgree on the halting status of H1^(H1^)

I have pointed out above WHY this logic is broken.

On 5/24/2021 9:43 PM, Richard Damon wrote:
> On 5/24/21 2:43 PM, olcott wrote:
>> Generic halt deciding principle for inputs having the pathological
>> self-reference error
>>
>> We are proposing that when an input P has an embedded simulating halt
>> decider H we can replace H with Simulator S defining proxy input P2.
>>
>> When the original simulating halt decider H decides halting on the proxy
>> input P2 this decision can be correctly used as a proxy decision for the
>> original input.
>>
>> The following analyzes why we can replace the invocations of halt
>> decider H embedded in input P with a simulator S defining input S2 as
>> the proxy halt deciding basis for deciding P.
>>
>> The following must be analyzed at the architectural level of detail
>> ignoring how an embedded simulating halt decider is recognized and
>> replaced. These issues become moot at the next level of analysis.
>>
>> (a) Simulating halt decider H and simulator S are equivalent
>> computations for all inputs P that halt.
>
> Somewhat. The time to halt, which normally isn't important, can change,
> so this rule can only be applied a finite number of times.

Equivalent does not mean identical.

It can be 100 million times slower and still be an equivalent computation.

>
>>
>> (b) Simulating halt decider H and simulator S are equivalent
>> computations for all inputs P that do not halt up to the point where H
>> stops simulating P.
>
> BUT DOES affect the computation after that.

Yes

>
>>
>> (c) When we replace embedded halt decider H in input P with embedded
>> simulator S defining proxy input P2 and the simulation of P2 halts
>> because of (a) we can know that H would decide halting on P.
>
> Only as long as this was done only a finite number of times in the
> execution path. The addition of a finite amount of work doesn't affect
> the time to finish, but doing that in infinite number of times does.
>

The test case is one substitution.

> The replacement of a call to H(P,I) with P(I) which calls H(P,I) is a
> case where the substitution adds time, thus we need to apply this only a
> finite number of times.
>
> Since you have done this an infinite number of times, you substitution
> is invalid.

You just don't understand these things well enough.

>>
>> (d) When we replace embedded halt decider H in input P with an embedded
>> simulator S defining proxy input P2 and the simulation of P2 does not
>> halt because of (b) we can know that H would decide not halting on P.
>
> BUT, if P decides not-Halting this action changes the behavior of the
> machine that H was in,
>>
>> Because of the above simulating halt decider H decides input P having
>> the pathological self-reference error on the basis of the proxy input P2
>> having the pathological self-reference error removed.
>>
>> Constantly updated:
>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>>
>>
>
> You STILL haven't shown how you will detect the nested H to do the
> substitution or the nested recursion as real Turing machines, so even if
> you did make this proof, you don't have you answer yet, so you are
> premature.
>
> We can also demonstart that this logic MUST be flawed as we do have that
> the H^(H^) logic that this tries to say in non-halting is halting, and
> that H2 and H1 disgree on the halting status of H1^(H1^)
>
> I have pointed out above WHY this logic is broken.
>

--
Copyright 2021 Pete Olcott

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

On 5/24/21 11:43 PM, olcott wrote:
> On 5/24/2021 9:43 PM, Richard Damon wrote:
>> On 5/24/21 2:43 PM, olcott wrote:
>>> Generic halt deciding principle for inputs having the pathological
>>> self-reference error
>>>
>>> We are proposing that when an input P has an embedded simulating halt
>>> decider H we can replace H with Simulator S defining proxy input P2.
>>>
>>> When the original simulating halt decider H decides halting on the proxy
>>> input P2 this decision can be correctly used as a proxy decision for the
>>> original input.
>>>
>>> The following analyzes why we can replace the invocations of halt
>>> decider H embedded in input P with a simulator S defining input S2 as
>>> the proxy halt deciding basis for deciding P.
>>>
>>> The following must be analyzed at the architectural level of detail
>>> ignoring how an embedded simulating halt decider is recognized and
>>> replaced. These issues become moot at the next level of analysis.
>>>
>>> (a) Simulating halt decider H and simulator S are equivalent
>>> computations for all inputs P that halt.
>>
>> Somewhat. The time to halt, which normally isn't important, can change,
>> so this rule can only be applied a finite number of times.
>
> Equivalent does not mean identical.
>
> It can be 100 million times slower and still be an equivalent computation.

Right, but if the change adds 1 unit of time, and you do that in
infinite number of times, then you make finite infinite

>
>>
>>>
>>> (b) Simulating halt decider H and simulator S are equivalent
>>> computations for all inputs P that do not halt up to the point where H
>>> stops simulating P.
>>
>> BUT DOES affect the computation after that.
>
> Yes
>
>>
>>>
>>> (c) When we replace embedded halt decider H in input P with embedded
>>> simulator S defining proxy input P2 and the simulation of P2 halts
>>> because of (a) we can know that H would decide halting on P.
>>
>> Only as long as this was done only a finite number of times in the
>> execution path. The addition of a finite amount of work doesn't affect
>> the time to finish, but doing that in infinite number of times does.
>>
>
> The test case is one substitution.

NO. You can't edit the input tape, as that changes the input and you
test the wrong program. You can't decide about black cats by studing
rainbow cats.

The alteration has to be done at execution, each level individual, at
least when counting the effect.

>
>> The replacement of a call to H(P,I) with P(I) which calls H(P,I) is a
>> case where the substitution adds time, thus we need to apply this only a
>> finite number of times.
>>
>> Since you have done this an infinite number of times, you substitution
>> is invalid.
>
> You just don't understand these things well enough.

NO YOU WON'T UNDERSTAND.

Can you actually PROVE what you claim.

NO. You are just making a rhetorical argument about it.

Do you have an actual PROVEN theory that says you can do the operatons
you are wanting to do. Not just claimed to be right by what sounds
right, but ACTAUL proofs.

NO.

THIS IS WHY YOUR LOGIC IS INCONSISTENT. (See below)

>
>>>
>>> (d) When we replace embedded halt decider H in input P with an embedded
>>> simulator S defining proxy input P2 and the simulation of P2 does not
>>> halt because of (b) we can know that H would decide not halting on P.
>>
>> BUT, if P decides not-Halting this action changes the behavior of the
>> machine that H was in,
>>>
>>> Because of the above simulating halt decider H decides input P having
>>> the pathological self-reference error on the basis of the proxy input P2
>>> having the pathological self-reference error removed.
>>>
>>> Constantly updated:
>>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>>>
>>>
>>>
>>
>> You STILL haven't shown how you will detect the nested H to do the
>> substitution or the nested recursion as real Turing machines, so even if
>> you did make this proof, you don't have you answer yet, so you are
>> premature.
>>
>> We can also demonstart that this logic MUST be flawed as we do have that
>> the H^(H^) logic that this tries to say in non-halting is halting, and
>> that H2 and H1 disgree on the halting status of H1^(H1^)
>>
>> I have pointed out above WHY this logic is broken.
>>
>
>

On 5/24/2021 11:01 PM, Richard Damon wrote:
> On 5/24/21 11:43 PM, olcott wrote:
>> On 5/24/2021 9:43 PM, Richard Damon wrote:
>>> On 5/24/21 2:43 PM, olcott wrote:
>>>> Generic halt deciding principle for inputs having the pathological
>>>> self-reference error
>>>>
>>>> We are proposing that when an input P has an embedded simulating halt
>>>> decider H we can replace H with Simulator S defining proxy input P2.
>>>>
>>>> When the original simulating halt decider H decides halting on the proxy
>>>> input P2 this decision can be correctly used as a proxy decision for the
>>>> original input.
>>>>
>>>> The following analyzes why we can replace the invocations of halt
>>>> decider H embedded in input P with a simulator S defining input S2 as
>>>> the proxy halt deciding basis for deciding P.
>>>>
>>>> The following must be analyzed at the architectural level of detail
>>>> ignoring how an embedded simulating halt decider is recognized and
>>>> replaced. These issues become moot at the next level of analysis.
>>>>
>>>> (a) Simulating halt decider H and simulator S are equivalent
>>>> computations for all inputs P that halt.
>>>
>>> Somewhat. The time to halt, which normally isn't important, can change,
>>> so this rule can only be applied a finite number of times.
>>
>> Equivalent does not mean identical.
>>
>> It can be 100 million times slower and still be an equivalent computation.
>
> Right, but if the change adds 1 unit of time, and you do that in
> infinite number of times, then you make finite infinite
>
>>
>>>
>>>>
>>>> (b) Simulating halt decider H and simulator S are equivalent
>>>> computations for all inputs P that do not halt up to the point where H
>>>> stops simulating P.
>>>
>>> BUT DOES affect the computation after that.
>>
>> Yes
>>
>>>
>>>>
>>>> (c) When we replace embedded halt decider H in input P with embedded
>>>> simulator S defining proxy input P2 and the simulation of P2 halts
>>>> because of (a) we can know that H would decide halting on P.
>>>
>>> Only as long as this was done only a finite number of times in the
>>> execution path. The addition of a finite amount of work doesn't affect
>>> the time to finish, but doing that in infinite number of times does.
>>>
>>
>> The test case is one substitution.
>
> NO. You can't edit the input tape, as that changes the input and you
> test the wrong program. You can't decide about black cats by studing
> rainbow cats.
>
> The alteration has to be done at execution, each level individual, at
> least when counting the effect.
>

We don't actually do any substitution at all, but you have to totally
understand every detail of how this substitution would make H_Hat()
decidable before you will be able to understand the rest of the proof
after this part.

>>
>>> The replacement of a call to H(P,I) with P(I) which calls H(P,I) is a
>>> case where the substitution adds time, thus we need to apply this only a
>>> finite number of times.
>>>
>>> Since you have done this an infinite number of times, you substitution
>>> is invalid.
>>
>> You just don't understand these things well enough.
>
> NO YOU WON'T UNDERSTAND.
>
> Can you actually PROVE what you claim.
>
> NO. You are just making a rhetorical argument about it.
>
> Do you have an actual PROVEN theory that says you can do the operatons
> you are wanting to do. Not just claimed to be right by what sounds
> right, but ACTAUL proofs.
>
> NO.
>
> THIS IS WHY YOUR LOGIC IS INCONSISTENT. (See below)
>
>>
>>>>
>>>> (d) When we replace embedded halt decider H in input P with an embedded
>>>> simulator S defining proxy input P2 and the simulation of P2 does not
>>>> halt because of (b) we can know that H would decide not halting on P.
>>>
>>> BUT, if P decides not-Halting this action changes the behavior of the
>>> machine that H was in,
>>>>
>>>> Because of the above simulating halt decider H decides input P having
>>>> the pathological self-reference error on the basis of the proxy input P2
>>>> having the pathological self-reference error removed.
>>>>
>>>> Constantly updated:
>>>> http://www.liarparadox.org/Halting_problem_undecidability_and_infinitely_nested_simulation.pdf
>>>>
>>>>
>>>>
>>>
>>> You STILL haven't shown how you will detect the nested H to do the
>>> substitution or the nested recursion as real Turing machines, so even if
>>> you did make this proof, you don't have you answer yet, so you are
>>> premature.
>>>
>>> We can also demonstart that this logic MUST be flawed as we do have that
>>> the H^(H^) logic that this tries to say in non-halting is halting, and
>>> that H2 and H1 disgree on the halting status of H1^(H1^)
>>>
>>> I have pointed out above WHY this logic is broken.
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

On 5/25/21 12:07 AM, olcott wrote:
> On 5/24/2021 11:01 PM, Richard Damon wrote:
>> On 5/24/21 11:43 PM, olcott wrote:
>>> On 5/24/2021 9:43 PM, Richard Damon wrote:
>>>> On 5/24/21 2:43 PM, olcott wrote:
>>>>> Generic halt deciding principle for inputs having the pathological
>>>>> self-reference error
>>>>>
>>>>> We are proposing that when an input P has an embedded simulating halt
>>>>> decider H we can replace H with Simulator S defining proxy input P2.
>>>>>
>>>>> When the original simulating halt decider H decides halting on the
>>>>> proxy
>>>>> input P2 this decision can be correctly used as a proxy decision
>>>>> for the
>>>>> original input.
>>>>>
>>>>> The following analyzes why we can replace the invocations of halt
>>>>> decider H embedded in input P with a simulator S defining input S2 as
>>>>> the proxy halt deciding basis for deciding P.
>>>>>
>>>>> The following must be analyzed at the architectural level of detail
>>>>> ignoring how an embedded simulating halt decider is recognized and
>>>>> replaced. These issues become moot at the next level of analysis.
>>>>>
>>>>> (a) Simulating halt decider H and simulator S are equivalent
>>>>> computations for all inputs P that halt.
>>>>
>>>> Somewhat. The time to halt, which normally isn't important, can change,
>>>> so this rule can only be applied a finite number of times.
>>>
>>> Equivalent does not mean identical.
>>>
>>> It can be 100 million times slower and still be an equivalent
>>> computation.
>>
>> Right, but if the change adds 1 unit of time, and you do that in
>> infinite number of times, then you make finite infinite
>>
>>>
>>>>
>>>>>
>>>>> (b) Simulating halt decider H and simulator S are equivalent
>>>>> computations for all inputs P that do not halt up to the point where H
>>>>> stops simulating P.
>>>>
>>>> BUT DOES affect the computation after that.
>>>
>>> Yes
>>>
>>>>
>>>>>
>>>>> (c) When we replace embedded halt decider H in input P with embedded
>>>>> simulator S defining proxy input P2 and the simulation of P2 halts
>>>>> because of (a) we can know that H would decide halting on P.
>>>>
>>>> Only as long as this was done only a finite number of times in the
>>>> execution path. The addition of a finite amount of work doesn't affect
>>>> the time to finish, but doing that in infinite number of times does.
>>>>
>>>
>>> The test case is one substitution.
>>
>> NO. You can't edit the input tape, as that changes the input and you
>> test the wrong program. You can't decide about black cats by studing
>> rainbow cats.
>>
>> The alteration has to be done at execution, each level individual, at
>> least when counting the effect.
>>
>
> We don't actually do any substitution at all, but you have to totally
> understand every detail of how this substitution would make H_Hat()
> decidable before you will be able to understand the rest of the proof
> after this part.
>

Whether you actually change the code or not, you still need to apply
this rule. If you apply it an infinite number of times, then the
operation is invalid.

Since each level of simulation is a distinct level and a distinct
operation you have to add up all the changes, so you get the infinte number.

It isn't that changing cost time, it is that the change adds time to the
run, and thus can only be done a bounded number of times.

On 5/25/2021 5:37 AM, Richard Damon wrote:
> On 5/25/21 12:07 AM, olcott wrote:
>> On 5/24/2021 11:01 PM, Richard Damon wrote:
>>> On 5/24/21 11:43 PM, olcott wrote:
>>>> On 5/24/2021 9:43 PM, Richard Damon wrote:
>>>>> On 5/24/21 2:43 PM, olcott wrote:
>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>> self-reference error
>>>>>>
>>>>>> We are proposing that when an input P has an embedded simulating halt
>>>>>> decider H we can replace H with Simulator S defining proxy input P2.
>>>>>>
>>>>>> When the original simulating halt decider H decides halting on the
>>>>>> proxy
>>>>>> input P2 this decision can be correctly used as a proxy decision
>>>>>> for the
>>>>>> original input.
>>>>>>
>>>>>> The following analyzes why we can replace the invocations of halt
>>>>>> decider H embedded in input P with a simulator S defining input S2 as
>>>>>> the proxy halt deciding basis for deciding P.
>>>>>>
>>>>>> The following must be analyzed at the architectural level of detail
>>>>>> ignoring how an embedded simulating halt decider is recognized and
>>>>>> replaced. These issues become moot at the next level of analysis.
>>>>>>
>>>>>> (a) Simulating halt decider H and simulator S are equivalent
>>>>>> computations for all inputs P that halt.
>>>>>
>>>>> Somewhat. The time to halt, which normally isn't important, can change,
>>>>> so this rule can only be applied a finite number of times.
>>>>
>>>> Equivalent does not mean identical.
>>>>
>>>> It can be 100 million times slower and still be an equivalent
>>>> computation.
>>>
>>> Right, but if the change adds 1 unit of time, and you do that in
>>> infinite number of times, then you make finite infinite
>>>
>>>>
>>>>>
>>>>>>
>>>>>> (b) Simulating halt decider H and simulator S are equivalent
>>>>>> computations for all inputs P that do not halt up to the point where H
>>>>>> stops simulating P.
>>>>>
>>>>> BUT DOES affect the computation after that.
>>>>
>>>> Yes
>>>>
>>>>>
>>>>>>
>>>>>> (c) When we replace embedded halt decider H in input P with embedded
>>>>>> simulator S defining proxy input P2 and the simulation of P2 halts
>>>>>> because of (a) we can know that H would decide halting on P.
>>>>>
>>>>> Only as long as this was done only a finite number of times in the
>>>>> execution path. The addition of a finite amount of work doesn't affect
>>>>> the time to finish, but doing that in infinite number of times does.
>>>>>
>>>>
>>>> The test case is one substitution.
>>>
>>> NO. You can't edit the input tape, as that changes the input and you
>>> test the wrong program. You can't decide about black cats by studing
>>> rainbow cats.
>>>
>>> The alteration has to be done at execution, each level individual, at
>>> least when counting the effect.
>>>
>>
>> We don't actually do any substitution at all, but you have to totally
>> understand every detail of how this substitution would make H_Hat()
>> decidable before you will be able to understand the rest of the proof
>> after this part.
>>
>
> Whether you actually change the code or not, you still need to apply
> this rule. If you apply it an infinite number of times, then the
> operation is invalid.
>

We are imagining what would happen if we changed an actual copy of the
input an run the simulating halt decider on this copy.

> Since each level of simulation is a distinct level and a distinct
> operation you have to add up all the changes, so you get the infinte number.
>

We are imagining that we are modifying the actual Turing machine
description that only has a single instance of a simulating halt
decider. How the Hell you think this is any infinite process seems
absurd to me.

> It isn't that changing cost time, it is that the change adds time to the
> run, and thus can only be done a bounded number of times.
>

With Turing machines it is perfectly OK if a computation takes a
Googolplex of Kalpas before ending. It doesn't even matter that the heat
death of the universe is projected to come much much sooner than that.

https://en.wikipedia.org/wiki/Googolplex

https://en.wikipedia.org/wiki/Kalpa_(aeon)

--
Copyright 2021 Pete Olcott

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

On 5/25/21 9:55 AM, olcott wrote:
> On 5/25/2021 5:37 AM, Richard Damon wrote:
>> On 5/25/21 12:07 AM, olcott wrote:
>>> On 5/24/2021 11:01 PM, Richard Damon wrote:
>>>> On 5/24/21 11:43 PM, olcott wrote:
>>>>> On 5/24/2021 9:43 PM, Richard Damon wrote:
>>>>>> On 5/24/21 2:43 PM, olcott wrote:
>>>>>>> Generic halt deciding principle for inputs having the pathological
>>>>>>> self-reference error
>>>>>>>
>>>>>>> We are proposing that when an input P has an embedded simulating
>>>>>>> halt
>>>>>>> decider H we can replace H with Simulator S defining proxy input P2.
>>>>>>>
>>>>>>> When the original simulating halt decider H decides halting on the
>>>>>>> proxy
>>>>>>> input P2 this decision can be correctly used as a proxy decision
>>>>>>> for the
>>>>>>> original input.
>>>>>>>
>>>>>>> The following analyzes why we can replace the invocations of halt
>>>>>>> decider H embedded in input P with a simulator S defining input
>>>>>>> S2 as
>>>>>>> the proxy halt deciding basis for deciding P.
>>>>>>>
>>>>>>> The following must be analyzed at the architectural level of detail
>>>>>>> ignoring how an embedded simulating halt decider is recognized and
>>>>>>> replaced. These issues become moot at the next level of analysis.
>>>>>>>
>>>>>>> (a) Simulating halt decider H and simulator S are equivalent
>>>>>>> computations for all inputs P that halt.
>>>>>>
>>>>>> Somewhat. The time to halt, which normally isn't important, can
>>>>>> change,
>>>>>> so this rule can only be applied a finite number of times.
>>>>>
>>>>> Equivalent does not mean identical.
>>>>>
>>>>> It can be 100 million times slower and still be an equivalent
>>>>> computation.
>>>>
>>>> Right, but if the change adds 1 unit of time, and you do that in
>>>> infinite number of times, then you make finite infinite
>>>>
>>>>>
>>>>>>
>>>>>>>
>>>>>>> (b) Simulating halt decider H and simulator S are equivalent
>>>>>>> computations for all inputs P that do not halt up to the point
>>>>>>> where H
>>>>>>> stops simulating P.
>>>>>>
>>>>>> BUT DOES affect the computation after that.
>>>>>
>>>>> Yes
>>>>>
>>>>>>
>>>>>>>
>>>>>>> (c) When we replace embedded halt decider H in input P with embedded
>>>>>>> simulator S defining proxy input P2 and the simulation of P2 halts
>>>>>>> because of (a) we can know that H would decide halting on P.
>>>>>>
>>>>>> Only as long as this was done only a finite number of times in the
>>>>>> execution path. The addition of a finite amount of work doesn't
>>>>>> affect
>>>>>> the time to finish, but doing that in infinite number of times does.
>>>>>>
>>>>>
>>>>> The test case is one substitution.
>>>>
>>>> NO. You can't edit the input tape, as that changes the input and you
>>>> test the wrong program. You can't decide about black cats by studing
>>>> rainbow cats.
>>>>
>>>> The alteration has to be done at execution, each level individual, at
>>>> least when counting the effect.
>>>>
>>>
>>> We don't actually do any substitution at all, but you have to totally
>>> understand every detail of how this substitution would make H_Hat()
>>> decidable before you will be able to understand the rest of the proof
>>> after this part.
>>>
>>
>> Whether you actually change the code or not, you still need to apply
>> this rule. If you apply it an infinite number of times, then the
>> operation is invalid.
>>
>
> We are imagining what would happen if we changed an actual copy of the
> input an run the simulating halt decider on this copy.

Which is figuring out what a black cat does by studying a white dog.

>
>> Since each level of simulation is a distinct level and a distinct
>> operation you have to add up all the changes, so you get the infinte
>> number.
>>
>
> We are imagining that we are modifying the actual Turing machine
> description that only has a single instance of a simulating halt
> decider. How the Hell you think this is any infinite process seems
> absurd to me.

Again, changing the input is looking at the wrong machine. Like
answering about a white dog when asked about a black cat.

>
>> It isn't that changing cost time, it is that the change adds time to the
>> run, and thus can only be done a bounded number of times.
>>
>
> With Turing machines it is perfectly OK if a computation takes a
> Googolplex of Kalpas before ending. It doesn't even matter that the heat
> death of the universe is projected to come much much sooner than that.
>
> https://en.wikipedia.org/wiki/Googolplex
>
> https://en.wikipedia.org/wiki/Kalpa_(aeon)
>

There is a fundamental difference between a very big number and
infinity. THAT is the difference.

Since the transformation is ONLY valid for a bounded number of
iterations, and each iteration introduces another iteration being
needed, you get an unbounded number, and thus the set of transformations
is invalid.

You logic doesn't know how to properly handle things that might be infinite.

This is the common problem with undecidable inputs, they tend to push
you to large numbers that you can't prove to be finite, so you need to
treat them as infinite for what you can do with them, but you can't
prove that are actually infinite.