On 12/13/2021 9:24 AM, André G. Isaak wrote:
> On 2021-12-13 07:45, olcott wrote:
>> On 12/13/2021 5:50 AM, Richard Damon wrote:
>>> On 12/12/21 11:16 PM, olcott wrote:
>>>> On 12/12/2021 10:02 PM, Richard Damon wrote:
>>>>> On 12/12/21 10:44 PM, olcott wrote:
>>>>>> On 12/12/2021 9:13 PM, olcott wrote:
>>>>>>> On 12/12/2021 7:34 PM, Richard Damon wrote:
>>>>>>>> On 12/12/21 8:29 PM, olcott wrote:
>>>>>>>>> On 12/12/2021 7:05 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 12/12/2021 4:23 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> A function f with domain D is said to be Turing-computable
>>>>>>>>>>>>> or just computable if there exists some Turing machine
>>>>>>>>>>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>>>>>>>>>>> for all w ∈ D (Linz:1990:243)
>>>>>>>>>>>> I wonder if you know what this means...  Is the "add one"
>>>>>>>>>>>> function given
>>>>>>>>>>>> by f: N -> N, f(n) = n+1 computable or not?
>>>>>>>>>>>> (Your ASCII has garbled the key part.  In "Mqff(w)" the M is
>>>>>>>>>>>> a subscript
>>>>>>>>>>>> to the ⊢ symbol and there should be a spaces between the M,
>>>>>>>>>>>> qf and
>>>>>>>>>>>> f(w).)
>>>>>>>>>>>>
>>>>>>>>>>>>> The question of whether or not a halt decider exists is
>>>>>>>>>>>>> answered by
>>>>>>>>>>>>> whether or not a computable function exists that computes
>>>>>>>>>>>>> the halt
>>>>>>>>>>>>> status of every finite string Turing machine description.
>>>>>>>>>>>> Clumsy wording.  The question is whether the halting
>>>>>>>>>>>> function is
>>>>>>>>>>>> computable or not (it isn't).
>>>>>>>>>>>>
>>>>>>>>>>>>> As long as computable function H(x,y) correctly maps its
>>>>>>>>>>>>> inputs to a
>>>>>>>>>>>>> final accept or reject state
>>>>>>>>>>>> H is not a function, computable or otherwise.  H seems to
>>>>>>>>>>>> refer to a
>>>>>>>>>>>> Turing machine as it has accepting and rejecting states.  No
>>>>>>>>>>>> Turing
>>>>>>>>>>>> machine has the property that
>>>>>>>>>>>>     H x,y ⊢* qy   if x encodes a TM X such that X(y) halts, and
>>>>>>>>>>>>     H x,y ⊢* qn   otherwise.
>>>>>>>>>>>
>>>>>>>>>>> The point is that H(P,P)==0 is not refuted by the fact that
>>>>>>>>>>> int main() { P(P); } halts
>>>>>>>>>>
>>>>>>>>>> And now H is not even a Turing machine but some pile of junk
>>>>>>>>>> code!  If
>>>>>>>>>> you steer clear of making statements about mathematics and Turing
>>>>>>>>>> machines, I'll leave you to post whatever claims you like.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is the case that a computable function can be defined that
>>>>>>>>> overcomes the feedback loop between a halt decider H and input
>>>>>>>>> P that does the opposite of whatever H decides by simply
>>>>>>>>> examining the behavior of P(P) as if H was a UTM(P,P).
>>>>>>>>>
>>>>>>>>
>>>>>>>> Only by not computing the Halting Function, but only computing
>>>>>>>> the POOP function.
>>>>>>>>
>>>>>>>
>>>>>>> It is always the case that the behavior of the input to H(x,y) as
>>>>>>> if H was a UTM(x,y) defines the correct halt status of the input
>>>>>>> to H(x,y).
>>>>>>
>>>>>> It is always the case that when pure simulation of the input to
>>>>>> H(x,y) never stops running unless H aborts the simulation of this
>>>>>> input that this input is correct decided as not halting.
>>>>>
>>>>> Unless THIS copy of H aborts the simulation.
>>>>>
>>>>> Wrong definitin=on, wrong problem.
>>>>>
>>>>> The fact that the copy of H included in the copy of P that is being
>>>>> simulted has aborted its simulation and INCORRECTLY decided the
>>>>> copy of P that it was simulationg will not halt, doesn't mean that
>>>>> P IS non-halting if it is the case that changing the outer copy of
>>>>> H to be a UTM would Halt.
>>>>>
>>>>>>
>>>>>> A function f with domain D is said to be Turing-computable
>>>>>> or just computable if there exists some Turing machine
>>>>>> M = (Q, Σ, Γ, δ, q0, □, F) such that q0 w ⊢* Mqff(w), qf ∈ F
>>>>>> for all w ∈ D (Linz:1990:243)
>>>>>>
>>>>>> Olcott paraphrase of machine definition: Machine M begins at its
>>>>>> start state q0 on input w and transitions to qf as a function of
>>>>>> input w.
>>>>>>
>>>>>> Everyone knowing the basics of the theory of computation knows
>>>>>> that every computable function (regardless of model of
>>>>>> computation) is only accountable for its actual inputs.
>>>>>>
>>>>>
>>>>> Right. And the input to H(P,P) is the representation of the
>>>>> INDEPENDENT machine/input P(P).
>>>> There are no textbook sources anywhere that ever say anything like
>>>> that.
>>>>
>>>
>>> Maybe, but only because the standard definitions make it clear, you
>>> seem to need stuff made explicit.
>>>
>>
>> I am saying that what you are saying is not the truth and you cannot
>> find any textbook source that agrees with your misconcepiton.
>
> You are the one making the misconception here. The reason no textbook
> explicitly excludes your misconception is because your interpretation is
> one that is completely nonsensical and one that no one familiar with the
> actual definitions of "computation" or 'Turing Machine" would ever even
> consider.
>
> Your problem is that, despite the fact that you are talking about a
> theorem which concerns Turing Machines, you continue to think about
> things in terms of C programs and/or x86 programs which are very
> different animals from Turing Machines.
>

As long as a C function is a pure function then it is a computable
function through the RASP model of computation for every input that it
derives an output.

> A Turing Machine is an entirely self-contained entity. It does not run
> under an operating system. It does not run on actual hardware. It
> *cannot* be called from another Turing Machine.
>

A Turing machine Y can be called from another Turing machine X in the
sense that X contains a UTM.

> When you talk about running a Turing Machine on a particular input
> string you are talking about something which by the very nature of a
> Turing Machine occurs entirely without reference to anything else. A TM
> never has a caller. It is never executed inside some 'environment'.
>

So you simply don't believe in UTMs?

> So for the definition of halting to explicitly specify that it refers to
> the independent execution of the TM is completely unnecessary. There is
> no other possible interpretation for those who actually understand the
> subject.
>

Yes when you simply don't believe in UTM's then that would be true
within your misconception.

> When you provide a description of a TM and input to a UTM, your are
> *not* executing that TM. When you provide a description of a TM and an
> input to a halt decider, you are *not* executing that TM.

It is computationally equivalent to direct execution and you know it.

>The halting
> problem asks whether a given TM will halt on a particular input when you
> actually do execute that computation.
>

When-so-ever a halt decider bases its halt status decision on behavior
of the pure simulation this input the as if the halt decider was a UTM
then the halt decider has the correct basis for every input.

[Olcott 2021 generic halt deciding principle] Whenever the pure
simulation of the input to simulating halt decider H(x,y) never stops
running unless H aborts its simulation H correctly aborts this
simulation and returns 0 for not halting.

>>> Look at the requirements if Linz.
>>>
>>> H applied to Wm w goes to qy if M applied to w Halts.
>>>
>>> M is a Turing Machine, which BY DEFINITION is an independent
>>> computation.
>>
>> The input to a halt decider is never ever a Turing machine it is
>> always a finite string.
>
> Yes, of course it is a finite string. It is a finite string that
> describes a TM and its input.

No that is incorrect. It is a pair of finite strings that stipulate a
100% precise and exact set of configurations.

> The question which a halt decider is
> supposed to answer is about what happens when you execute that
> particular computation. The question is not about the string itself.
>

The question is about the precise behavior of the pure simulation of the
finite string pair as if H was only a UTM and not a halt decider.

> This is no different from the fact that (e.g.) a TM which calculates
> factorials is given an input which is a finite string that describes an
> integer. The question it must answer is about the integer, not about the
> string describing it.
>
> All computations involve strings of symbols. That means any function you
> want to compute must have the elements in its domain and codomain
> translated into a symbolic representation appropriate for the given
> Turing Machine. But the function which a TM computes still involves
> mapping the elements of the domain to the codomain; the symbolic
> representations of those elements are simply what is used internally by
> the algorithm which computes the function.
>
> André
>

Every computable function halt decider correctly returns 0 for the halt
status of its input when-so-ever the pure simulation of this input by
the halt decider would never stop running unless aborted.

The halt decider need not be an actual pure simulator for it to
correctly determine what the behavior of the input would be under pure
simulation. The halt decider only need be a pure simulator for N steps
of the simulation of its input.
(a) The simulated input halts on its own.
(b) The simulated behavior of the input matched an infinite behavior
pattern.

These are the two most obvious cases where a simulating halt decider
does detect infinite behavior patterns. Detecting infinitely nested
simulation is comparable to detecting infinite recursion.

void Infinite_Loop(int N)
{ HERE: goto HERE;
}

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
}

_Infinite_Loop()
[00000cb5](01) 55 push ebp
[00000cb6](02) 8bec mov ebp,esp
[00000cb8](02) ebfe jmp 00000cb8
[00000cba](01) 5d pop ebp
[00000cbb](01) c3 ret
Size in bytes:(0007) [00000cbb]

_Infinite_Recursion()
[00000cc5](01) 55 push ebp
[00000cc6](02) 8bec mov ebp,esp
[00000cc8](03) 8b4508 mov eax,[ebp+08]
[00000ccb](01) 50 push eax
[00000ccc](05) e8f4ffffff call 00000cc5
[00000cd1](03) 83c404 add esp,+04
[00000cd4](01) 5d pop ebp
[00000cd5](01) c3 ret
Size in bytes:(0017) [00000cd5]

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer