Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #33708 > unrolled thread

Re: Infinitely Recursive input on HP Proofs

Started byolcott <NoOne@NoWhere.com>
First post2021-05-16 14:09 -0500
Last post2021-05-17 20:34 -0500
Articles 20 on this page of 32 — 6 participants

Back to article view | Back to comp.theory

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 14:09 -0500
    Re: Infinitely Recursive input on HP Proofs Jeff Barnett <jbb@notatt.com> - 2021-05-16 13:46 -0600
    Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 19:05 -0400
      Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 18:21 -0500
        Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 21:11 -0400
          Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 21:01 -0500
            Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 23:18 -0400
              Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 22:23 -0500
                Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 07:11 -0400
                Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 07:26 -0400
                  Re: Infinitely Recursive input on HP Proofs Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-05-17 05:45 -0700
                    Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 10:23 -0500
                      Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 20:41 -0400
                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-17 20:27 +0100
                      Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 14:31 -0500
                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-18 01:38 +0100
                          Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 19:54 -0500
                            Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 21:21 -0400
                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-20 12:57 +0100
                        Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 20:43 -0400
        Re: Infinitely Recursive input on HP Proofs André G. Isaak <agisaak@gm.invalid> - 2021-05-16 19:15 -0600
          Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 20:34 -0500
            Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 21:55 -0400
    Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 15:56 -0400
    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-16 21:21 +0100
      Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 17:19 -0400
        Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 16:37 -0500
      Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 16:00 -0500
        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-17 02:19 +0100
          Re: Infinitely Recursive input on HP Proofs (Full Linz text) olcott <NoOne@NoWhere.com> - 2021-05-16 20:54 -0500
            Re: Infinitely Recursive input on HP Proofs (Full Linz text) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-18 01:57 +0100
              Re: Infinitely Recursive input on HP Proofs (eternally on this point) olcott <NoOne@NoWhere.com> - 2021-05-17 20:34 -0500

Page 1 of 2  [1] 2  Next page →


#33708 — Re: Infinitely Recursive input on HP Proofs

Fromolcott <NoOne@NoWhere.com>
Date2021-05-16 14:09 -0500
SubjectRe: Infinitely Recursive input on HP Proofs
Message-ID<a4ydnWkMIKhS8Dz9nZ2dnUU7-L3NnZ2d@giganews.com>
On 3/11/2017 3:13 PM, peteolcott wrote:
> http://LiarParadox.org/HP_Infinite_Recursion.pdf
> 
> As this page 319 of An Introduction to Formal Languages and Automata
> by Peter Linz 1990 indicates
> 
>  From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'.
>   
> q0 Wm |-* H-Hat q0 Wm Wm...
> 
> Page 320 indicates that we apply H-Hat to itself as input.
> 
> The problem is that every H-Hat needs a pair of inputs.
> 
> H-Hat takes an H-Hat as input and copies it so that it
> can analyze how its input H-hat would analyze the copy
> of H-Hat that it just made.
> 
> The input H-Hat would have to copy its own input H-Hat
> so that it can analyze what its own input H-Hat would
> do on its own input, on and on forever...
> 
> Copyright 2016 and 2017 Pete Olcott.
> 

Any genius knowing the theory of computation quite well can easily 
confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of
[infinitely_nested_simulation] to every simulating halt decider.
This equally applies to all of the halting problem instances.

Ĥ(Ĥ) is short-hand for:
Now Ĥ is a Turing machine, so that it will have some description in Σ*,
say ŵ. This string, in addition to being the description of Ĥ can also 
be used
as input string. We can therefore legitimately ask what would happen if Ĥ is
applied to ŵ. (Linz:1990:320)

Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company. (315-320)

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf


-- 
Copyright 2021 Pete Olcott

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

[toc] | [next] | [standalone]


#33714

FromJeff Barnett <jbb@notatt.com>
Date2021-05-16 13:46 -0600
Message-ID<s7rsqh$8rg$1@dont-email.me>
In reply to#33708
On 5/16/2021 1:09 PM, olcott wrote:
> On 3/11/2017 3:13 PM, peteolcott wrote:

> Any genius knowing the theory of computation

Ah, we are at the heart of the matter!!!!

1) You are not a genius, not even close. Just a lonesome troll feeding 
on newsgroup interactions for the human interactions in her/his life.

2) You have shown no knowledge of theory of computation or, its 
engineering kin, software engineer.

I think your life would be much more fulfilling if you wrote a 
foundational paper "Cut and Pasting, Theory and Practice" and then a 
minor epic such as "Emphasis from the Cap Key and Repetition". Together 
they would revolutionize keyboard designs and give you a firm place in 
the history of the field. Trolling, at last, would be put on a firm 
scientific and engineering foundation and could join other modern 
occupations that are well prepared for the future.

BTW, don't forget to patent and copyright your papers.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#33715

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-16 19:05 -0400
Message-ID<_yhoI.542847$nn2.449398@fx48.iad>
In reply to#33708
On 5/16/21 5:37 PM, olcott wrote:
> On 5/16/2021 4:19 PM, Richard Damon wrote:
>> On 5/16/21 5:00 PM, olcott wrote:
>>> On 5/16/2021 3:21 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> Any genius knowing the theory of computation quite well can easily
>>>>> confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of
>>>>> [infinitely_nested_simulation] to every simulating halt decider.
>>>>> This equally applies to all of the halting problem instances.
>>>>>
>>>>> Ĥ(Ĥ) is short-hand for:
>>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>>> Σ*,
>>>>> say ŵ. This string, in addition to being the description of Ĥ can
>>>>> also be used
>>>>> as input string. We can therefore legitimately ask what would happen
>>>>> if Ĥ is
>>>>> applied to ŵ. (Linz:1990:320)
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and
>>>>> Automata. Lexington/Toronto: D. C. Heath and Company. (315-320)
>>>>
>>>> Nonsense.  H is the name given in Linz to a non-existent Turing
>>>> machine.  H^, derived from it, also does not exit.  Anyone who has read
>>>> that book should know that H^([H^]) specifies no behaviour at all.
>>>>
>>>> You have constructed a poor-man's partial decider that gets the "hat"
>>>> case wrong, but you can't justify the wrong answer by appeal Linz.
>>>>
>>>> Your "infinitely nested simulation" explanation for your decider giving
>>>> the wrong answer can be put on a more formal basis, but you can't do by
>>>> re-using the names of nonexistent TM's from Linz.
>>>>
>>>
>>> Well I won't say that you are not a genius or that you don't know the
>>> theory of computation very well.
>>>
>>> The actual Ĥ(<Ĥ>) does specify [infinitely_nested_simulation] to every
>>> simulating halt decider. This [infinitely_nested_simulation] is more
>>> complex than the one that Halts recognizes.
>>>
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>
>>> The above is adapted from (Linz:1990:319).
>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>> executing an embedded copy of the original halt decider with this input
>>> at (qx).
>>>
>>> The (qy) state indicates that the halt decider decides that its input
>>> would halt. The ((qn)) state indicates the input would not halt. The
>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>> decider decides that its input would halt.
>>>
>>> It can be understood from the above specification that when the embedded
>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>> and it has (Ĥ,  Ĥ) as its input that:
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy then
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy then
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy...
>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>
>> BUT, since H is required to be finite in execution, the copy of H within
>> H^ must have some alteration from a simple simulator to break the loop.
>>
>> If it does, then it WILL break the loop, and be finite in execution.
>>
>> If it doesn't then H(H^,H^) won't break the loop, and thus will not
>> answer in finite time and thus fail to give an answer and not be a
>> decider.
>>
> 
> That is why we need this truism to dislodge the pathological
> self-reference:
> 
> On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Truism:
>>> Every simulation that would never stop unless Halts() stops
>>> it at some point specifies infinite execution.
>>
>> Any algorithm that implements this truism is, of course, a halting
>> decider.
> 
> Whether a computation is finite is more nuanced than it simply stops
> running otherwise an infinite loop that had its simulation aborted
> because its behavior matched the [infinite_loop] non-halting behavior
> pattern would have to be classified as a halting computation.
> 
> Unless the simulating halt decider stops simulating Ĥ(Ĥ) at some point
> its simulation would be infinite ∴ meets the non-halting truism.
> 

But you can't use a 'Falsism' to change the facts about the definition.

And, as I have said, there IS no pathological self-reference in the problem.

YOU create the self-reference by not implementing the required copy
operation. In actuality the Linz proof has no real self-reference, just
two copies of what just happens to be the same thing.

[toc] | [prev] | [next] | [standalone]


#33735

Fromolcott <NoOne@NoWhere.com>
Date2021-05-16 18:21 -0500
Message-ID<EsCdnduL051HNTz9nZ2dnUU7-d_NnZ2d@giganews.com>
In reply to#33715
On 5/16/2021 6:05 PM, Richard Damon wrote:
> On 5/16/21 5:37 PM, olcott wrote:
>> On 5/16/2021 4:19 PM, Richard Damon wrote:
>>> On 5/16/21 5:00 PM, olcott wrote:
>>>> On 5/16/2021 3:21 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> Any genius knowing the theory of computation quite well can easily
>>>>>> confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of
>>>>>> [infinitely_nested_simulation] to every simulating halt decider.
>>>>>> This equally applies to all of the halting problem instances.
>>>>>>
>>>>>> Ĥ(Ĥ) is short-hand for:
>>>>>> Now Ĥ is a Turing machine, so that it will have some description in
>>>>>> Σ*,
>>>>>> say ŵ. This string, in addition to being the description of Ĥ can
>>>>>> also be used
>>>>>> as input string. We can therefore legitimately ask what would happen
>>>>>> if Ĥ is
>>>>>> applied to ŵ. (Linz:1990:320)
>>>>>>
>>>>>> Linz, Peter 1990. An Introduction to Formal Languages and
>>>>>> Automata. Lexington/Toronto: D. C. Heath and Company. (315-320)
>>>>>
>>>>> Nonsense.  H is the name given in Linz to a non-existent Turing
>>>>> machine.  H^, derived from it, also does not exit.  Anyone who has read
>>>>> that book should know that H^([H^]) specifies no behaviour at all.
>>>>>
>>>>> You have constructed a poor-man's partial decider that gets the "hat"
>>>>> case wrong, but you can't justify the wrong answer by appeal Linz.
>>>>>
>>>>> Your "infinitely nested simulation" explanation for your decider giving
>>>>> the wrong answer can be put on a more formal basis, but you can't do by
>>>>> re-using the names of nonexistent TM's from Linz.
>>>>>
>>>>
>>>> Well I won't say that you are not a genius or that you don't know the
>>>> theory of computation very well.
>>>>
>>>> The actual Ĥ(<Ĥ>) does specify [infinitely_nested_simulation] to every
>>>> simulating halt decider. This [infinitely_nested_simulation] is more
>>>> complex than the one that Halts recognizes.
>>>>
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>
>>>> The above is adapted from (Linz:1990:319).
>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>>> executing an embedded copy of the original halt decider with this input
>>>> at (qx).
>>>>
>>>> The (qy) state indicates that the halt decider decides that its input
>>>> would halt. The ((qn)) state indicates the input would not halt. The
>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>>> decider decides that its input would halt.
>>>>
>>>> It can be understood from the above specification that when the embedded
>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>>> and it has (Ĥ,  Ĥ) as its input that:
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy then
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy then
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy...
>>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>>
>>> BUT, since H is required to be finite in execution, the copy of H within
>>> H^ must have some alteration from a simple simulator to break the loop.
>>>
>>> If it does, then it WILL break the loop, and be finite in execution.
>>>
>>> If it doesn't then H(H^,H^) won't break the loop, and thus will not
>>> answer in finite time and thus fail to give an answer and not be a
>>> decider.
>>>
>>
>> That is why we need this truism to dislodge the pathological
>> self-reference:
>>
>> On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Truism:
>>>> Every simulation that would never stop unless Halts() stops
>>>> it at some point specifies infinite execution.
>>>
>>> Any algorithm that implements this truism is, of course, a halting
>>> decider.
>>
>> Whether a computation is finite is more nuanced than it simply stops
>> running otherwise an infinite loop that had its simulation aborted
>> because its behavior matched the [infinite_loop] non-halting behavior
>> pattern would have to be classified as a halting computation.
>>
>> Unless the simulating halt decider stops simulating Ĥ(Ĥ) at some point
>> its simulation would be infinite ∴ meets the non-halting truism.
>>
> 
> But you can't use a 'Falsism' to change the facts about the definition.
> 
> And, as I have said, there IS no pathological self-reference in the problem.
> 
> YOU create the self-reference by not implementing the required copy
> operation. In actuality the Linz proof has no real self-reference, just
> two copies of what just happens to be the same thing.
> 

I am referring to the complete Peter Linz version where a copy <is> made.

Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn

The above is adapted from (Linz:1990:319).
It shows that Turing machine Ĥ copies its input at (q0) and begins 
executing an embedded copy of the original halt decider with this input 
at (qx).

The (qy) state indicates that the halt decider decides that its input 
would halt. The ((qn)) state indicates the input would not halt. The 
appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt 
decider decides that its input would halt.

It can be understood from the above specification that when the embedded 
halt decider @Ĥ.qx bases its halting decision on simulating its input, 
and it has (Ĥ,  Ĥ) as its input that:
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy...
unless and until the halt decider @Ĥ.qx stops simulating its input.

Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company.



-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33740

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-16 21:11 -0400
Message-ID<HojoI.604824$%W6.542760@fx44.iad>
In reply to#33735
On 5/16/21 7:21 PM, olcott wrote:
> On 5/16/2021 6:05 PM, Richard Damon wrote:

>>
>> But you can't use a 'Falsism' to change the facts about the definition.
>>
>> And, as I have said, there IS no pathological self-reference in the
>> problem.
>>
>> YOU create the self-reference by not implementing the required copy
>> operation. In actuality the Linz proof has no real self-reference, just
>> two copies of what just happens to be the same thing.
>>
> 
> I am referring to the complete Peter Linz version where a copy <is> made.
> 
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
> 
> The above is adapted from (Linz:1990:319).
> It shows that Turing machine Ĥ copies its input at (q0) and begins
> executing an embedded copy of the original halt decider with this input
> at (qx).
> 
> The (qy) state indicates that the halt decider decides that its input
> would halt. The ((qn)) state indicates the input would not halt. The
> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
> decider decides that its input would halt.
> 
> It can be understood from the above specification that when the embedded
> halt decider @Ĥ.qx bases its halting decision on simulating its input,
> and it has (Ĥ,  Ĥ) as its input that:
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy...
> unless and until the halt decider @Ĥ.qx stops simulating its input.
> 
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company.
> 
> 
> 
Key point to notice is that Linz's description doesn't have ANY
self-reference, or even things done via a 'reference'

EVERYTHING is done with a copy, and there is no references to be self.

H^ has its own copy of the algorithm of H in it, it doesn't 'reference'
H, so this is NOT a self-reference.

The input to H^ doesn't 'reference' H^, it is built on the description of H^

With no references, you can't have self-reference.

The only self-references in your 'proof' are the one YOU create by not
making the 'required' copies. This also makes it so things are likely
not actually the Equivalents of the required Turing Machines. Another
flaw in your proof.

[toc] | [prev] | [next] | [standalone]


#33750

Fromolcott <NoOne@NoWhere.com>
Date2021-05-16 21:01 -0500
Message-ID<daudnYwj2vzXUzz9nZ2dnUU7-XPNnZ2d@giganews.com>
In reply to#33740
On 5/16/2021 8:11 PM, Richard Damon wrote:
> On 5/16/21 7:21 PM, olcott wrote:
>> On 5/16/2021 6:05 PM, Richard Damon wrote:
> 
>>>
>>> But you can't use a 'Falsism' to change the facts about the definition.
>>>
>>> And, as I have said, there IS no pathological self-reference in the
>>> problem.
>>>
>>> YOU create the self-reference by not implementing the required copy
>>> operation. In actuality the Linz proof has no real self-reference, just
>>> two copies of what just happens to be the same thing.
>>>
>>
>> I am referring to the complete Peter Linz version where a copy <is> made.
>>
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>
>> The above is adapted from (Linz:1990:319).
>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>> executing an embedded copy of the original halt decider with this input
>> at (qx).
>>
>> The (qy) state indicates that the halt decider decides that its input
>> would halt. The ((qn)) state indicates the input would not halt. The
>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>> decider decides that its input would halt.
>>
>> It can be understood from the above specification that when the embedded
>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>> and it has (Ĥ,  Ĥ) as its input that:
>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>> this copy then
>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>> this copy then
>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>> this copy...
>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>
>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company.
>>
>>
>>
> Key point to notice is that Linz's description doesn't have ANY
> self-reference, or even things done via a 'reference'
> 
> EVERYTHING is done with a copy, and there is no references to be self.

The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way 
that all entirely black cats are only rainbow colored and not black at all.

> 
> H^ has its own copy of the algorithm of H in it, it doesn't 'reference'
> H, so this is NOT a self-reference.
> 
> The input to H^ doesn't 'reference' H^, it is built on the description of H^
> 
> With no references, you can't have self-reference.
> 
> The only self-references in your 'proof' are the one YOU create by not
> making the 'required' copies. This also makes it so things are likely
> not actually the Equivalents of the required Turing Machines. Another
> flaw in your proof.
> 


-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33753

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-16 23:18 -0400
Message-ID<ngloI.149087$gq3.16218@fx04.iad>
In reply to#33750
On 5/16/21 10:01 PM, olcott wrote:
> On 5/16/2021 8:11 PM, Richard Damon wrote:
>> On 5/16/21 7:21 PM, olcott wrote:
>>> On 5/16/2021 6:05 PM, Richard Damon wrote:
>>
>>>>
>>>> But you can't use a 'Falsism' to change the facts about the definition.
>>>>
>>>> And, as I have said, there IS no pathological self-reference in the
>>>> problem.
>>>>
>>>> YOU create the self-reference by not implementing the required copy
>>>> operation. In actuality the Linz proof has no real self-reference, just
>>>> two copies of what just happens to be the same thing.
>>>>
>>>
>>> I am referring to the complete Peter Linz version where a copy <is>
>>> made.
>>>
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>
>>> The above is adapted from (Linz:1990:319).
>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>> executing an embedded copy of the original halt decider with this input
>>> at (qx).
>>>
>>> The (qy) state indicates that the halt decider decides that its input
>>> would halt. The ((qn)) state indicates the input would not halt. The
>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>> decider decides that its input would halt.
>>>
>>> It can be understood from the above specification that when the embedded
>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>> and it has (Ĥ,  Ĥ) as its input that:
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy then
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy then
>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>> this copy...
>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>>
>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>> Lexington/Toronto: D. C. Heath and Company.
>>>
>>>
>>>
>> Key point to notice is that Linz's description doesn't have ANY
>> self-reference, or even things done via a 'reference'
>>
>> EVERYTHING is done with a copy, and there is no references to be self.
> 
> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way
> that all entirely black cats are only rainbow colored and not black at all.

Please show where in a proper encoding of H^(H^) you ever have something
generate an actual reference to something. PLEASE.

H^ has a COPY OF (not a reference to) H within it.

It is given a DESCRIPTION OF (not a reference to) H^

No reference in sight!

YOU fail to copy Halts, and make H_Hat use a reference to it, but that
is actually in violation to the structure described in Linz.

Turing Machines do not DO 'references'.

[toc] | [prev] | [next] | [standalone]


#33754

Fromolcott <NoOne@NoWhere.com>
Date2021-05-16 22:23 -0500
Message-ID<lO2dncjmT5ftfDz9nZ2dnUU7-IWdnZ2d@giganews.com>
In reply to#33753
On 5/16/2021 10:18 PM, Richard Damon wrote:
> On 5/16/21 10:01 PM, olcott wrote:
>> On 5/16/2021 8:11 PM, Richard Damon wrote:
>>> On 5/16/21 7:21 PM, olcott wrote:
>>>> On 5/16/2021 6:05 PM, Richard Damon wrote:
>>>
>>>>>
>>>>> But you can't use a 'Falsism' to change the facts about the definition.
>>>>>
>>>>> And, as I have said, there IS no pathological self-reference in the
>>>>> problem.
>>>>>
>>>>> YOU create the self-reference by not implementing the required copy
>>>>> operation. In actuality the Linz proof has no real self-reference, just
>>>>> two copies of what just happens to be the same thing.
>>>>>
>>>>
>>>> I am referring to the complete Peter Linz version where a copy <is>
>>>> made.
>>>>
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>
>>>> The above is adapted from (Linz:1990:319).
>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>>> executing an embedded copy of the original halt decider with this input
>>>> at (qx).
>>>>
>>>> The (qy) state indicates that the halt decider decides that its input
>>>> would halt. The ((qn)) state indicates the input would not halt. The
>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>>> decider decides that its input would halt.
>>>>
>>>> It can be understood from the above specification that when the embedded
>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>>> and it has (Ĥ,  Ĥ) as its input that:
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy then
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy then
>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>> this copy...
>>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>>>
>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>> Lexington/Toronto: D. C. Heath and Company.
>>>>
>>>>
>>>>
>>> Key point to notice is that Linz's description doesn't have ANY
>>> self-reference, or even things done via a 'reference'
>>>
>>> EVERYTHING is done with a copy, and there is no references to be self.
>>
>> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way
>> that all entirely black cats are only rainbow colored and not black at all.
> 
> Please show where in a proper encoding of H^(H^) you ever have something
> generate an actual reference to something. PLEASE.
> 

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf

> H^ has a COPY OF (not a reference to) H within it.
> 
> It is given a DESCRIPTION OF (not a reference to) H^
> 
> No reference in sight!
> 

I have provided the full reference at least 50 times now.

> YOU fail to copy Halts, and make H_Hat use a reference to it, but that
> is actually in violation to the structure described in Linz.
> 
> Turing Machines do not DO 'references'.
> 

I changed the subject from the x86utm H_Hat C/x86 computation to the 
actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice.


-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33769

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-17 07:11 -0400
Message-ID<BbsoI.227125$N_4.174401@fx36.iad>
In reply to#33754
On 5/16/21 11:23 PM, olcott wrote:
> On 5/16/2021 10:18 PM, Richard Damon wrote:
>> On 5/16/21 10:01 PM, olcott wrote:
>>> On 5/16/2021 8:11 PM, Richard Damon wrote:
>>>> On 5/16/21 7:21 PM, olcott wrote:
>>>>> On 5/16/2021 6:05 PM, Richard Damon wrote:
>>>>
>>>>>>
>>>>>> But you can't use a 'Falsism' to change the facts about the
>>>>>> definition.
>>>>>>
>>>>>> And, as I have said, there IS no pathological self-reference in the
>>>>>> problem.
>>>>>>
>>>>>> YOU create the self-reference by not implementing the required copy
>>>>>> operation. In actuality the Linz proof has no real self-reference,
>>>>>> just
>>>>>> two copies of what just happens to be the same thing.
>>>>>>
>>>>>
>>>>> I am referring to the complete Peter Linz version where a copy <is>
>>>>> made.
>>>>>
>>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>>
>>>>> The above is adapted from (Linz:1990:319).
>>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>>>> executing an embedded copy of the original halt decider with this
>>>>> input
>>>>> at (qx).
>>>>>
>>>>> The (qy) state indicates that the halt decider decides that its input
>>>>> would halt. The ((qn)) state indicates the input would not halt. The
>>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>>>> decider decides that its input would halt.
>>>>>
>>>>> It can be understood from the above specification that when the
>>>>> embedded
>>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>>>> and it has (Ĥ,  Ĥ) as its input that:
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy then
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy then
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy...
>>>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company.
>>>>>
>>>>>
>>>>>
>>>> Key point to notice is that Linz's description doesn't have ANY
>>>> self-reference, or even things done via a 'reference'
>>>>
>>>> EVERYTHING is done with a copy, and there is no references to be self.
>>>
>>> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way
>>> that all entirely black cats are only rainbow colored and not black
>>> at all.
>>
>> Please show where in a proper encoding of H^(H^) you ever have something
>> generate an actual reference to something. PLEASE.
>>
> 
> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> 
>> H^ has a COPY OF (not a reference to) H within it.
>>
>> It is given a DESCRIPTION OF (not a reference to) H^
>>
>> No reference in sight!
>>
> 
> I have provided the full reference at least 50 times now.
> 
>> YOU fail to copy Halts, and make H_Hat use a reference to it, but that
>> is actually in violation to the structure described in Linz.
>>
>> Turing Machines do not DO 'references'.
>>
> 
> I changed the subject from the x86utm H_Hat C/x86 computation to the
> actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice.
> 
> 

[toc] | [prev] | [next] | [standalone]


#33770

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-17 07:26 -0400
Message-ID<GpsoI.240833$PE7.20906@fx39.iad>
In reply to#33754
On 5/16/21 11:23 PM, olcott wrote:
> On 5/16/2021 10:18 PM, Richard Damon wrote:
>> On 5/16/21 10:01 PM, olcott wrote:
>>> On 5/16/2021 8:11 PM, Richard Damon wrote:
>>>> On 5/16/21 7:21 PM, olcott wrote:
>>>>> On 5/16/2021 6:05 PM, Richard Damon wrote:
>>>>
>>>>>>
>>>>>> But you can't use a 'Falsism' to change the facts about the
>>>>>> definition.
>>>>>>
>>>>>> And, as I have said, there IS no pathological self-reference in the
>>>>>> problem.
>>>>>>
>>>>>> YOU create the self-reference by not implementing the required copy
>>>>>> operation. In actuality the Linz proof has no real self-reference,
>>>>>> just
>>>>>> two copies of what just happens to be the same thing.
>>>>>>
>>>>>
>>>>> I am referring to the complete Peter Linz version where a copy <is>
>>>>> made.
>>>>>
>>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
>>>>> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
>>>>>
>>>>> The above is adapted from (Linz:1990:319).
>>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins
>>>>> executing an embedded copy of the original halt decider with this
>>>>> input
>>>>> at (qx).
>>>>>
>>>>> The (qy) state indicates that the halt decider decides that its input
>>>>> would halt. The ((qn)) state indicates the input would not halt. The
>>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
>>>>> decider decides that its input would halt.
>>>>>
>>>>> It can be understood from the above specification that when the
>>>>> embedded
>>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input,
>>>>> and it has (Ĥ,  Ĥ) as its input that:
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy then
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy then
>>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
>>>>> this copy...
>>>>> unless and until the halt decider @Ĥ.qx stops simulating its input.
>>>>>
>>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
>>>>> Lexington/Toronto: D. C. Heath and Company.
>>>>>
>>>>>
>>>>>
>>>> Key point to notice is that Linz's description doesn't have ANY
>>>> self-reference, or even things done via a 'reference'
>>>>
>>>> EVERYTHING is done with a copy, and there is no references to be self.
>>>
>>> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way
>>> that all entirely black cats are only rainbow colored and not black
>>> at all.
>>
>> Please show where in a proper encoding of H^(H^) you ever have something
>> generate an actual reference to something. PLEASE.
>>
> 
> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> 
>> H^ has a COPY OF (not a reference to) H within it.
>>
>> It is given a DESCRIPTION OF (not a reference to) H^
>>
>> No reference in sight!
>>
> 
> I have provided the full reference at least 50 times now.

YOU have posted REFERENCES to articles, yes.

You haven't provided ANY indication of where the problem you are
describing actually includes anything IN THE PROBLEM that is actually a
reference to something else in th problem.

If nothing refers by reference, there can't be self-reference.

H^ includes the code for H not by reference, but by making a copy. When
H is deciding on H^, it doesn't see 'it self' in the machine, but
machine that just happens to match what it does.

The input to H^ isn't a reference to itself, but a pattern that just
happens to match a description of itself.

At no point can anything in the problem just look at what it is given
and say, oh, that's ME!

YOU change the definition of the problem to convert these copies into
actual references, and in doing so you actually break the Turing
Equivalence, because at the fundamental level, Turing Machines don't do
references.

I will again challenge you, WHERE in the original problem is there
actually a reference that becomes a self-reference?

> 
>> YOU fail to copy Halts, and make H_Hat use a reference to it, but that
>> is actually in violation to the structure described in Linz.
>>
>> Turing Machines do not DO 'references'.
>>
> 
> I changed the subject from the x86utm H_Hat C/x86 computation to the
> actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice.
> 
> 

Non-responsive. Just proves that you didn't actually read things but
just throw out random words when you feel cornered.

Yes, a machine that claims to be a decider and just starts by blindly
simulating will get into an infinite loop of recusing down the
simulation tree. These means that said claimed decider will not be able
to answer in finite time. This makes that claimed decider wrong, not the
problem.

If said claimed decider is improved to see the problem and stop it, now
said decider may be able to answer in time, but, at least with your
method, it can get the wrong answer because it doesn't get to see what
the machine it is deciding on will do with that answer.

Again, that is the problem with the design of that claimed decider, not
the problem.

ALL you have shown is that the method you claim is the obvious way to
try to solve the problem doesn't work, not that some how the problem is
defective.

There is actually no basis to claim that there actually NEEDS to be a
way to solve the problem, the answer that you can't build a Halt Decider
that get all problems correctly is a perfectly good answer.

[toc] | [prev] | [next] | [standalone]


#33775

FromMalcolm McLean <malcolm.arthur.mclean@gmail.com>
Date2021-05-17 05:45 -0700
Message-ID<15406379-420c-4c32-b713-be57e31901ban@googlegroups.com>
In reply to#33770
On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
> 
> If said claimed decider is improved to see the problem and stop it, now 
> said decider may be able to answer in time, but, at least with your 
> method, it can get the wrong answer because it doesn't get to see what 
> the machine it is deciding on will do with that answer. 
> 
> Again, that is the problem with the design of that claimed decider, not 
> the problem. 
> 
It's an inherent problem with all deciders. You can simulate until it
"looks stuck" and you might have a very good decider. But there will
be some inputs which "look stuck" but aren't, and you will decide
wrongly, and you can't design that out, because whatever your criteria
an attacker can always look stuck, add one one step, then halt.

[toc] | [prev] | [next] | [standalone]


#33782

Fromolcott <NoOne@NoWhere.com>
Date2021-05-17 10:23 -0500
Message-ID<Va-dnaC0HKatFz_9nZ2dnUU7-bfNnZ2d@giganews.com>
In reply to#33775
On 5/17/2021 7:45 AM, Malcolm McLean wrote:
> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>
>> If said claimed decider is improved to see the problem and stop it, now
>> said decider may be able to answer in time, but, at least with your
>> method, it can get the wrong answer because it doesn't get to see what
>> the machine it is deciding on will do with that answer.
>>
>> Again, that is the problem with the design of that claimed decider, not
>> the problem.
>>
> It's an inherent problem with all deciders. You can simulate until it
> "looks stuck" and you might have a very good decider. But there will
> be some inputs which "look stuck" but aren't, and you will decide
> wrongly, and you can't design that out, because whatever your criteria
> an attacker can always look stuck, add one one step, then halt.
> 

When a sufficient non-halting behavior pattern of [infinite_loop] or
[infinitely_nested_simulation] has been matched then it has been proven 
on the basis that counter-examples do not exist that these patterns do 
match behavior that will never stop unless its simulation is aborted.

The [infinitely_nested_simulation] behavior pattern must be adapted to 
the Linz proof Ĥ(<Ĥ>).

That the behavior Ĥ(<Ĥ>) would meet a [infinitely_nested_simulation] 
behavior pattern can be seen on the basis of the execution trace of 
Ĥ(<Ĥ>) shown below:

Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn

The above is adapted from (Linz:1990:319).
It shows that Turing machine Ĥ copies its input at (q0) and begins 
executing an embedded copy of the original halt decider with this input 
at (qx).

The (qy) state indicates that the halt decider decides that its input 
would halt. The ((qn)) state indicates the input would not halt. The 
appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt 
decider decides that its input would halt.

Linz, Peter 1990. An Introduction to Formal Languages and Automata. 
Lexington/Toronto: D. C. Heath and Company.

The above definition specifies this execution trace:
It can be understood from the above specification that when the embedded 
halt decider @Ĥ.qx bases its halting decision on simulating its input, 
and it has (<Ĥ>,<Ĥ>) as its input that:
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy then
Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with 
this copy...
unless and until the halt decider @Ĥ.qx stops simulating its input.

As long as any halt decider must ever stop simulating its input the 
input does specify non-halting. The first halt decider that see this 
reports it.

The convoluted way of saying Ĥ(<Ĥ>):
Now Ĥ is a Turing machine, so that it will have some description in Σ*,
say ŵ. This string, in addition to being the description of Ĥ can also 
be used
as input string. We can therefore legitimately ask what would happen if Ĥ is
applied to ŵ.

Because Ĥ(<Ĥ>) must abort the simulation of its input ∴ this input <is> 
correctly decided as non-halting.

Because H(<Ĥ>,<Ĥ>) must abort the simulation of its input ∴ this input 
<is> correctly decided as non-halting.



-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33824

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-17 20:41 -0400
Message-ID<k3EoI.129389$D16.17075@fx40.iad>
In reply to#33782
On 5/17/21 11:23 AM, olcott wrote:
> On 5/17/2021 7:45 AM, Malcolm McLean wrote:
>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>
>>> If said claimed decider is improved to see the problem and stop it, now
>>> said decider may be able to answer in time, but, at least with your
>>> method, it can get the wrong answer because it doesn't get to see what
>>> the machine it is deciding on will do with that answer.
>>>
>>> Again, that is the problem with the design of that claimed decider, not
>>> the problem.
>>>
>> It's an inherent problem with all deciders. You can simulate until it
>> "looks stuck" and you might have a very good decider. But there will
>> be some inputs which "look stuck" but aren't, and you will decide
>> wrongly, and you can't design that out, because whatever your criteria
>> an attacker can always look stuck, add one one step, then halt.
>>
> 
> When a sufficient non-halting behavior pattern of [infinite_loop] or
> [infinitely_nested_simulation] has been matched then it has been proven
> on the basis that counter-examples do not exist that these patterns do
> match behavior that will never stop unless its simulation is aborted.

Yes, you MAY be able to recognize a behavior and can prove that it is
non-halting.

Your 'infinite recursion template', at least the way you process it,
isn't right, as it DOES match the finite machine H_Hat(H_Hat).

> 
> The [infinitely_nested_simulation] behavior pattern must be adapted to
> the Linz proof Ĥ(<Ĥ>).

And that is going to be a problem for you. Since Turing Machines DON'T
have this handy 'address' and the Turing Machine you are simulating will
have its own copy of the decider, and the machine it will ask its
decider will have its own. There is no simple test to use in the Turing
Machine to detect this.
> 
> That the behavior Ĥ(<Ĥ>) would meet a [infinitely_nested_simulation]
> behavior pattern can be seen on the basis of the execution trace of
> Ĥ(<Ĥ>) shown below:
> 
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qy  ∞
> Ĥ.q0  wM  ⊢*  Ĥ.qx  wM  wM  ⊢*  Ĥ.qn
> 
> The above is adapted from (Linz:1990:319).
> It shows that Turing machine Ĥ copies its input at (q0) and begins
> executing an embedded copy of the original halt decider with this input
> at (qx).
> 
> The (qy) state indicates that the halt decider decides that its input
> would halt. The ((qn)) state indicates the input would not halt. The
> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt
> decider decides that its input would halt.
> 
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company.
> 
> The above definition specifies this execution trace:
> It can be understood from the above specification that when the embedded
> halt decider @Ĥ.qx bases its halting decision on simulating its input,
> and it has (<Ĥ>,<Ĥ>) as its input that:
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy then
> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with
> this copy...
> unless and until the halt decider @Ĥ.qx stops simulating its input.
> 
> As long as any halt decider must ever stop simulating its input the
> input does specify non-halting. The first halt decider that see this
> reports it.

Right, so if the algorithm of the Halt Decider doesn't have anything to
break this pattern, the Computation will be infinite. But then so will
the asking of it directly to decide H(H^,H^), so H^ doesn't need to
worry about refuting that case.

If H DOES have in its algorithn the capability to detect this loop and
terminate it, then H^ has that in its copy of H, and so H^ will not run
infinitely, get its answer from its copy of H and do the opposite, thus
making H wrong.

> 
> The convoluted way of saying Ĥ(<Ĥ>):
> Now Ĥ is a Turing machine, so that it will have some description in Σ*,
> say ŵ. This string, in addition to being the description of Ĥ can also
> be used
> as input string. We can therefore legitimately ask what would happen if
> Ĥ is
> applied to ŵ.
> 
> Because Ĥ(<Ĥ>) must abort the simulation of its input ∴ this input <is>
> correctly decided as non-halting.
> 
> Because H(<Ĥ>,<Ĥ>) must abort the simulation of its input ∴ this input
> <is> correctly decided as non-halting.
> 

Except that we see that H^(H^) will Halt, and thus it was wrong.

The creator of H had several choices:

They could let H just run in the loop and not return an answer, then H
starts failing to decide, so it is clearly not universally right.

They could detect the loop and call it non-halting (like you do) but
then H^ will halt when given the answer so it was wrong.

They could detect the loop and decider to be sneeky and say halting, at
which point H^ see that and loops forever so it is still wrong.

They could even try to do something more to try to figure out what the
input would do, but whatever it returns, will be wrong.

Ultimately, H WILL be wrong about H^, not because the definition of the
problem is wrong, but because, just like in Tic-Tac-Toe, always winning
this game is impossible.

H doesn't get to redefine the 'winning condition', that isn't allowed,
it just has to settle for doing the best it can, and that is being just
a partial halt decider, and one machine it will NEVER be able to get
right is the H^ that was built on it.

[toc] | [prev] | [next] | [standalone]


#33792

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-17 20:27 +0100
Message-ID<87sg2l2ma2.fsf@bsb.me.uk>
In reply to#33775
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>> 
>> If said claimed decider is improved to see the problem and stop it, now 
>> said decider may be able to answer in time, but, at least with your 
>> method, it can get the wrong answer because it doesn't get to see what 
>> the machine it is deciding on will do with that answer. 
>> 
>> Again, that is the problem with the design of that claimed decider, not 
>> the problem. 
>> 
> It's an inherent problem with all deciders. You can simulate until it
> "looks stuck" and you might have a very good decider.

You seem determined to encourage PO's misconceptions.  PO assumes
simulation is involved.  No one else should.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#33793

Fromolcott <NoOne@NoWhere.com>
Date2021-05-17 14:31 -0500
Message-ID<356dndvIucnMWT_9nZ2dnUU7-bmdnZ2d@giganews.com>
In reply to#33792
On 5/17/2021 2:27 PM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
> 
>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>
>>> If said claimed decider is improved to see the problem and stop it, now
>>> said decider may be able to answer in time, but, at least with your
>>> method, it can get the wrong answer because it doesn't get to see what
>>> the machine it is deciding on will do with that answer.
>>>
>>> Again, that is the problem with the design of that claimed decider, not
>>> the problem.
>>>
>> It's an inherent problem with all deciders. You can simulate until it
>> "looks stuck" and you might have a very good decider.
> 
> You seem determined to encourage PO's misconceptions.  PO assumes
> simulation is involved.  No one else should.
> 

None-the-less you cannot possibly provide any correct rebuttal because 
none exists.

My current proof simply shows exactly how the exact Peter Linz H would 
correctly decide not halting on the exact Peter Linz Ĥ.

This definition of halting circumvents the pathological self-reference 
error for every simulating halt decider:

An input is decided to be halting only if its simulation never needs to 
be stopped by any simulating halt decider anywhere in its entire 
invocation chain.

On that basis:
Ĥ(<Ĥ>) ⊢* Ĥ.qn
H(<Ĥ>,<Ĥ>) ⊢* H.qn


-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33815

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-18 01:38 +0100
Message-ID<87eee43mgf.fsf@bsb.me.uk>
In reply to#33793
olcott <NoOne@NoWhere.com> writes:

> On 5/17/2021 2:27 PM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>>
>>>> If said claimed decider is improved to see the problem and stop it, now
>>>> said decider may be able to answer in time, but, at least with your
>>>> method, it can get the wrong answer because it doesn't get to see what
>>>> the machine it is deciding on will do with that answer.
>>>>
>>>> Again, that is the problem with the design of that claimed decider, not
>>>> the problem.
>>>>
>>> It's an inherent problem with all deciders. You can simulate until it
>>> "looks stuck" and you might have a very good decider.
>>
>> You seem determined to encourage PO's misconceptions.  PO assumes
>> simulation is involved.  No one else should.
>
> None-the-less you cannot possibly provide any correct rebuttal because
> none exists.

There's nothing to rebut as far as I can see.  You've defined a "new
kind if halting" which no one cares about.  What you need is someone to
tell you to stop lying about it being halting.  Is there no friend you
can turn to who will help you stay honest?

> My current proof simply shows exactly how the exact Peter Linz H would
> correctly decide not halting on the exact Peter Linz Ĥ.

Don't be silly.  The rebuttal is in Linz.

> This definition of halting circumvents the pathological self-reference
> error for every simulating halt decider:

The definition is halting is already settled.  You need a new name for
whatever property you think we should care about.  Whatever you think
your mysterious and hidden Halts function decides, it is not halting.

> An input is decided to be halting only if its simulation never needs
> to be stopped by any simulating halt decider anywhere in its entire
> invocation chain.

However, an input /should/ be decided to be halting only if the sequence
of machine configurations it generates is finite.  No one cares about
whatever it is you've decided to misname halting.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#33819

Fromolcott <NoOne@NoWhere.com>
Date2021-05-17 19:54 -0500
Message-ID<IO6dnYnAp8SQjT79nZ2dnUU7-IPNnZ2d@giganews.com>
In reply to#33815
On 5/17/2021 7:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 5/17/2021 2:27 PM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>
>>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>>>
>>>>> If said claimed decider is improved to see the problem and stop it, now
>>>>> said decider may be able to answer in time, but, at least with your
>>>>> method, it can get the wrong answer because it doesn't get to see what
>>>>> the machine it is deciding on will do with that answer.
>>>>>
>>>>> Again, that is the problem with the design of that claimed decider, not
>>>>> the problem.
>>>>>
>>>> It's an inherent problem with all deciders. You can simulate until it
>>>> "looks stuck" and you might have a very good decider.
>>>
>>> You seem determined to encourage PO's misconceptions.  PO assumes
>>> simulation is involved.  No one else should.
>>
>> None-the-less you cannot possibly provide any correct rebuttal because
>> none exists.
> 
> There's nothing to rebut as far as I can see.  You've defined a "new
> kind if halting" which no one cares about.  What you need is someone to
> tell you to stop lying about it being halting.  Is there no friend you
> can turn to who will help you stay honest?
> 
>> My current proof simply shows exactly how the exact Peter Linz H would
>> correctly decide not halting on the exact Peter Linz Ĥ.
> 
> Don't be silly.  The rebuttal is in Linz.
> 

On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
 > olcott <NoOne@NoWhere.com> writes:
 >
 >> Truism:
 >> Every simulation that would never stop unless Halts() stops
 >> it at some point specifies infinite execution.
 >
 > Any algorithm that implements this truism is, of course, a halting
 > decider.

Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating it 
precisely meeting the criteria of a non-halting computation therefore Ĥ 
correctly decides that its input <Ĥ> is a non-halting computation.


>> This definition of halting circumvents the pathological self-reference
>> error for every simulating halt decider:
> 
> The definition is halting is already settled.  You need a new name for
> whatever property you think we should care about.  Whatever you think
> your mysterious and hidden Halts function decides, it is not halting.
> 
>> An input is decided to be halting only if its simulation never needs
>> to be stopped by any simulating halt decider anywhere in its entire
>> invocation chain.
> 
> However, an input /should/ be decided to be halting only if the sequence
> of machine configurations it generates is finite.  No one cares about
> whatever it is you've decided to misname halting.
> 


-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [next] | [standalone]


#33822

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-17 21:21 -0400
Message-ID<BEEoI.340488$ST2.334418@fx47.iad>
In reply to#33819
On 5/17/21 8:54 PM, olcott wrote:
> On 5/17/2021 7:38 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 5/17/2021 2:27 PM, Ben Bacarisse wrote:
>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>
>>>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>>>>
>>>>>> If said claimed decider is improved to see the problem and stop
>>>>>> it, now
>>>>>> said decider may be able to answer in time, but, at least with your
>>>>>> method, it can get the wrong answer because it doesn't get to see
>>>>>> what
>>>>>> the machine it is deciding on will do with that answer.
>>>>>>
>>>>>> Again, that is the problem with the design of that claimed
>>>>>> decider, not
>>>>>> the problem.
>>>>>>
>>>>> It's an inherent problem with all deciders. You can simulate until it
>>>>> "looks stuck" and you might have a very good decider.
>>>>
>>>> You seem determined to encourage PO's misconceptions.  PO assumes
>>>> simulation is involved.  No one else should.
>>>
>>> None-the-less you cannot possibly provide any correct rebuttal because
>>> none exists.
>>
>> There's nothing to rebut as far as I can see.  You've defined a "new
>> kind if halting" which no one cares about.  What you need is someone to
>> tell you to stop lying about it being halting.  Is there no friend you
>> can turn to who will help you stay honest?
>>
>>> My current proof simply shows exactly how the exact Peter Linz H would
>>> correctly decide not halting on the exact Peter Linz Ĥ.
>>
>> Don't be silly.  The rebuttal is in Linz.
>>
> 
> On 5/11/2021 11:10 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Truism:
>>> Every simulation that would never stop unless Halts() stops
>>> it at some point specifies infinite execution.
>>
>> Any algorithm that implements this truism is, of course, a halting
>> decider.
> 
> Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating it
> precisely meeting the criteria of a non-halting computation therefore Ĥ
> correctly decides that its input <Ĥ> is a non-halting computation.
> 
> 

WRONG.

H^ Halts because its own algorithm made that decision.

The Simulator made a mistake, and H^ USES that mistake to allow itself
to Halt.

There is a simulator that terminates its simulation but it isn't the
simulation of the machine we are running, as the test isn't to run a
simulation of H^, but to run H^.

H^ uses the alrgorithm of H to determine that H will say non-halting
when it is run on H(H^,H^) and thus it knows that it wants to be a
halting computation. Due to the structure of the 'game' H^ has the upper
hand over H and can always defeat it.

[toc] | [prev] | [next] | [standalone]


#34010

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-20 12:57 +0100
Message-ID<87fsyhvcre.fsf@bsb.me.uk>
In reply to#33819
olcott <NoOne@NoWhere.com> writes:

> Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating
> it precisely meeting the criteria of a non-halting computation
> therefore Ĥ correctly decides that its input <Ĥ> is a non-halting
> computation.

Garbage.  So many errors it's almost impossible to reply.  Let me have a
go.

> Ĥ(<Ĥ>) Input <Ĥ> only halts

Inputs don't halt or not halt.  Inputs are strings.  TM's halt or don't
halt when presented with input strings.

> because its simulator stopped simulating
> it precisely meeting the criteria of a non-halting computation

It's called the silly-non-halting criterion.  You refused to pick a name
so I picked that one.  Call the criterion something that it is not is
dishonest.

> therefore Ĥ correctly decides

H^ is not a decider.

> that its input <Ĥ> is a non-halting computation.

<H^> is not even a computation.  It's a string, and it's not even a
string representing a computation.

The facts:

(a) UTM^([UTM^]) is not a finite computation.  The "hat" construction
    means that a pure simulator will not halt on it's "hat" version.

(b) Your partial decider, D, is a UTM that also scans for the
    silly-non-halting pattern.  It is not a UTM.

(c) D^([D^]) is a finite computation.

(d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
    according to you, the correct result or the silly-non-halting
    problem.

You see?  If you don't abuse names and language it's easy to keep things
clear and simple.

Notation: M(s) is the computation that results from Turing machine M
applied to string s.  [M] is the string encoding of a TM M.  <x, y> is
the encoding of a pair of strings.  <[M], s> is therefore the string
representing M(s).

M^(s) is M'(<s, s>) where M' is a TM that does not halt on exactly those
inputs on which M halts.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#33825

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-17 20:43 -0400
Message-ID<Q4EoI.129390$D16.102450@fx40.iad>
In reply to#33793
On 5/17/21 3:31 PM, olcott wrote:
> On 5/17/2021 2:27 PM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote:
>>>>
>>>> If said claimed decider is improved to see the problem and stop it, now
>>>> said decider may be able to answer in time, but, at least with your
>>>> method, it can get the wrong answer because it doesn't get to see what
>>>> the machine it is deciding on will do with that answer.
>>>>
>>>> Again, that is the problem with the design of that claimed decider, not
>>>> the problem.
>>>>
>>> It's an inherent problem with all deciders. You can simulate until it
>>> "looks stuck" and you might have a very good decider.
>>
>> You seem determined to encourage PO's misconceptions.  PO assumes
>> simulation is involved.  No one else should.
>>
> 
> None-the-less you cannot possibly provide any correct rebuttal because
> none exists.
> 
> My current proof simply shows exactly how the exact Peter Linz H would
> correctly decide not halting on the exact Peter Linz Ĥ.

Except Linz said what the correct decision was for H^, the opposite of
whatever H will say, as H will be wrong.
> 
> This definition of halting circumvents the pathological self-reference
> error for every simulating halt decider:
> 
> An input is decided to be halting only if its simulation never needs to
> be stopped by any simulating halt decider anywhere in its entire
> invocation chain.
> 
> On that basis:
> Ĥ(<Ĥ>) ⊢* Ĥ.qn
> H(<Ĥ>,<Ĥ>) ⊢* H.qn
> 
> 

But it isn't the right definition of Halting!

[toc] | [prev] | [next] | [standalone]


Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.theory


csiph-web