On 9/24/2021 8:27 PM, Richard Damon wrote:
> On 9/24/21 8:48 PM, olcott wrote:
>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>> On 9/24/21 10:49 AM, olcott wrote:
>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>> #include <stdint.h>
>>>>>>>> #define ptr uintptr_t
>>>>>>>>
>>>>>>>> int H(ptr p, ptr i)
>>>>>>>> {
>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>> }
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>      H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>      printf("H is called in infinitely nested emulation = ", H(P,
>>>>>>>> P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>>>>>
>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>> giving
>>>>>>>> them an opportunity to either correct my errors or failing that show
>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>> analyze the
>>>>>>>> problem as presented.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>> called
>>>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>>>> another instance of H with the same parameters. You code does this
>>>>>>> successfully.
>>>>>>>
>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>> decided
>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>> detecting
>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>> 'copy' of
>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>> Linz, as
>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>> limited
>>>>>>> model.
>>>>>>>
>>>>>>
>>>>>> It is sufficiently the same thing in that it implements the essence of
>>>>>> the liar paradox pattern.
>>>>>
>>>>> I thought you were working on that Halting Problem. It needs to
>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>> Linz
>>>>> does.
>>>>>
>>>>
>>>> I hypothesize that you are either a liar or incompetent about what is
>>>> and what is not an actual computation. The term of the art for this is
>>>> "computable function", therefore if you are not a liar or incompetent
>>>> you would be able to cite sources that conform your assessments.
>>>
>>> There is a difference between a Computable Function and a Computation,
>>> but it might be too subtle for you.
>>>
>>> A Computible Function is the actual Mapping, that happens to be
>>> computable, i.e. there exists an algorithm that is able to generate that
>>> mapping.
>>>
>>
>> I derive a unique mapping from an input finite string to a Boolean
>> value. I currently need static local data to do this, none-the-less a
>> unique mapping is derived. I can't understand how this is computable in
>> C and not computable in a TM.
>>
>
> The problem is that to be a Computatable Function ALL refereces to that
> Function need to generate that same mapping.
>
> That means that the P that call this 'Computable Function' H must get
> the exact same answer as H give when just asked.

So we are back to a function called in infinite recursion must return to
its caller even though everyone know this is impossible.

Maybe all black cats are really white dogs?

> This actually isn't a problem so far, because H(P,P) is non-Halting and
> the H(P,P) also gives non-halting, so that can easily be a Computable
> Function.
>

H(P,P) is only non-halting until at least one element of this otherwise
infinite chain breaks the chain. It makes sense that the element that is
not called in infinite recursion would be the one that does this.

> It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
> non-halting answer, P(P) then halts.
>

They are very similar looking distinctly different comutations that are
proven to be different by their different execution trace.

H1(P,P) is a similar computation to P(P).

> When you then claim that H1 is the SAME Computable Function and its
> answer is correct, then you have a problem.
>

Whenever a halt decider must decide halting on an input that calls this
same halt decider this is an entirely different computation than when an
exact copy of this code must decide halting on the exact same input that
does not call this copied halt decider.

You maintain your false assumptions even when presented with easily
verified facts to the contrary.

> Or, when you claim that H's non halting answer while it might not be
> correct for the indpendently run P(P) is correct of the P(P) is is
> simulating, then that implies that P is not a computable function, as
> two instances of it give diffent answers for the same input, but the
> structure of P is such that the only way that P isn't computable is if H
> itself isn't. The simulated P(P) can only be non halting if the
> simulated H(P,P) doesn't answer non-halting which means that H isn't
> actually a Computatable Function.
>
> If you allow H to be wrong, then it could be a Turing Machine, but it
> just is wrong.
>
> If you don't allow H to be wrong, then it must not actually a Computable
> Function, and thus doesn't map to a Turing Machine.
>
>>> A Computation is the running of such an algorithm on an input.
>>>
>>> The Turing Machine is an embodiment of an algorithm.
>>>
>>> Add an input tape, and you get a Computaton.
>>>
>>> The sum set of all input tapes to their results, is a Computable
>>> Function.
>>>
>>>>
>>>>>>
>>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>>> will
>>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>>> recursion
>>>>>>> here is strictly limited.
>>>>>>>
>>>>>>
>>>>>> H knows that is must abort the simulation of its input because its
>>>>>> input
>>>>>> never reaches its final state whether or not it aborts this input.
>>>>>
>>>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>>>> and answer Non-Halting, the machine represented by the input will reach
>>>>> its Halting State.
>>>>>
>>>>>>
>>>>>>> We can add the tracking of all calls that occur, with their
>>>>>>> parameters,
>>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>>
>>>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>>>> simple simulator will not be able to tell what happens after this
>>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>>> always be later in the execution of the machine that it is simulating
>>>>>>> than when the simulator will abort it.
>>>>>>>
>>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>>> solve
>>>>>>> problems do exist.
>>>>>>>
>>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>>> there IS
>>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>>> has a
>>>>>>> definite halting status when run on a representation of itself.
>>>>>>>
>>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>>> gives
>>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>>> contradiction,
>>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>>> the
>>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>>> second
>>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>>> make
>>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>>> will
>>>>>>> defeat any given machine.
>>>>>>>
>>>>>>
>>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>>> pattern
>>>>>> and toss out the one that loses the three-way vote.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> FAIL.
>>>>>
>>>>> If you define a decider based on 3 copies of H, and call this lets say
>>>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>>>> and your H3 voting pattern will get this wrong.
>>>>>
>>>>> I think all three will detect the infinite recursion and thus the
>>>>> consesus will be non-halting, at which point it will halt, showing them
>>>>> ALL to be wrong, even the majority vote.
>>>>>
>>>>> Depending on how you do the voting, it might be possible for only 2 of
>>>>> the three to get it wrong, if H3 never checks the third machine if the
>>>>> first two agree.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> It has already been empirically validated that although the equivalent
>>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>>> of Ĥ.
>>>>
>>>
>>> Nope. You have unsound logic.
>>>
>>> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
>>> on, if it was, it would get the exact same answer.
>>>
>>
>> One machine has an input that calls the same halt decider that is
>> evaluating it and the other machine does not this makea them distinctly
>> different computations even though their code it the same.
>
> If they give different answers, they can't be the same Computable
> Function. PERIOD.
>
> IF H/H1 can distinguish that P calls H but not H1, then they are not the
> same Computable Function. PERIOD.
>
> You can't claim that they actually have the exact same algorithm, but
> give different result from the exact same input.
>

P calls H and P does not call H1 this makes a big difference.

> If they really DO have the same algorithm, then the 'input' described is
> NOT the complete list of inputs, and thus they fail to be Computable
> Fuinctions of the defined input set.
>
> They are a mapping of I+x => O, not I => O.
>
>>
>>> This basically proves that your whole logic is flawed. Most likely
>>> because your C/x86 things that you claim to map to the Turing Machine
>>> are actually the right sort of Computation, so there actually isn't a
>>> Turing Machine for them to the equivalent of.
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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