On 9/20/2021 11:42 PM, Richard Damon wrote:
> On 9/21/21 12:03 AM, olcott wrote:
>> On 9/20/2021 10:21 PM, Richard Damon wrote:
>>> On 9/20/21 10:25 PM, olcott wrote:
>>>> On 9/20/2021 9:12 PM, Richard Damon wrote:
>>>>> On 9/20/21 8:14 PM, olcott wrote:
>>>>>> On 9/20/2021 7:00 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 9/20/2021 5:06 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 9/20/2021 5:00 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> The two machines are already fully operational.
>>>>>>>>>>>> H1 is merely a copy of H.
>>>>>>>>>>> It's deceptive to call your secret C functions "machines".  It
>>>>>>>>>>> hints at
>>>>>>>>>>> the formality a clarity of Turing machines, but a TM that is a
>>>>>>>>>>> copy of
>>>>>>>>>>> another will have exactly the same transfer function (i.e. it
>>>>>>>>>>> will
>>>>>>>>>>> never
>>>>>>>>>>> compute a different result).
>>>>>>>>>>
>>>>>>>>>> Unless one of them has a pathological self-reference relationship
>>>>>>>>>> with
>>>>>>>>>> its input and the other one does not.
>>>>>>>>> No.  I stated a fact (about TMs) that has no exceptions.  Your
>>>>>>>>> secret C
>>>>>>>>> code is another matter, of course.  It's just the deception of
>>>>>>>>> calling
>>>>>>>>> your code a "machine" that I was objecting to.  It gives your
>>>>>>>>> hidden
>>>>>>>>> code an air of formality that it lacks.
>>>>>>>>
>>>>>>>> This is easily proven in a way that you are incapable of
>>>>>>>> understanding.
>>>>>>>
>>>>>>> You can't even write English.  Saying "This is easily proven"
>>>>>>> following
>>>>>>> a quote from me that you are wrong, means you can easily prove what I
>>>>>>> said in the quote -- that you are wrong.  That is indeed the case,
>>>>>>> but
>>>>>>> it is unlikely to be what you meant to say.
>>>>>>>
>>>>>>> Your junk functions are not "machines".  The terms suggests an
>>>>>>> undeserved formality.
>>>>>>>
>>>>>>
>>>>>> void P(u32 x)
>>>>>> {
>>>>>>     if (H(x, x))
>>>>>>       HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> The actual correct x86 emulation of the input to H1(P,P) is different
>>>>>> than the actual correct x86 emulation of the input to H(P,P).
>>>>>
>>>>> Which means that your emulator is broken, or H isn't a Computation.
>>>>>
>>>>> PERIOD.
>>>>>
>>>>
>>>> That would mean that "a computation" cannot possibly determine that it
>>>> has been invoked in infinitely recursive simulation, whereas a C
>>>> function with a a pair of static local variables can.
>>>>
>>>
>>> Right, it can't
>>>
>>> Yep, a C code fragment can easily be a non-computation.
>>>
>>>> This means that a C function can do something that a TM cannot do thus
>>>> making it strictly more powerful than a TM. Since this seems implausible
>>>> I estimate that you are simply wrong.
>>>
>>> Nope.
>>>
>>> The Rule is that there is no COMPUTATION that the C function can do that
>>> a Turing Machine can not do. This is the definition of Turing
>>> Competeness and the Turing Equivalence rule.
>>>
>>
>> Yes a C function can determine that it has been called in infinitely
>> nested simulation only because it is able to maintain static local data
>> that is not erased between nested simulations.
>>
>> If a TM cannot maintain static data between nested simulations then a TM
>> cannot detect when it is within infinitely nested simulations. This
>> makes the C function strictly more powerful than the TM.
>
> Maybe, but it doesn't mean it can COMPUTE something that a Turing
> Machine can, which is the only thing that Computation Theory is
> concerned with.
>
> If it isn't a pure mapping of an input to an output, Computation Theory
> doesn't care about it.
>
>>
>>> Also, any 'complete' program (or complete fragment) that has a well
>>> defined input, can be expressed as a Computation, and thus a Turing
>>> Machine could do the equivalent of it. The key here is COMPLETE. You
>>> function isn't 'Complete' as exection goes outside of it and then comes
>>> back in.
>>
>> Exactly the same way that the simulation of the
>>
>> machine description of a UTM H that simulates
>> the machine description P the simulates
>>
>> machine description of a UTM H that simulates
>> the machine description P the simulates
>>
>> machine description of a UTM H that simulates
>> the machine description P the simulates ...
>>
>> Olcott H can detect when Olcott P is doing this only because Olcott H
>> has static local data the survives nested simulations.
>>
>> If a TM cannot have such static local data then Olcott H is strictly
>> more powerful than Linz H.
>>
>
>
> Right, if H IS just a UTM, then H^ is non-halting, but then H doesn't
> give an answer to the question H(H^,H^), so it can't answer the question.
>

Although Olcott H can watch the nested simulation of itself because it
has static local data Linz Ĥ could not do this if it is not allowed to
have the equivalent of static local data. This would make Olcott H
strictly more powerful that Linz Ĥ, when Linz Ĥ is arbitrarily forbidden
from having its own static local data.

> Once H has the code to abort the simulation loop, and is also still a

We can get here because the Linz Ĥ cannot even get to the point where
the abort criteria is matched because it is forced to erase the
execution data that would show this.

> Computation, then H^ will no longer be stuck in an infinite recursion as
> the H inside it will ALSO do that same abort to keep it out of the loop,
> and H when coming up with its answer needs to take that into account to
> give the right answer.
>

This never happens. Ĥ must see at least two iterations and without
static local data it can at most only see one.

> The fact that you can write a program that can detect this sort of
> recusion doesn't matter to Computation Theory, it is only concerned
> about actual Computations,

It does not make sense that arbitrary rules would allow a C function to
be strictly more powerful than a TM so you must be wrong.

> and a proper Halt Decider on Computation MUST
> be a Computation, as the behavior of a Computaton only depends on the
> Machine/ALgorithm and the Input Data, so ANY decider that changes its
> answer based on something outside that CAN'T be right, by definition, it
> give two different answers for a question that always has the same
> answer, so it MUST be wrong at time.
>

In the case of Olcott H, H merely provides no answer at all until (1) It
has seen a behavior pattern that proves that its input matches a never
halting behavior pattern (2) Its input halts on its own.

> The key here is that if H isn't a Computation, then the 'machine' H^
> isn't either, so Computation Theory doesn't care about what it does.
>

So a halt decider can be made yet it breaks arbitrary rules so no one
cares that a halt decider can be made.

> The Halting Problem of Computation Theory is STRICTLY about actual
> Computations.
>
> If your H ACTUALLY is a correct decider for ALL Turing Machines, then by
> definition it needs to be actually a Computation for ANY Turing Machine
> given to it, and thus, it can be shown that there does actually exist a
> Turing Machine version of it that can take any Turing Machine as an
> input. Since this Turing Machine version IS actually a Computation, we
> can use the Linz ^ trick on it showing that it gets this case wrong.

It doesn't make sense that a C function can be strictly more powerful
that a TM in that it can detect when itself is stuck in finitely nested
simulation and a TM cannot do this because it is not allowed to use
static local memory therefore you are probable wrong.

The function return values are identical for identical arguments (no
variation with local static variables, non-local variables, mutable
reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function

The return values are identical for identical arguments, without static
data there is no return value at all.

>
> The only way we can't do this is if your H isn't a computation for some
> P(I) so that there isn't a Turing Machine equivalent for it, but then
> there are some conditions under which H calls P(I) both Halting and
> Non-Halting, so there are some conditions where it gives the wrong
> answer, so it isn't the Universal Halt Decider that COmputation Theory
> is Looking for.
>

In those cases where H(P,P) gives and answer that is inconsistent with
the behavior of P(P) H1(P,P) gives an answer that is consistent with the
behavior of P(P).

We cannot correctly call this a wrong answer because it is a verifiable
fact that the input to H(P,P) never halts and H correctly reports this.

The inconsistency is not because H(P,P) is wrong, it is because when
H(P,P) aborts the infinitely recursive simulation at any point besides
the first infinitely recursive invocation the sequence ceases to be
infinitely recursive and then the earlier parts of this infinitely
recursive simulation chain come to a halt.

We can know for sure that the whole chain is infinitely recursive when
none of the invocations is ever terminated then the chain never halts.

> Again, note that if Olcott-H is NOT a strict computation when given an
> actual Turing Machine/Input (or equivalent), then BY DEFINTION it must
> be wrong some of the time, as to be a non-computation says that there IS
> some condition where for an actual computation is predicts both Halting
> and Non-Halting for the exact same computation, and thus one of the
> answers MUST be wrong.
>

Self-contradictory inputs derive inconsistent results. The simplest
thing to do is simply detect and reject such inputs.

u32 PSR_Olcott_2004(u32 P)
{ return H1(P,P) != H(P,P);
}

"This sentence is not true" is rejected as a semantically ill-formed
truth bearer on the basis that it is self-contradictory.

"This sentence cannot be proven." is rejected as a semantically
ill-formed truth bearer on the basis that it is self-contradictory.

--
Copyright 2021 Pete Olcott

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