On 9/21/21 12:55 AM, olcott wrote:
> 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.
>>
>> Once H has the code to abort the simulation loop, and is also still a
>> 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.
>>
>> 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, and a proper Halt Decider on Computation MUST
>
> So in other words a C function with static local data can detect that it
> was called in infinitely nested simulation, yet a TM is not allowed to
> have static local data therefore the C function is strictly more
> powerful than a TM.

Turing Machine do NOT have recursion, so don't have a need to detect it.

Without a call stack, you don't have actual calls so you don't have
recursive calls.

You don't seem to really understand what this is about. I think you can
only think in terms of random access computing machines, and totally
don't understand the others.

>
>> 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.
>>
>
> It seems to me that static local data is allowed as long as the initial
> input consistently derives the same final output.

Again, the question is NOT 'static data', but does the function ALWAYS
return the same answer for the same input.

This includes when looking at the simulations of the input machines,
that simulation needs to accurate represent what the independent machine
does, and the extrapolations of what it WOULD do if the simulation
wasn't aborted (but the function stayed the same) needs to match what
the actual machine did.

Your H fails this, as it assumes an extrapolation of the simulated H's
that differs from that actual behavior of the top level H, thus either H
is inaccurate in its simulation, or isn't a Computation in the simulated
machine, both of which invalidates the results.

>
>> 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.
>>
>> 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.
>>
>
> If Olcott H1 can defeat the Linz trick then so can the Linz H.
> Both must use static local data.

But Linz H is a Turing Machine, so MUST be a computaiton, which it
sounds like you H1 isn't. So No Linz H exists that is its equivalent.

Linz's H can't have 'static local data' in the way that your H does, but
then your H does other things that aren't the way that Turing Machines
do things, one BIG one is the way you specify the 'input' isn't really
equivalent to how the actual Turing Machine is given it, which puts your
H and P not in the same relationship as the Linz H and H^.

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