Because it is known to be true that a correct pure simulation of the
input by the halt decider would demonstrate the actual behavior of this
input it is known that this is a correct basis for a halt status
decision by the halt decider.

A simulating halt decider need only perform a pure simulation of N steps
of its input until:
(a) Its input halts on its own or
(b) The simulated behavior of its input correctly matches non-halting
behavior patterns conclusively proving that a pure simulation of this
input would never stop running.

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

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)

Begins at start state q0 on input w and transitions to qf as a function
of input 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.

As long as computable function H(x,y) correctly maps its inputs to a
final accept or reject state that directly applies to the actual
behavior of this actual input then the halt status decision of H is
correct for this input.

No function is ever accountable for anything besides its actual inputs.
If it is the case that the input to H(P,P) never stops running unless it
is aborted when H returns 0 it is necessarly correct and impossibly
incorrect.

*Halting problem undecidability and infinitely nested simulation V2*

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

--
Copyright 2021 Pete Olcott

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

On 12/12/21 2:05 PM, olcott wrote:
> Because it is known to be true that a correct pure simulation of the
> input by the halt decider would demonstrate the actual behavior of this
> input it is known that this is a correct basis for a halt status
> decision by the halt decider.
>
> A simulating halt decider need only perform a pure simulation of N steps
> of its input until:
> (a) Its input halts on its own or
> (b) The simulated behavior of its input correctly matches non-halting
> behavior patterns conclusively proving that a pure simulation of this
> input would never stop running.

But only if the pattern is a CORRECT non-halting pattern.

The fact that x(y) calls H(x,y) is NOT a correct non-halting pattern if
H(x,y) will abort its processing and return an answer.

FAIL.

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

Error in form.

This statement PRESUMES that H can correctly decide if it needs to halt
its simulation to know it can abort.

Note, if you go strictly by this rule, then H can NEVER abort its
simulation of H^ as if at any finite time it aborts its simulation and
return a non-halting answer, it makes H^ to be a halting computation, as
the independently run H^ will call H(H^,H^) and then halt when H returns
the value 0.

Thus H fails to decide in finite time.

>
> 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)
>
> Begins at start state q0 on input w and transitions to qf as a function
> of input 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.
>
> As long as computable function H(x,y) correctly maps its inputs to a
> final accept or reject state that directly applies to the actual
> behavior of this actual input then the halt status decision of H is
> correct for this input.

Except that the IS no value that H(H^,H^) can return that make H(H^,H^)
map to the actual halting status of H^(H^).

If H(H^,H^) returns non-halting, then H^(H^) will Halt and H's answer
doesn't map correctly.

If H(H^,H^) returns halting, then H^(H^) will enter an infinite loop and
H's answer doesn't map correctly.

Thus H can not be the computation of the Halting Function.

Note, for ANY H that can be defined as an actual Turing Machine, there
WILL be a definite answer for the Halting State of H^(H^) but there is
no version of H that returns that value for H(H^,H^).

FAIL.

>
> No function is ever accountable for anything besides its actual inputs.
> If it is the case that the input to H(P,P) never stops running unless it
> is aborted when H returns 0 it is necessarly correct and impossibly
> incorrect.

And the input to H(x,y) represent the running of the INDEPENDENT machine
x(y).

It does NOT relate to the PARTIAL simulation done by H.

In your 'C' x96utm, that corresponds to writing int main() { x(y);}

If it isn't, then your system isn't defined to map to the Halting Problem.

PERIOD.

> *Halting problem undecidability and infinitely nested simulation V2*
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

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.

--
Ben.

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 because the correct pure simulation of the
input to H(P,P) never stops running and H is only accountable for the
actual behavior of its actual inputs.

I have said this previously yet with the the proof that no computable
function is ever accountable for anything besides its actual inputs.

H essentially derives the mathematical mapping from the sequence of
configurations specified by
558bec8b4508508b4d0851e8d0ffffff83c40885c07402ebfe5dc3 to 0.

--
Copyright 2021 Pete Olcott

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

On 12/12/21 7:27 PM, olcott wrote:
> 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 because the correct pure simulation of the
> input to H(P,P) never stops running and H is only accountable for the
> actual behavior of its actual inputs.

But the DEFINITION of the Halting Problem says that H(P,P) needs to
correspond to the Halting status of P(P) as an independent computaition.

It doesn't matter WHY that independent computation halts, if it halts it
is halting.

Thus the fact that P(P) uses H(P,P) and this H(P,P) simulates a copy of
P(P) and aborts the copy of P(P) doesn't affect the DEFINITIONAL fact
that the original independent P(P) does Halt.

Just means that H was WRONG in deciding that P(P) doesn't halt.

>
> I have said this previously yet with the the proof that no computable
> function is ever accountable for anything besides its actual inputs.

It isn't, but the input needs to be the right input. From below, yours
isn't.

Maybe the issue is that H computes the wrong function. If the function
it computes doesn't match the Halting Function, it doesn't matter what
it does.

>
> H essentially derives the mathematical mapping from the sequence of
> configurations specified by
> 558bec8b4508508b4d0851e8d0ffffff83c40885c07402ebfe5dc3 to 0.
>

Which can NOT be the proper encoding of the ALGORITHM of P as it doesn't
include ALL the steps needed to perform its operation. It MUST constain
the code for H too. FAIL.

You P is NOT the compuation specified by Linz, and in fact, isn't a
computation at all, as its behavior is dependent on more than its formal
inputs, as it depends on the contents of some memory outside of itself.

FAIL.

Just shows you are ignorant of what you are talking about.

>
>

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.

--
Ben.

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

--
Copyright 2021 Pete Olcott

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

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.

One problem is your P is NOT a computation because it has been built
incorrectly, and thus your whole argument has failed.

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

--
Copyright 2021 Pete Olcott

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

On 12/12/21 10: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).
>

Worded wrongly.

If THIS copy of H(x,y) was a UTM.

If x uses a copy of H, THAT copy must still use the original H, as x HAS
a COPY of H.

PERIOD.

You don't understand what a Computation and an Algorithm is.

The H^/P beind decided INCLUDES the definition of H, that MUST be the H
that is being tested, NOT the 'modified' H being used to check it if is
right or that it uses to figure out what it does.

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.

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.

Thus when the pure simulation of the input to H(x,y) never stops running
unless aborted then this input is correctly reported as not halting even
when x(y) that is not an input to H(x,y) does stop running.

--
Copyright 2021 Pete Olcott

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

On 12/12/2021 9:27 PM, Richard Damon wrote:
> On 12/12/21 10: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).
>>
>
> Worded wrongly.
>
> If THIS copy of H(x,y) was a UTM.

No you got this wrong 500 times now.

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 correctly decided as not halting.

It does not matter is H is not a pure simulator, even if H looks into a
crystal ball to discover that the pure simulation of the input would
never stop running unless H aborts this input the criterion measure is
met and H is correct to abort.

>
> If x uses a copy of H, THAT copy must still use the original H, as x HAS
> a COPY of H.
>
> PERIOD.
>
> You don't understand what a Computation and an Algorithm is.
>
> The H^/P beind decided INCLUDES the definition of H, that MUST be the H
> that is being tested, NOT the 'modified' H being used to check it if is
> right or that it uses to figure out what it does.
>
>
>

--
Copyright 2021 Pete Olcott

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

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

When H(P,P) returns non-halting, That P(P) does Halt, so the answer that
H(P,P) needs to give to be correct is HALT, so it was wrong.

> Thus when the pure simulation of the input to H(x,y) never stops running
> unless aborted then this input is correctly reported as not halting even
> when x(y) that is not an input to H(x,y) does stop running.
>

But a PURE simuatiom of P(P) DOES halt. it is only the PARTIAL
simulation of H that doesn't reach that halting state.

Your arguement about changing H is unsound.

If we lable each of your various Hs as Hn where the n controls how much
processing H does before aborting, and Pn as the P that relates to that H.

We have that in all cases where Hn(Pn,Pn) returns 0, there is a (larger)
value of m such that Hm(Pn,Pn) will see its simulation of Pn(Pn) finish,
and thus PROVE that Pn(Pn) is Halting.

YOU INCORRECTLY look at Hm(Pm,Pm) which is looking at a different
computaiton.

Part of your problem is that you define P incorrectly to NOT use a FIXED
Hn but your Pn uses what ever H is deciding it.

This mskes you P DIFFERENT than the REQUIRED machine H^ from Linz, and
in fact, makes your P not even a legal algorithm to perform a
computation, is the results of P(x) depends on MORE than just x, it
depends on the H that is looking at it.

UTTER FAIL.

On 12/12/21 10:50 PM, olcott wrote:
> On 12/12/2021 9:27 PM, Richard Damon wrote:
>> On 12/12/21 10: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).
>>>
>>
>> Worded wrongly.
>>
>> If THIS copy of H(x,y) was a UTM.
>
> No you got this wrong 500 times now.
>
> 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 correctly decided as not halting.

PLEASE PROVIDE YORU REFERENCE FOR THIS.

Something that allows the fact that a COPY of H that x uses can do the
abort and that makes x non-halting.

BOLD FACE LIE.

The ONLY definition of the right answer for a Halting Decider is the
behavior of the INDEPENDENT machine. So the right answer for H(x,y) is
ONLY determined by the behavior of x(y).

We can use UTM(x,y) as an alternative BECAUSE UTM(x,y) is DEFINED to
behave identically to x(y).

>
> It does not matter is H is not a pure simulator, even if H looks into a
> crystal ball to discover that the pure simulation of the input would
> never stop running unless H aborts this input the criterion measure is
> met and H is correct to abort.
>

WRONG. If H is NOT a UTM, then the behavor of H doesn't matter at all.
It is only the behavior of x(y) or its equivalent UTM(x,y) that matters.

Remember, you can't change the input to decide what the input does, and
that input for H^ includes the FULL algorithm of the H that needs to
decide it, so its behavior is FULLY defined.

You can possible argue about changing the ONE copy of H that is doing
the deciding (change from Hn to Hm) and if you do that you see that P(P)
does Halt.

You just can't see the truth because you mind is so filled with darkness
and lies.

You just prove you are ignorant of the field you are talking in and
prove that you are the fool.

>>
>> If x uses a copy of H, THAT copy must still use the original H, as x
>> HAS a COPY of H.
>>
>> PERIOD.
>>
>> You don't understand what a Computation and an Algorithm is.
>>
>> The H^/P beind decided INCLUDES the definition of H, that MUST be the
>> H that is being tested, NOT the 'modified' H being used to check it if
>> is right or that it uses to figure out what it does.
>>
>>
>>
>
>

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.

--
Copyright 2021 Pete Olcott

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

On 12/12/2021 10:11 PM, Richard Damon wrote:
> On 12/12/21 10:50 PM, olcott wrote:
>> On 12/12/2021 9:27 PM, Richard Damon wrote:
>>> On 12/12/21 10: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).
>>>>
>>>
>>> Worded wrongly.
>>>
>>> If THIS copy of H(x,y) was a UTM.
>>
>> No you got this wrong 500 times now.
>>
>> 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 correctly decided as not halting.
>
> PLEASE PROVIDE YORU REFERENCE FOR THIS.
>
> Something that allows the fact that a COPY of H that x uses can do the
> abort and that makes x non-halting.
>

My new pure function H never gets to the point where any copy of H ever
comes into existence.

> BOLD FACE LIE.
>
> The ONLY definition of the right answer for a Halting Decider is the
> behavior of the INDEPENDENT machine. So the right answer for H(x,y) is
> ONLY determined by the behavior of x(y).
>
> We can use UTM(x,y) as an alternative BECAUSE UTM(x,y) is DEFINED to
> behave identically to x(y).
>
>>
>> It does not matter is H is not a pure simulator, even if H looks into
>> a crystal ball to discover that the pure simulation of the input would
>> never stop running unless H aborts this input the criterion measure is
>> met and H is correct to abort.
>>
>
> WRONG. If H is NOT a UTM, then the behavor of H doesn't matter at all.
> It is only the behavior of x(y) or its equivalent UTM(x,y) that matters.
>
> Remember, you can't change the input to decide what the input does, and
> that input for H^ includes the FULL algorithm of the H that needs to
> decide it, so its behavior is FULLY defined.
>
> You can possible argue about changing the ONE copy of H that is doing
> the deciding (change from Hn to Hm) and if you do that you see that P(P)
> does Halt.
>
> You just can't see the truth because you mind is so filled with darkness
> and lies.
>
> You just prove you are ignorant of the field you are talking in and
> prove that you are the fool.
>
>>>
>>> If x uses a copy of H, THAT copy must still use the original H, as x
>>> HAS a COPY of H.
>>>
>>> PERIOD.
>>>
>>> You don't understand what a Computation and an Algorithm is.
>>>
>>> The H^/P beind decided INCLUDES the definition of H, that MUST be the
>>> H that is being tested, NOT the 'modified' H being used to check it
>>> if is right or that it uses to figure out what it does.
>>>
>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

On 12/12/21 11:25 PM, olcott wrote:
> On 12/12/2021 10:11 PM, Richard Damon wrote:
>> On 12/12/21 10:50 PM, olcott wrote:
>>> On 12/12/2021 9:27 PM, Richard Damon wrote:
>>>> On 12/12/21 10: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).
>>>>>
>>>>
>>>> Worded wrongly.
>>>>
>>>> If THIS copy of H(x,y) was a UTM.
>>>
>>> No you got this wrong 500 times now.
>>>
>>> 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 correctly decided as not halting.
>>
>> PLEASE PROVIDE YORU REFERENCE FOR THIS.
>>
>> Something that allows the fact that a COPY of H that x uses can do the
>> abort and that makes x non-halting.
>>
>
> My new pure function H never gets to the point where any copy of H ever
> comes into existence.

THen P doesn't meet the requirements. PERIOD.

Remember, H^ is built by giving it a COPY of H, because Turing Machines,
like ALL algorithms, include there own copy of everything that runs in them.

You just admitted you FAIL, and don't understand what you are talking about.

I will again remind you that when you build the Turing Machine H^, it
needs to contain it OWN copy of H that is distinct from the H that is
deciding it. Try to show how to create such a machine pair as H / H^
where H^ doesn't have its own copy.

Each machine needs to be a distinct machine with the required parameter
set, and complete machines of themselves.

It is IMPOSSIBLE.

FAIL.

>
>> BOLD FACE LIE.
>>
>> The ONLY definition of the right answer for a Halting Decider is the
>> behavior of the INDEPENDENT machine. So the right answer for H(x,y) is
>> ONLY determined by the behavior of x(y).
>>
>> We can use UTM(x,y) as an alternative BECAUSE UTM(x,y) is DEFINED to
>> behave identically to x(y).
>>
>>>
>>> It does not matter is H is not a pure simulator, even if H looks into
>>> a crystal ball to discover that the pure simulation of the input
>>> would never stop running unless H aborts this input the criterion
>>> measure is met and H is correct to abort.
>>>
>>
>> WRONG. If H is NOT a UTM, then the behavor of H doesn't matter at all.
>> It is only the behavior of x(y) or its equivalent UTM(x,y) that matters.
>>
>> Remember, you can't change the input to decide what the input does,
>> and that input for H^ includes the FULL algorithm of the H that needs
>> to decide it, so its behavior is FULLY defined.
>>
>> You can possible argue about changing the ONE copy of H that is doing
>> the deciding (change from Hn to Hm) and if you do that you see that
>> P(P) does Halt.
>>
>> You just can't see the truth because you mind is so filled with
>> darkness and lies.
>>
>> You just prove you are ignorant of the field you are talking in and
>> prove that you are the fool.
>>
>>>>
>>>> If x uses a copy of H, THAT copy must still use the original H, as x
>>>> HAS a COPY of H.
>>>>
>>>> PERIOD.
>>>>
>>>> You don't understand what a Computation and an Algorithm is.
>>>>
>>>> The H^/P beind decided INCLUDES the definition of H, that MUST be
>>>> the H that is being tested, NOT the 'modified' H being used to check
>>>> it if is right or that it uses to figure out what it does.
>>>>
>>>>
>>>>
>>>
>>>
>>
>
>

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.

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.

You just don't understand what you are saying.

FAIL.

On 12/13/2021 5:45 AM, Richard Damon wrote:
> On 12/12/21 11:25 PM, olcott wrote:
>> On 12/12/2021 10:11 PM, Richard Damon wrote:
>>> On 12/12/21 10:50 PM, olcott wrote:
>>>> On 12/12/2021 9:27 PM, Richard Damon wrote:
>>>>> On 12/12/21 10: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).
>>>>>>
>>>>>
>>>>> Worded wrongly.
>>>>>
>>>>> If THIS copy of H(x,y) was a UTM.
>>>>
>>>> No you got this wrong 500 times now.
>>>>
>>>> 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 correctly decided as not halting.
>>>
>>> PLEASE PROVIDE YORU REFERENCE FOR THIS.
>>>
>>> Something that allows the fact that a COPY of H that x uses can do
>>> the abort and that makes x non-halting.
>>>
>>
>> My new pure function H never gets to the point where any copy of H
>> ever comes into existence.
>
> THen P doesn't meet the requirements.  PERIOD.
>
> Remember, H^ is built by giving it a COPY of H, because Turing Machines,
> like ALL algorithms, include there own copy of everything that runs in
> them.
>

It also works with a copy of H.

> You just admitted you FAIL, and don't understand what you are talking
> about.
>
> I will again remind you that when you build the Turing Machine H^, it
> needs to contain it OWN copy of H that is distinct from the H that is
> deciding it. Try to show how to create such a machine pair as H / H^
> where H^ doesn't have its own copy.
>
> Each machine needs to be a distinct machine with the required parameter
> set, and complete machines of themselves.
>
> It is IMPOSSIBLE.
>
> FAIL.
>
>>
>>> BOLD FACE LIE.
>>>
>>> The ONLY definition of the right answer for a Halting Decider is the
>>> behavior of the INDEPENDENT machine. So the right answer for H(x,y)
>>> is ONLY determined by the behavior of x(y).
>>>
>>> We can use UTM(x,y) as an alternative BECAUSE UTM(x,y) is DEFINED to
>>> behave identically to x(y).
>>>
>>>>
>>>> It does not matter is H is not a pure simulator, even if H looks
>>>> into a crystal ball to discover that the pure simulation of the
>>>> input would never stop running unless H aborts this input the
>>>> criterion measure is met and H is correct to abort.
>>>>
>>>
>>> WRONG. If H is NOT a UTM, then the behavor of H doesn't matter at
>>> all. It is only the behavior of x(y) or its equivalent UTM(x,y) that
>>> matters.
>>>
>>> Remember, you can't change the input to decide what the input does,
>>> and that input for H^ includes the FULL algorithm of the H that needs
>>> to decide it, so its behavior is FULLY defined.
>>>
>>> You can possible argue about changing the ONE copy of H that is doing
>>> the deciding (change from Hn to Hm) and if you do that you see that
>>> P(P) does Halt.
>>>
>>> You just can't see the truth because you mind is so filled with
>>> darkness and lies.
>>>
>>> You just prove you are ignorant of the field you are talking in and
>>> prove that you are the fool.
>>>
>>>>>
>>>>> If x uses a copy of H, THAT copy must still use the original H, as
>>>>> x HAS a COPY of H.
>>>>>
>>>>> PERIOD.
>>>>>
>>>>> You don't understand what a Computation and an Algorithm is.
>>>>>
>>>>> The H^/P beind decided INCLUDES the definition of H, that MUST be
>>>>> the H that is being tested, NOT the 'modified' H being used to
>>>>> check it if is right or that it uses to figure out what it does.
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

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.

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

>
> You just don't understand what you are saying.
>
> FAIL.
>
>

--
Copyright 2021 Pete Olcott

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

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.

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.

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

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. The halting
problem asks whether a given TM will halt on a particular input when you
actually do execute that computation.

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

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

On 2021-12-13 08:50, olcott wrote:
> On 12/13/2021 9:24 AM, André G. Isaak wrote:

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

No C function is a computable function. Computable functions are a
subset of *mathematical* functions. The word 'function' in C means
something entirely different than the word 'function' in maths.

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

There is no sense in which that can be construed as 'calling another TM'.

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

Where did I say that?

UTM(<M>, I) and M(I) are two distinct computations. The former does not
involve 'running' the latter inside it. UTM(<M>, I) is a single
computation which computes the *result* of running M on I without
actually running M(I).

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

You seem to think the word 'equivalent' means 'interchangeable in any
context'. It does not. Things are equivalent with respect to some
specified set of properties. This doesn't make them identical.

A bag of 10,000 pennies is "equivalent" to a $100 bill only when you are
specifically talking about their value as U.S. currency. Not when
talking about their copper content or their usefulness in bludgeoning
someone to death.

Running UTM(<M>, I) is *not* equivalent to running M(I). The equivalence
refers only to the *result* obtained by running these two computations.

And note that the results are equivalent, not identical. The string
outputted by UTM(<M>, I) may be very different from the one outputted by
M(I). But those two strings will both be representations of the same
element of the codomain of the function computed by M.

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

Word salad.

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

If H was only a UTM then it would not decide halting.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 12/13/2021 10:22 AM, André G. Isaak wrote:
> On 2021-12-13 08:50, olcott wrote:
>> On 12/13/2021 9:24 AM, André G. Isaak wrote:
>
>>> 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.
>
> No C function is a computable function. Computable functions are a
> subset of *mathematical* functions. The word 'function' in C means
> something entirely different than the word 'function' in maths.
>

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 above machine definition: Machine M begins at start
state q0 on input w and transitions to qf as a function of input w.

Linz says that machine M computes the function f(w).

>>> 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.
>
> There is no sense in which that can be construed as 'calling another TM'.
>

Machine X simulates machine Y that writes its output to its tape which
is a part of the tape of X. This is the same thing as if X called Y.

>>> 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?
>
> Where did I say that?
>
> UTM(<M>, I) and M(I) are two distinct computations. The former does not
> involve 'running' the latter inside it. UTM(<M>, I) is a single
> computation which computes the *result* of running M on I without
> actually running M(I).
>
>>> 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.
>
> You seem to think the word 'equivalent' means 'interchangeable in any