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


Groups > sci.logic > #172557 > unrolled thread

Re: Infinitely Recursive input on HP Proofs (Final Solution?)

Started byNewberry <newberryxy@gmail.com>
First post2018-02-12 20:27 -0800
Last post2018-02-15 12:25 -0600
Articles 20 on this page of 41 — 6 participants

Back to article view | Back to sci.logic

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 (Final Solution?) Newberry <newberryxy@gmail.com> - 2018-02-12 20:27 -0800
    Re: Infinitely Recursive input on HP Proofs (Final Solution?) grahamcooper7@gmail.com - 2018-02-12 21:29 -0800
    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 00:18 -0600
      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 13:06 +0000
        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 16:55 -0600
          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 00:30 +0000
            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 19:38 -0600
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 02:27 +0000
                Re: Infinitely Recursive input on HP Proofs (Final Solution?) peteolcott <peterolcott2@gmail.com> - 2018-02-13 20:06 -0800
          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-14 22:55 +0000
            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 17:22 -0600
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) grahamcooper7@gmail.com - 2018-02-14 16:20 -0800
                Re: Infinitely Recursive input on HP Proofs (Final Solution?) peteolcott <peterolcott2@gmail.com> - 2018-02-14 16:29 -0800
                  Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-15 02:19 +0000
                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 21:00 -0600
                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) grahamcooper7@gmail.com - 2018-02-14 22:57 -0800
                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 09:06 -0600
                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-15 21:38 +0000
                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:27 -0600
                          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:34 -0600
                          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 00:15 +0000
                            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 18:43 -0600
                              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 01:05 +0000
                                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 19:37 -0600
                                  Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 02:34 +0000
                                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 20:51 -0600
                                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 03:32 +0000
                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 22:42 -0600
                                          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 12:06 +0000
                                            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 10:26 -0600
                                              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 20:42 +0000
                                                Re: Infinitely Recursive input on HP Proofs (Final Solution?) peteolcott <peterolcott2@gmail.com> - 2018-02-16 13:16 -0800
                                                  Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 23:01 +0000
                                                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 17:48 -0600
                                                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-17 01:33 +0000
                                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) grahamcooper7@gmail.com - 2018-02-16 17:49 -0800
                                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-19 15:48 +0000
                                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-22 15:31 -0600
                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) grahamcooper7@gmail.com - 2018-02-16 02:53 -0800
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-15 12:24 +0000
                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 12:25 -0600

Page 1 of 3  [1] 2 3  Next page →


#172557 — Re: Infinitely Recursive input on HP Proofs (Final Solution?)

FromNewberry <newberryxy@gmail.com>
Date2018-02-12 20:27 -0800
SubjectRe: Infinitely Recursive input on HP Proofs (Final Solution?)
Message-ID<3907eb66-b587-4026-a8ab-571c740a0217@googlegroups.com>
On Sunday, February 11, 2018 at 8:45:26 AM UTC-8, Pete Olcott wrote:
> 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. 
> 
>     
>     http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>       
> 
>     
> 
>     Refutation of Halting Problem Proof
> 
>     
> 
>     Decidability
>         of the Halting Problem as a David Hilbert formalism
> 
>     ∃a ∈ Turing_Machines_Descriptions
> 
>     ∀b ∈ Finite_Strings  // some of these specify Turing Machine
>     Descriptions
> 
>     ∀c ∈ Finite_Strings
> 
>     Halts(a, b, c) ∨ ~Halts(a, b, c)
> 
>     
> 
>     Halt Decider
>       definition
> 
>     A Halt Decider (HD) determines whether or not a finite string
>     represents a correct 
> 
>     Turing Machine Description that would halt on its input. It does
>     this by performing 
> 
>     a mathematical proof on a pair of finite strings as a David Hilbert
>     formalism in the 
> 
>     language of Turing Machine Descriptions.
> 
>     
> 
>     The
>         syntactic logical consequence of this proof is two finite
>         strings:
> 
>     (1) “Y”  input pair (b,c) is a correct TMD that would halt on its
>     input.
> 
>     (2) “N” indicating the else branch of (1).
> 
>     
> 
>     If the first element of the input finite string pair is a correct
>     TMD then this proof 
> 
>     must necessarily proceed from the specified TMD start state through
>     all of the 
> 
>     state transitions of this TMD to the halting or non halting behavior
>     of this TMD.
> 
>     
> 
>     The proof would essentially be a hypothetical execution trace** of
>     the state 
> 
>     transition sequences of the input TMD. It cannot be an actual
>     execution trace 
> 
>     or the halt decider could have non-halting behavior.
> 
>     ** Like step-by-step mode in a debugger.
> 
>     
> 
>     http://liarparadox.org/HP_Infinite_Recursion.pdf
> 
>     The following has been adapted from material from the above link:
> 
>     We begin our analysis by constructing a hypothetical halt decider:
>     H.
> 
>     
> 
>     Figure 12.1 Turing Machine H
> 
>     
> 
>     
> 
>     The dashed lines proceeding from state (q0) are represented in the
>     text 
> 
>     definition as the asterisk ⊢* wildcard character. These conventions
>     are 
> 
>     used to encode unspecified state transition sequences.
> 
>     
> 
>     Definition of
>       Turing Machine H (state transition sequence)
> 
>     H.q0 Wm W ⊢* H.qy  // Wm W corresponds to (b,c) shown above
> 
>     H.q0 Wm W ⊢* H.qn  // Wm W corresponds to (b,c) shown above
> 
>     
> 
>     The diagram and the state transition sequence indicate that H begins
>     at 
> 
>     its own start state H.q0 and is applied to finite string pair (Wm,
>     W).
> 
>     
> 
>     H.qy is the final state of H indicating that Wm is a correct TM that
>     would 
> 
>     halt on input W.  Syntactic
>         logical consequence : “Y” (shown above).
> 
>     
> 
>     H.qn is the final state of H indicating that Wm is not a correct TM
>     that would 
> 
>     halt on input W.  Syntactic
>         logical consequence: “N” (shown above).
> 
>     
> 
>     We create Turing
>       Machine Ĥx by making the following changes to H:
> 
>     (1) Ĥx copies its input Wm a its Ĥx.q0 state and transitions to its
>     Ĥx.qx state.
> 
>     
> 
>     (2) Ĥx would begin to evaluate Wm Wm at its Ĥx.qx state in exactly 
> 
>     the same way that H would begin to evaluate its Wm W input at its
>     H.q0 state.
> 
>     
> 
>     Since Turing Machine Ĥx is created by adapting H, it would have
>     exactly the 
> 
>     same behavior at its Ĥx.qx state as H would have at its H.q0 state.
> 
>     
> 
>                   Figure 12.4 Turing Machine Ĥx
> 
>     
> 
>     
> 
>       Definition of Turing Machine Ĥx (state transition sequence)
> 
>     Ĥx.q0 Wm ⊢* Ĥx.qx Wm
>       Wm ⊢* Ĥx.qy   // NO LOOP
> 
>     Ĥx.q0 Wm ⊢* Ĥx.qx Wm
>       Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
> 
>     
> 
>         If Turing Machine H is applied to Turing Machine description
>         [Ĥx] [Ĥx] 
> 
>      would it
>         transition to H.y or H.n ? 
> 
>     
> 
>       We append a “2” to the input to [Ĥx] for clarity [Ĥx2] is a copy
>       of [Ĥx].
> 
>     
> 
>         To answer this question we perform an execution trace on H
> 
>     (1) H begins at
>       its start state H.q0.
> 
>     (2) H begins to evaluate what [Ĥx] would do on its input
>       [Ĥx2].
> 
>     
> 
>         Hypothetical Execution trace of what [Ĥ] would do if it was
>         executed
> 
>     (3) [Ĥx] would
>       begin at its start state [Ĥx].q0
> 
>     (4) [Ĥx] would make a copy of its input [Ĥx2], we will
>     call this [Ĥx3].
> 
>     (5) [Ĥx] would transition to its state [Ĥx].qx.
> 
>     (6) [Ĥx] would begin to evaluate what [Ĥx2] would do on its
>       input [Ĥx3].
> 
>     Can you see
>       the infinite recursion?
> 
>     
> 
>     H [Ĥx] [Ĥx] specifies an infinitely recursive evaluation sequence.
> 
>     Every HP proof by contradiction depends this same infinite
>     recursion.
> 
>     
> 
>     Because of this every TMD in the infinitely recursive sequence is
>     defined in 
> 
>     terms of H each would reject the whole sequence as semantically
>     incorrect 
> 
>         before even beginning any halting evaluation.
> 
>     
> 
> https://groups.google.com/forum/#!original/comp.theory/RO9Z9eCabeE/Ka8-xS2rdEEJ
>     
> 
>     Therefore H would correctly transition to its H.qn state rejecting
>     the 
> 
>     infinitely recursive evaluation sequence specified by [Ĥx] [Ĥx] as
>     the 
> 
>     semantic error of Pathological self-reference(Olcott 2004).
> 
So H^x goes to qn, i.e. it halts, but H does not know that it has halted.     
> 
>     Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott
> 
>     
> 
>     
> -- 
> 
>       
>       
>             ∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X)

[toc] | [next] | [standalone]


#172563

Fromgrahamcooper7@gmail.com
Date2018-02-12 21:29 -0800
Message-ID<6d2137ff-2225-454b-ac4f-5adfc2b79d74@googlegroups.com>
In reply to#172557
On Tuesday, February 13, 2018 at 2:27:47 PM UTC+10, Newberry wrote:
> On Sunday, February 11, 2018 at 8:45:26 AM UTC-8, Pete Olcott wrote:
> > 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. 
> > 
> >     
> >     http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> >       
> > 
> >     
> > 
> >     Refutation of Halting Problem Proof
> > 
> >     
> > 
> >     Decidability
> >         of the Halting Problem as a David Hilbert formalism
> > 
> >     ∃a ∈ Turing_Machines_Descriptions
> > 
> >     ∀b ∈ Finite_Strings  // some of these specify Turing Machine
> >     Descriptions
> > 
> >     ∀c ∈ Finite_Strings
> > 
> >     Halts(a, b, c) ∨ ~Halts(a, b, c)
> > 
> >     
> > 
> >     Halt Decider
> >       definition
> > 
> >     A Halt Decider (HD) determines whether or not a finite string
> >     represents a correct 
> > 
> >     Turing Machine Description that would halt on its input. It does
> >     this by performing 
> > 
> >     a mathematical proof on a pair of finite strings as a David Hilbert
> >     formalism in the 
> > 
> >     language of Turing Machine Descriptions.
> > 
> >     
> > 
> >     The
> >         syntactic logical consequence of this proof is two finite
> >         strings:
> > 
> >     (1) “Y”  input pair (b,c) is a correct TMD that would halt on its
> >     input.
> > 
> >     (2) “N” indicating the else branch of (1).
> > 
> >     
> > 
> >     If the first element of the input finite string pair is a correct
> >     TMD then this proof 
> > 
> >     must necessarily proceed from the specified TMD start state through
> >     all of the 
> > 
> >     state transitions of this TMD to the halting or non halting behavior
> >     of this TMD.
> > 
> >     
> > 
> >     The proof would essentially be a hypothetical execution trace** of
> >     the state 
> > 
> >     transition sequences of the input TMD. It cannot be an actual
> >     execution trace 
> > 
> >     or the halt decider could have non-halting behavior.
> > 
> >     ** Like step-by-step mode in a debugger.
> > 
> >     
> > 
> >     http://liarparadox.org/HP_Infinite_Recursion.pdf
> > 
> >     The following has been adapted from material from the above link:
> > 
> >     We begin our analysis by constructing a hypothetical halt decider:
> >     H.
> > 
> >     
> > 
> >     Figure 12.1 Turing Machine H
> > 
> >     
> > 
> >     
> > 
> >     The dashed lines proceeding from state (q0) are represented in the
> >     text 
> > 
> >     definition as the asterisk ⊢* wildcard character. These conventions
> >     are 
> > 
> >     used to encode unspecified state transition sequences.
> > 
> >     
> > 
> >     Definition of
> >       Turing Machine H (state transition sequence)
> > 
> >     H.q0 Wm W ⊢* H.qy  // Wm W corresponds to (b,c) shown above
> > 
> >     H.q0 Wm W ⊢* H.qn  // Wm W corresponds to (b,c) shown above
> > 
> >     
> > 
> >     The diagram and the state transition sequence indicate that H begins
> >     at 
> > 
> >     its own start state H.q0 and is applied to finite string pair (Wm,
> >     W).
> > 
> >     
> > 
> >     H.qy is the final state of H indicating that Wm is a correct TM that
> >     would 
> > 
> >     halt on input W.  Syntactic
> >         logical consequence : “Y” (shown above).
> > 
> >     
> > 
> >     H.qn is the final state of H indicating that Wm is not a correct TM
> >     that would 
> > 
> >     halt on input W.  Syntactic
> >         logical consequence: “N” (shown above).
> > 
> >     
> > 
> >     We create Turing
> >       Machine Ĥx by making the following changes to H:
> > 
> >     (1) Ĥx copies its input Wm a its Ĥx.q0 state and transitions to its
> >     Ĥx.qx state.
> > 
> >     
> > 
> >     (2) Ĥx would begin to evaluate Wm Wm at its Ĥx.qx state in exactly 
> > 
> >     the same way that H would begin to evaluate its Wm W input at its
> >     H.q0 state.
> > 
> >     
> > 
> >     Since Turing Machine Ĥx is created by adapting H, it would have
> >     exactly the 
> > 
> >     same behavior at its Ĥx.qx state as H would have at its H.q0 state.
> > 
> >     
> > 
> >                   Figure 12.4 Turing Machine Ĥx
> > 
> >     
> > 
> >     
> > 
> >       Definition of Turing Machine Ĥx (state transition sequence)
> > 
> >     Ĥx.q0 Wm ⊢* Ĥx.qx Wm
> >       Wm ⊢* Ĥx.qy   // NO LOOP
> > 
> >     Ĥx.q0 Wm ⊢* Ĥx.qx Wm
> >       Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
> > 
> >     
> > 
> >         If Turing Machine H is applied to Turing Machine description
> >         [Ĥx] [Ĥx] 
> > 
> >      would it
> >         transition to H.y or H.n ? 
> > 
> >     
> > 
> >       We append a “2” to the input to [Ĥx] for clarity [Ĥx2] is a copy
> >       of [Ĥx].
> > 
> >     
> > 
> >         To answer this question we perform an execution trace on H
> > 
> >     (1) H begins at
> >       its start state H.q0.
> > 
> >     (2) H begins to evaluate what [Ĥx] would do on its input
> >       [Ĥx2].
> > 
> >     
> > 
> >         Hypothetical Execution trace of what [Ĥ] would do if it was
> >         executed
> > 
> >     (3) [Ĥx] would
> >       begin at its start state [Ĥx].q0
> > 
> >     (4) [Ĥx] would make a copy of its input [Ĥx2], we will
> >     call this [Ĥx3].
> > 
> >     (5) [Ĥx] would transition to its state [Ĥx].qx.
> > 
> >     (6) [Ĥx] would begin to evaluate what [Ĥx2] would do on its
> >       input [Ĥx3].
> > 
> >     Can you see
> >       the infinite recursion?
> > 
> >     
> > 
> >     H [Ĥx] [Ĥx] specifies an infinitely recursive evaluation sequence.
> > 



 
> So H^x goes to qn, i.e. it halts, but H does not know that it has halted.  



No even simpler than that!


HALT(   H^x , H^x  )  =  TRUE



H^x inputs H^x

and Analyses H^x( H^x )


The only option is to OUTPUT TRUE  (qYES)

and HALT CORRECTLY!


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


#172566

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-13 00:18 -0600
Message-ID<y6qdnS5-u8qvHh_HnZ2dnUU7-e_NnZ2d@giganews.com>
In reply to#172557
On 2/12/2018 10:27 PM, Newberry wrote:
> On Sunday, February 11, 2018 at 8:45:26 AM UTC-8, Pete Olcott wrote:
>> 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.
>>
>>      
>>      http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>        
>>
>>      
>>
>>      Refutation of Halting Problem Proof
>>
>>      
>>
>>      Decidability
>>          of the Halting Problem as a David Hilbert formalism
>>
>>      ∃a ∈ Turing_Machines_Descriptions
>>
>>      ∀b ∈ Finite_Strings  // some of these specify Turing Machine
>>      Descriptions
>>
>>      ∀c ∈ Finite_Strings
>>
>>      Halts(a, b, c) ∨ ~Halts(a, b, c)
>>
>>      
>>
>>      Halt Decider
>>        definition
>>
>>      A Halt Decider (HD) determines whether or not a finite string
>>      represents a correct
>>
>>      Turing Machine Description that would halt on its input. It does
>>      this by performing
>>
>>      a mathematical proof on a pair of finite strings as a David Hilbert
>>      formalism in the
>>
>>      language of Turing Machine Descriptions.
>>
>>      
>>
>>      The
>>          syntactic logical consequence of this proof is two finite
>>          strings:
>>
>>      (1) “Y”  input pair (b,c) is a correct TMD that would halt on its
>>      input.
>>
>>      (2) “N” indicating the else branch of (1).
>>
>>      
>>
>>      If the first element of the input finite string pair is a correct
>>      TMD then this proof
>>
>>      must necessarily proceed from the specified TMD start state through
>>      all of the
>>
>>      state transitions of this TMD to the halting or non halting behavior
>>      of this TMD.
>>
>>      
>>
>>      The proof would essentially be a hypothetical execution trace** of
>>      the state
>>
>>      transition sequences of the input TMD. It cannot be an actual
>>      execution trace
>>
>>      or the halt decider could have non-halting behavior.
>>
>>      ** Like step-by-step mode in a debugger.
>>
>>      
>>
>>      http://liarparadox.org/HP_Infinite_Recursion.pdf
>>
>>      The following has been adapted from material from the above link:
>>
>>      We begin our analysis by constructing a hypothetical halt decider:
>>      H.
>>
>>      
>>
>>      Figure 12.1 Turing Machine H
>>
>>      
>>
>>      
>>
>>      The dashed lines proceeding from state (q0) are represented in the
>>      text
>>
>>      definition as the asterisk ⊢* wildcard character. These conventions
>>      are
>>
>>      used to encode unspecified state transition sequences.
>>
>>      
>>
>>      Definition of
>>        Turing Machine H (state transition sequence)
>>
>>      H.q0 Wm W ⊢* H.qy  // Wm W corresponds to (b,c) shown above
>>
>>      H.q0 Wm W ⊢* H.qn  // Wm W corresponds to (b,c) shown above
>>
>>      
>>
>>      The diagram and the state transition sequence indicate that H begins
>>      at
>>
>>      its own start state H.q0 and is applied to finite string pair (Wm,
>>      W).
>>
>>      
>>
>>      H.qy is the final state of H indicating that Wm is a correct TM that
>>      would
>>
>>      halt on input W.  Syntactic
>>          logical consequence : “Y” (shown above).
>>
>>      
>>
>>      H.qn is the final state of H indicating that Wm is not a correct TM
>>      that would
>>
>>      halt on input W.  Syntactic
>>          logical consequence: “N” (shown above).
>>
>>      
>>
>>      We create Turing
>>        Machine Ĥx by making the following changes to H:
>>
>>      (1) Ĥx copies its input Wm a its Ĥx.q0 state and transitions to its
>>      Ĥx.qx state.
>>
>>      
>>
>>      (2) Ĥx would begin to evaluate Wm Wm at its Ĥx.qx state in exactly
>>
>>      the same way that H would begin to evaluate its Wm W input at its
>>      H.q0 state.
>>
>>      
>>
>>      Since Turing Machine Ĥx is created by adapting H, it would have
>>      exactly the
>>
>>      same behavior at its Ĥx.qx state as H would have at its H.q0 state.
>>
>>      
>>
>>                    Figure 12.4 Turing Machine Ĥx
>>
>>      
>>
>>      
>>
>>  Definition of Turing Machine Ĥx (state transition sequence)
>>  Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
>>  Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
>>
>>      
>>
>>          If Turing Machine H is applied to Turing Machine description
>>          [Ĥx] [Ĥx]
>>
>>       would it
>>          transition to H.y or H.n ?
>>
>>      
>>
>>        We append a “2” to the input to [Ĥx] for clarity [Ĥx2] is a copy
>>        of [Ĥx].
>>
>>      
>>
>>          To answer this question we perform an execution trace on H
>>
>>      (1) H begins at
>>        its start state H.q0.
>>
>>      (2) H begins to evaluate what [Ĥx] would do on its input
>>        [Ĥx2].
>>
>>      
>>
>>          Hypothetical Execution trace of what [Ĥ] would do if it was
>>          executed
>>
>>      (3) [Ĥx] would
>>        begin at its start state [Ĥx].q0
>>
>>      (4) [Ĥx] would make a copy of its input [Ĥx2], we will
>>      call this [Ĥx3].
>>
>>      (5) [Ĥx] would transition to its state [Ĥx].qx.
>>
>>      (6) [Ĥx] would begin to evaluate what [Ĥx2] would do on its
>>        input [Ĥx3].
>>
>>      Can you see
>>        the infinite recursion?
>>
>>      
>>
>>      H [Ĥx] [Ĥx] specifies an infinitely recursive evaluation sequence.
>>
>>      Every HP proof by contradiction depends this same infinite
>>      recursion.
>>
>>      
>>
>>      Because of this every TMD in the infinitely recursive sequence is
>>      defined in
>>
>>      terms of H each would reject the whole sequence as semantically
>>      incorrect
>>
>>          before even beginning any halting evaluation.
>>
>>      
>>
>> https://groups.google.com/forum/#!original/comp.theory/RO9Z9eCabeE/Ka8-xS2rdEEJ
>>      
>>
>>      Therefore H would correctly transition to its H.qn state rejecting
>>      the
>>
>>      infinitely recursive evaluation sequence specified by [Ĥx] [Ĥx] as
>>      the
>>
>>      semantic error of Pathological self-reference(Olcott 2004).
>>
> So H^x goes to qn, i.e. it halts, but H does not know that it has halted.

... Definition of Turing Machine Ĥx (state transition sequence)
... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER

H [Ĥx] [Ĥx]
H performs a debug trace on [Ĥx] [Ĥx] and aborts this trace when
it detects the specified infinitely recursive evaluation sequence.

Ĥx [Ĥx] [Ĥx] would do the same thing.

Every [Ĥx] in the infinitely recursive evaluation sequence begins
its debug trace of its input its state Ĥx.qx

So it should be clear by now that we know exactly that all halt
deciders must do a debug trace on their input until they detect
the halting, non halting behavior or erroneous nature of this input.

Because of this we know exactly how a correct halt decider must
decide this input: [Ĥx] [Ĥx].


>>      Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott  

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


#172583

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-13 13:06 +0000
Message-ID<876071ghst.fsf@bsb.me.uk>
In reply to#172566
Pete Olcott <Pete@NoEmail.address> writes:
<snip>
> ... Definition of Turing Machine Ĥx (state transition sequence)
> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER

These lines say that H^x always halts (on any input).  This is one of
the few correct things in this post.  You don't say in which
circumstances it goes to qy or qn but, as you say, I can infer that form
the context.

And it is still not a definition of a TM.  No matter how many times you
repeat that phrase, those lines do not define a Turing machine.  They
never will.

> H [Ĥx] [Ĥx]
> H performs a debug trace on [Ĥx] [Ĥx] and aborts this trace when
> it detects the specified infinitely recursive evaluation sequence.

H is supposed to a halt decider so there is no question of what it must
do -- it must halt in state qy.  (Again, due to a lack of imagination,
you assume how it must do it, but the conclusion is the same -- it must
accept.)

> So it should be clear by now that we know exactly that all halt
> deciders must do a debug trace on their input until they detect
> the halting, non halting behavior or erroneous nature of this input.

There is nothing erroneous about the input.  The construction of H^x is
such that it will halt on all inputs.

> Because of this we know exactly how a correct halt decider must
> decide this input: [Ĥx] [Ĥx].

We know that it must accept simply because H^x must always halt.  It is
built from a decider which always halts, and the construction includes
nothing that can change that.

H^x is about the silliest thing so far.  Not only is it trivial to
analyse, but it can not help you show that there is something wrong with
the proof because it simply does not appear in the proof.  You can
invent new constructions all you like, but the proof is valid because of
the behaviour of the constructions it uses.

You are wasting your time on a construction that won't help you say why
you think the proof that you have fixed on is wrong.  Obviously, going
on about a distraction like this is helpful, since the proof is not
wrong, but you won't show it's wrong using H^x.  All you can do with H^x
is waste time.

-- 
Ben.

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


#172620

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-13 16:55 -0600
Message-ID<0eGdnVEyGIJs8R7HnZ2dnUU7-fHNnZ2d@giganews.com>
In reply to#172583
On 2/13/2018 7:06 AM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> <snip>
>> ... Definition of Turing Machine Ĥx (state transition sequence)
>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
> 
> These lines say that H^x always halts (on any input).  This is one of
> the few correct things in this post.  You don't say in which
> circumstances it goes to qy or qn but, as you say, I can infer that form
> the context.
> 
> And it is still not a definition of a TM.  No matter how many times you
> repeat that phrase, those lines do not define a Turing machine.  They
> never will.
> 

They completely define enough that an actual debug trace can be performed
on the state transition sequence from Ĥx.q0 to Ĥx.qx and the steps
immediately after Ĥx.qx because we know that a halt decider is defined
to do a debug trace on its input until:
(1) Halting behavior is detected.
(2) Non-Halting behavior is detected.
(3) Erroneous input is detected.

Thus this necessarily applies recursively to
--- H [Ĥx] [Ĥx2]
--- Ĥx2 [Ĥx3] [Ĥx4]
--- Ĥx3 [Ĥx4] [Ĥx5]

This is an enormously difficult thing to see that you do not see
it right away does not indicate that I am incorrect. I think that
you are getting closer to seeing this.

>> H [Ĥx] [Ĥx]
>> H performs a debug trace on [Ĥx] [Ĥx] and aborts this trace when
>> it detects the specified infinitely recursive evaluation sequence.
> 
> H is supposed to a halt decider so there is no question of what it must
> do -- it must halt in state qy. 

Sure and the question: "What time is it (yes or no)?"
must be answered only with Yes or No, INCORRECT QUESTION is not allowed,
yet none-the-less the question remain incorrect no matter what the
semantically incoherent problem requirements are.

> (Again, due to a lack of imagination,
> you assume how it must do it, but the conclusion is the same -- it must
> accept.)
> 

Sure then you correctly answer my incorrect question!

I came up with this incorrect question years ago on comp.theory.
I later discussed at great length the apparently brand new concept
of an incorrect polar questio0n on sci.lang.

>> So it should be clear by now that we know exactly that all halt
>> deciders must do a debug trace on their input until they detect
>> the halting, non halting behavior or erroneous nature of this input.
> 
> There is nothing erroneous about the input.  The construction of H^x is
> such that it will halt on all inputs.

Then is the current time Yes or is it No ???

> 
>> Because of this we know exactly how a correct halt decider must
>> decide this input: [Ĥx] [Ĥx].
> 
> We know that it must accept simply because H^x must always halt.  It is
> built from a decider which always halts, and the construction includes
> nothing that can change that.

Since it ONLY halts because each halt decider in the sequence aborts
the halt evaluation sequence before halting evaluation even begins
the halt decider is not deciding halting when it transitions to H.qn.

See the big picture here. Every single undecidable decision problem
is only undecidable because it is semantically incorrect. The HP proof
is merely one of many examples.

> 
> H^x is about the silliest thing so far.  Not only is it trivial to
> analyse, but it can not help you show that there is something wrong with
> the proof because it simply does not appear in the proof.  You can
> invent new constructions all you like, but the proof is valid because of
> the behaviour of the constructions it uses.
> 

It superficially seems that way until you fully realize that the only
reason that any correct halt decider in the infinitely recursive evaluation
sequence halts is that it must necessarily reject the entire evaluation
sequence before any halting decision is ever made.

Try and correctly determine if the Liar Paradox is True or False and
you will fail only because the LP is a semantically incorrect expression
of language in the same way that: H [Ĥx][Ĥx] is a semantically incorrect
expression of language.

All undecidable decision problems are semantically incorrect in this same way.
If I would not have see this same thing expressed several different ways
I would not have noticed the same problem in the HP proof.

> You are wasting your time on a construction that won't help you say why
> you think the proof that you have fixed on is wrong.  

I have not fixed the proof. The essential proof remains the same.
I have just shown that it does not actually provide a basis for its conclusion.

> Obviously, going
> on about a distraction like this is helpful, since the proof is not
> wrong, but you won't show it's wrong using H^x.  All you can do with H^x
> is waste time.
> 

The proof is correct right up until the conclusion that a correct halt
decider cannot exist is asserted, then it fails.

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172628

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 00:30 +0000
Message-ID<87a7wcfm4k.fsf@bsb.me.uk>
In reply to#172620
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/13/2018 7:06 AM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>> <snip>
>>> ... Definition of Turing Machine Ĥx (state transition sequence)
>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
>>
>> These lines say that H^x always halts (on any input).  This is one of
>> the few correct things in this post.  You don't say in which
>> circumstances it goes to qy or qn but, as you say, I can infer that form
>> the context.
>>
>> And it is still not a definition of a TM.  No matter how many times you
>> repeat that phrase, those lines do not define a Turing machine.  They
>> never will.
>
> They completely define enough that an actual debug trace can be performed
> on the state transition sequence from Ĥx.q0 to Ĥx.qx and the steps
> immediately after Ĥx.qx because we know that a halt decider is defined
> to do a debug trace on its input until:

You don't know what H does so you don't know what H^x does.  All you
know is that if H exists it decides (not PO-decides) halting (not
PO-halting) and therefore it always halts.

> (1) Halting behavior is detected.
> (2) Non-Halting behavior is detected.
> (3) Erroneous input is detected.
>
> Thus this necessarily applies recursively to
> --- H [Ĥx] [Ĥx2]
> --- Ĥx2 [Ĥx3] [Ĥx4]
> --- Ĥx3 [Ĥx4] [Ĥx5]

Are you talking about the halting problem, of the PO-problem?  It sounds
like the later.  I'd have to give two answers to every point you make
unless I know what problem you are talking about so I'll wait and see
which you are talking about.

<snip awaiting to find out what you are talking about>
-- 
Ben.

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


#172646

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-13 19:38 -0600
Message-ID<SO2dnWo1R8uPDh7HnZ2dnUU7-IudnZ2d@giganews.com>
In reply to#172628
On 2/13/2018 6:30 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/13/2018 7:06 AM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>> <snip>
>>>> ... Definition of Turing Machine Ĥx (state transition sequence)
>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
>>>
>>> These lines say that H^x always halts (on any input).  This is one of
>>> the few correct things in this post.  You don't say in which
>>> circumstances it goes to qy or qn but, as you say, I can infer that form
>>> the context.
>>>
>>> And it is still not a definition of a TM.  No matter how many times you
>>> repeat that phrase, those lines do not define a Turing machine.  They
>>> never will.
>>
>> They completely define enough that an actual debug trace can be performed
>> on the state transition sequence from Ĥx.q0 to Ĥx.qx and the steps
>> immediately after Ĥx.qx because we know that a halt decider is defined
>> to do a debug trace on its input until:
> 
> You don't know what H does so you don't know what H^x does.  All you
> know is that if H exists it decides (not PO-decides) halting (not
> PO-halting) and therefore it always halts.
> 
>> (1) Halting behavior is detected.
>> (2) Non-Halting behavior is detected.
>> (3) Erroneous input is detected.
>>
>> Thus this necessarily applies recursively to
>> --- H [Ĥx] [Ĥx2]
>> --- Ĥx2 [Ĥx3] [Ĥx4]
>> --- Ĥx3 [Ĥx4] [Ĥx5]
> 
> Are you talking about the halting problem, of the PO-problem?  It sounds
> like the later.  I'd have to give two answers to every point you make
> unless I know what problem you are talking about so I'll wait and see
> which you are talking about.
> 
> <snip awaiting to find out what you are talking about>
> 

You know that every halt decider must have two inputs right?
Yes or no?

You also know that conventionally another machine is specified
that takes one input and copies it and then evaluates halting
for this pair as it input pair?
Yes or No?

You also know that every TMD requires it own input pair
Yes or No?

If you said Yes, Yes, Yes, then you should be able to see
that the input to any machine so defined is infinitely recursive.

I will keep a single minded focus on this one point with you until
you either understand and agree or prove that truth is not your goal.

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172653

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 02:27 +0000
Message-ID<87k1vge25w.fsf@bsb.me.uk>
In reply to#172646
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/13/2018 6:30 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 2/13/2018 7:06 AM, Ben Bacarisse wrote:
>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>> <snip>
>>>>> ... Definition of Turing Machine Ĥx (state transition sequence)
>>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
>>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
>>>>
>>>> These lines say that H^x always halts (on any input).  This is one of
>>>> the few correct things in this post.  You don't say in which
>>>> circumstances it goes to qy or qn but, as you say, I can infer that form
>>>> the context.
>>>>
>>>> And it is still not a definition of a TM.  No matter how many times you
>>>> repeat that phrase, those lines do not define a Turing machine.  They
>>>> never will.
>>>
>>> They completely define enough that an actual debug trace can be performed
>>> on the state transition sequence from Ĥx.q0 to Ĥx.qx and the steps
>>> immediately after Ĥx.qx because we know that a halt decider is defined
>>> to do a debug trace on its input until:
>>
>> You don't know what H does so you don't know what H^x does.  All you
>> know is that if H exists it decides (not PO-decides) halting (not
>> PO-halting) and therefore it always halts.
>>
>>> (1) Halting behavior is detected.
>>> (2) Non-Halting behavior is detected.
>>> (3) Erroneous input is detected.
>>>
>>> Thus this necessarily applies recursively to
>>> --- H [Ĥx] [Ĥx2]
>>> --- Ĥx2 [Ĥx3] [Ĥx4]
>>> --- Ĥx3 [Ĥx4] [Ĥx5]
>>
>> Are you talking about the halting problem, of the PO-problem?  It sounds
>> like the later.  I'd have to give two answers to every point you make
>> unless I know what problem you are talking about so I'll wait and see
>> which you are talking about.

No answer?  It matters.  If you are not talking about the halting
problem, we can stop right away.  I have no interest in the PO-halting
problem.

>> <snip awaiting to find out what you are talking about>
>>
>
> You know that every halt decider must have two inputs right?
> Yes or no?

No.

> You also know that conventionally another machine is specified
> that takes one input and copies it and then evaluates halting
> for this pair as it input pair?
> Yes or No?

No.

> You also know that every TMD requires it own input pair
> Yes or No?

No.

> If you said Yes, Yes, Yes, then you should be able to see
> that the input to any machine so defined is infinitely recursive.
>
> I will keep a single minded focus on this one point with you until
> you either understand and agree or prove that truth is not your goal.

Any chance you will answer my question and say what halting problem you
are talking about?

-- 
Ben.

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


#172660

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-13 20:06 -0800
Message-ID<5a5b403d-a082-4184-8b8c-e58c82d95e71@googlegroups.com>
In reply to#172653
On Tuesday, February 13, 2018 at 8:27:26 PM UTC-6, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
> > On 2/13/2018 6:30 PM, Ben Bacarisse wrote:
> >> Pete Olcott <Pete@NoEmail.address> writes:
> >>
> >>> On 2/13/2018 7:06 AM, Ben Bacarisse wrote:
> >>>> Pete Olcott <Pete@NoEmail.address> writes:
> >>>> <snip>
> >>>>> ... Definition of Turing Machine Ĥx (state transition sequence)
> >>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy   // NO LOOP
> >>>>> ... Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn   // NO LOOP HERE EITHER
> >>>>
> >>>> These lines say that H^x always halts (on any input).  This is one of
> >>>> the few correct things in this post.  You don't say in which
> >>>> circumstances it goes to qy or qn but, as you say, I can infer that form
> >>>> the context.
> >>>>
> >>>> And it is still not a definition of a TM.  No matter how many times you
> >>>> repeat that phrase, those lines do not define a Turing machine.  They
> >>>> never will.
> >>>
> >>> They completely define enough that an actual debug trace can be performed
> >>> on the state transition sequence from Ĥx.q0 to Ĥx.qx and the steps
> >>> immediately after Ĥx.qx because we know that a halt decider is defined
> >>> to do a debug trace on its input until:
> >>
> >> You don't know what H does so you don't know what H^x does.  All you
> >> know is that if H exists it decides (not PO-decides) halting (not
> >> PO-halting) and therefore it always halts.
> >>
> >>> (1) Halting behavior is detected.
> >>> (2) Non-Halting behavior is detected.
> >>> (3) Erroneous input is detected.
> >>>
> >>> Thus this necessarily applies recursively to
> >>> --- H [Ĥx] [Ĥx2]
> >>> --- Ĥx2 [Ĥx3] [Ĥx4]
> >>> --- Ĥx3 [Ĥx4] [Ĥx5]
> >>
> >> Are you talking about the halting problem, of the PO-problem?  It sounds
> >> like the later.  I'd have to give two answers to every point you make
> >> unless I know what problem you are talking about so I'll wait and see
> >> which you are talking about.
> 
> No answer?  It matters.  If you are not talking about the halting
> problem, we can stop right away.  I have no interest in the PO-halting
> problem.
> 
> >> <snip awaiting to find out what you are talking about>
> >>
> >
> > You know that every halt decider must have two inputs right?
> > Yes or no?
> 
> No.
> 
> > You also know that conventionally another machine is specified
> > that takes one input and copies it and then evaluates halting
> > for this pair as it input pair?
> > Yes or No?
> 
> No.
> 
> > You also know that every TMD requires it own input pair
> > Yes or No?
> 
> No.
> 
> > If you said Yes, Yes, Yes, then you should be able to see
> > that the input to any machine so defined is infinitely recursive.
> >
> > I will keep a single minded focus on this one point with you until
> > you either understand and agree or prove that truth is not your goal.
> 
> Any chance you will answer my question and say what halting problem you
> are talking about?
> 
> -- 
> Ben.

Please justify your answers first.

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


#172745

FromAndy Walker <anw@cuboid.co.uk>
Date2018-02-14 22:55 +0000
Message-ID<p62epk$aaf$1@gioia.aioe.org>
In reply to#172620
On 13/02/18 22:55, Pete Olcott wrote:
> [... W]e know that a halt decider is defined
> to do a debug trace on its input until:
> (1) Halting behavior is detected.
> (2) Non-Halting behavior is detected.
> (3) Erroneous input is detected.

	Wait!  In what world is that the *definition* of a halt decider?
Indeed, it is almost [but not quite] trivial that by such a definition
there can be no such thing.  Specifically, how do you expect a HD to
detect non-halting behaviour?  If you can do so only by a "debug trace",
then almost all such behaviour is going to be undetectable.

> Thus this necessarily applies recursively to
> --- H [Ĥx] [Ĥx2]
> --- Ĥx2 [Ĥx3] [Ĥx4]
> --- Ĥx3 [Ĥx4] [Ĥx5]

	To the extent to which that is true, it demonstrates that your
definition is uninteresting.

	Emulating/tracing a TM-input pair can show that the TM halts
with that input;  it cannot show directly that it does not halt*.  For
that you need more sophisticated arguments [of which there are many].
The essence of the HP discussion is to show that no such argument [or
collection of them] is sufficient in general.
____
   * The nearest to such a direct demonstration is to discover that a
     state of the TM and its tape has been exactly repeated, but that
     discovery already requires a further mechanism than mere tracing.

-- 
Andy Walker,
Nottingham.

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


#172749

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-14 17:22 -0600
Message-ID<N5mdndQp3tItWRnHnZ2dnUU7-X_NnZ2d@giganews.com>
In reply to#172745
On 2/14/2018 4:55 PM, Andy Walker wrote:
> On 13/02/18 22:55, Pete Olcott wrote:
>> [... W]e know that a halt decider is defined
>> to do a debug trace on its input until:
>> (1) Halting behavior is detected.
>> (2) Non-Halting behavior is detected.
>> (3) Erroneous input is detected.
> 
>      Wait!  In what world is that the *definition* of a halt decider?
> Indeed, it is almost [but not quite] trivial that by such a definition
> there can be no such thing.  Specifically, how do you expect a HD to
> detect non-halting behaviour?  

You never heard a a loop that lacks a loop termination condition?
If not you haven't the slightest basis to even begin critiquing my work.

> If you can do so only by a "debug trace",
> then almost all such behaviour is going to be undetectable.
> 
>> Thus this necessarily applies recursively to
>> --- H [Ĥx] [Ĥx2]
>> --- Ĥx2 [Ĥx3] [Ĥx4]
>> --- Ĥx3 [Ĥx4] [Ĥx5]
> 
>      To the extent to which that is true, it demonstrates that your
> definition is uninteresting.
> 

Every conventional HP proof specifies an infinitely recursive
evaluation sequence because every conventional proof operates
on a pair of TMD's and each TMD always requires its own pair
of inputs. I was surprised that it took me more than a dozen
years and 3000 hours to notice this.

>      Emulating/tracing a TM-input pair can show that the TM halts
> with that input;  it cannot show directly that it does not halt*.  For

As soon as it detects a loop that lacks a loop termination condition
it breaks out of the debug trace and transitions to its H.qn decision state.

> that you need more sophisticated arguments [of which there are many].
> The essence of the HP discussion is to show that no such argument [or
> collection of them] is sufficient in general.

No my case is relatively simple every single counter-example to the
claim that a halt decider does not exist is semantically incorrect
thus not a counter-example at all.

> ____
>    * The nearest to such a direct demonstration is to discover that a
>      state of the TM and its tape has been exactly repeated, but that
>      discovery already requires a further mechanism than mere tracing.
> 

The debug trace is not a mindless emulation. At every step of the trace
it is looking for a loop that lacks a loop termination condition. As
soon as it finds one it breaks out of the (David Hilbert formal
proof from a pair of input finite strings to a pair of final states
within the language of Turing Machine Descriptions) debug trace.

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172751

Fromgrahamcooper7@gmail.com
Date2018-02-14 16:20 -0800
Message-ID<a2259cf5-c80e-461c-a2aa-7fb18b35b836@googlegroups.com>
In reply to#172749
On Thursday, February 15, 2018 at 9:22:31 AM UTC+10, Pete Olcott wrote:
> On 2/14/2018 4:55 PM, Andy Walker wrote:
> > On 13/02/18 22:55, Pete Olcott wrote:
> >> [... W]e know that a halt decider is defined
> >> to do a debug trace on its input until:
> >> (1) Halting behavior is detected.
> >> (2) Non-Halting behavior is detected.
> >> (3) Erroneous input is detected.
> > 
> >      Wait!  In what world is that the *definition* of a halt decider?
> > Indeed, it is almost [but not quite] trivial that by such a definition
> > there can be no such thing.  Specifically, how do you expect a HD to
> > detect non-halting behaviour?  
> 
> You never heard a a loop that lacks a loop termination condition?
> If not you haven't the slightest basis to even begin critiquing my work.
> 
> > If you can do so only by a "debug trace",
> > then almost all such behaviour is going to be undetectable.
> > 
> >> Thus this necessarily applies recursively to
> >> --- H [Ĥx] [Ĥx2]
> >> --- Ĥx2 [Ĥx3] [Ĥx4]
> >> --- Ĥx3 [Ĥx4] [Ĥx5]
> > 
> >      To the extent to which that is true, it demonstrates that your
> > definition is uninteresting.
> > 
> 
> Every conventional HP proof specifies an infinitely recursive
> evaluation sequence because every conventional proof operates
> on a pair of TMD's and each TMD always requires its own pair
> of inputs. I was surprised that it took me more than a dozen
> years and 3000 hours to notice this.
> 
> >      Emulating/tracing a TM-input pair can show that the TM halts
> > with that input;  it cannot show directly that it does not halt*.  For
> 
> As soon as it detects a loop that lacks a loop termination condition
> it breaks out of the debug trace and transitions to its H.qn decision state.
> 
> > that you need more sophisticated arguments [of which there are many].
> > The essence of the HP discussion is to show that no such argument [or
> > collection of them] is sufficient in general.
> 
> No my case is relatively simple every single counter-example to the
> claim that a halt decider does not exist is semantically incorrect
> thus not a counter-example at all.
> 
> > ____
> >    * The nearest to such a direct demonstration is to discover that a
> >      state of the TM and its tape has been exactly repeated, but that
> >      discovery already requires a further mechanism than mere tracing.


There are 5 state TM's that demonstrate Erratic Behaviour
the tape value slowly increases 
and it takes 1000s of state transitions
(in general moving to the far left of the tape then far right & repeating)

to see the CHANGING pattern!





> > 
> 
> The debug trace is not a mindless emulation. At every step of the trace
> it is looking for a loop that lacks a loop termination condition. As


WHAT LOOP?   it has to input MEGABYTES of (random) SPAGHETTI CODE

Imagine 1000s of functions each calling 100s of functions each



> soon as it finds one it breaks out of the (David Hilbert formal
> proof from a pair of input finite strings to a pair of final states
> within the language of Turing Machine Descriptions) debug trace.
> 
> -- 
> *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172752

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-14 16:29 -0800
Message-ID<b2b6001f-1e33-4fb1-92d8-f88d4fdf6e75@googlegroups.com>
In reply to#172751
On Wednesday, February 14, 2018 at 6:20:10 PM UTC-6, graham...@gmail.com wrote:
> On Thursday, February 15, 2018 at 9:22:31 AM UTC+10, Pete Olcott wrote:
> > On 2/14/2018 4:55 PM, Andy Walker wrote:
> > > On 13/02/18 22:55, Pete Olcott wrote:
> > >> [... W]e know that a halt decider is defined
> > >> to do a debug trace on its input until:
> > >> (1) Halting behavior is detected.
> > >> (2) Non-Halting behavior is detected.
> > >> (3) Erroneous input is detected.
> > > 
> > >      Wait!  In what world is that the *definition* of a halt decider?
> > > Indeed, it is almost [but not quite] trivial that by such a definition
> > > there can be no such thing.  Specifically, how do you expect a HD to
> > > detect non-halting behaviour?  
> > 
> > You never heard a a loop that lacks a loop termination condition?
> > If not you haven't the slightest basis to even begin critiquing my work.
> > 
> > > If you can do so only by a "debug trace",
> > > then almost all such behaviour is going to be undetectable.
> > > 
> > >> Thus this necessarily applies recursively to
> > >> --- H [Ĥx] [Ĥx2]
> > >> --- Ĥx2 [Ĥx3] [Ĥx4]
> > >> --- Ĥx3 [Ĥx4] [Ĥx5]
> > > 
> > >      To the extent to which that is true, it demonstrates that your
> > > definition is uninteresting.
> > > 
> > 
> > Every conventional HP proof specifies an infinitely recursive
> > evaluation sequence because every conventional proof operates
> > on a pair of TMD's and each TMD always requires its own pair
> > of inputs. I was surprised that it took me more than a dozen
> > years and 3000 hours to notice this.
> > 
> > >      Emulating/tracing a TM-input pair can show that the TM halts
> > > with that input;  it cannot show directly that it does not halt*.  For
> > 
> > As soon as it detects a loop that lacks a loop termination condition
> > it breaks out of the debug trace and transitions to its H.qn decision state.
> > 
> > > that you need more sophisticated arguments [of which there are many].
> > > The essence of the HP discussion is to show that no such argument [or
> > > collection of them] is sufficient in general.
> > 
> > No my case is relatively simple every single counter-example to the
> > claim that a halt decider does not exist is semantically incorrect
> > thus not a counter-example at all.
> > 
> > > ____
> > >    * The nearest to such a direct demonstration is to discover that a
> > >      state of the TM and its tape has been exactly repeated, but that
> > >      discovery already requires a further mechanism than mere tracing.
> 
> 
> There are 5 state TM's that demonstrate Erratic Behaviour
> the tape value slowly increases 
> and it takes 1000s of state transitions
> (in general moving to the far left of the tape then far right & repeating)
> 
> to see the CHANGING pattern!
> 
> 
> 
> 
> 
> > > 
> > 
> > The debug trace is not a mindless emulation. At every step of the trace
> > it is looking for a loop that lacks a loop termination condition. As
> 
> 
> WHAT LOOP?   it has to input MEGABYTES of (random) SPAGHETTI CODE
> 
> Imagine 1000s of functions each calling 100s of functions each
> 

The concept of the proof is to show that a halt decider is impossible.
The concept of the proof is NOT to show that a halt decider is very difficult.

I have correctly refuted the whole class of HP proofs. 

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


#172757

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-15 02:19 +0000
Message-ID<87bmgr9epp.fsf@bsb.me.uk>
In reply to#172752
peteolcott <peterolcott2@gmail.com> writes:
<snip>
> I have correctly refuted the whole class of HP proofs. 

Utter tosh.  You don't even accept what the theorem is about, and that
is simply a matter of fact.  Your PO-halting problem (which permits an
as yet rather vague set of strings to be rejected) is irrelevant.

(There is a deep irony in all this: the set of strings you want to
reject as "semantically incorrect" is probably empty since it is almost
certainly only those hypothetical strings you've seen in the one proof
you've read and non of them actually exists.)

I wonder how the JACM paper is coming along.  I would love to be one of
the referees on that one.

-- 
Ben.

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


#172759

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-14 21:00 -0600
Message-ID<GPCdnctrt8pbahnHnZ2dnUU7-THNnZ2d@giganews.com>
In reply to#172757
On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
> peteolcott <peterolcott2@gmail.com> writes:
> <snip>
>> I have correctly refuted the whole class of HP proofs.
> 
> Utter tosh.  You don't even accept what the theorem is about, and that
> is simply a matter of fact.  Your PO-halting problem (which permits an
> as yet rather vague set of strings to be rejected) is irrelevant.
> 
> (There is a deep irony in all this: the set of strings you want to
> reject as "semantically incorrect" is probably empty since it is almost
> certainly only those hypothetical strings you've seen in the one proof
> you've read and non of them actually exists.)
> 

The Liar Paradox is the simplest possible example that I can provide
that shows a syntactically WFF can indeed be semantically incorrect.

“This sentence is not true”.  // is not true
Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics

Since you are rejecting the concept of a semantically incorrect WFF
then you would be able to provide a formal proof showing exactly how
and why the formalized Liar Paradox is exactly one of True or False.

or will you be honest and acknowledge that you don't know how to do this?

It is OK if you still don't see how this applies to the Halting Problem,
after all you are not a math guy. You still can't quite see the HP as
a math problem.

If you could the the HP as a math problem and you can see that a formal
proof from the Liar Paradox to True or False is impossible then it is
really not all that much of a stretch of the imagination to understand
the the HP could be a semantically incorrect WFF.

Copyright 2018 Pete Olcott

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172769

Fromgrahamcooper7@gmail.com
Date2018-02-14 22:57 -0800
Message-ID<eaa3c02c-813d-4088-b98f-7738cce6e4f1@googlegroups.com>
In reply to#172759
On Thursday, February 15, 2018 at 1:00:28 PM UTC+10, Pete Olcott wrote:
> On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
> > peteolcott <peterolcott2@gmail.com> writes:
> > <snip>
> >> I have correctly refuted the whole class of HP proofs.
> > 
> > Utter tosh.  You don't even accept what the theorem is about, and that
> > is simply a matter of fact.  Your PO-halting problem (which permits an
> > as yet rather vague set of strings to be rejected) is irrelevant.
> > 
> > (There is a deep irony in all this: the set of strings you want to
> > reject as "semantically incorrect" is probably empty since it is almost
> > certainly only those hypothetical strings you've seen in the one proof
> > you've read and non of them actually exists.)
> > 
> 
> The Liar Paradox is the simplest possible example that I can provide
> that shows a syntactically WFF can indeed be semantically incorrect.
> 
> “This sentence is not true”.  // is not true
> Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics
> 
> Since you are rejecting the concept of a semantically incorrect WFF
> then you would be able to provide a formal proof showing exactly how
> and why the formalized Liar Paradox is exactly one of True or False.



Now now Peter... your forgeting SCI.LOGIC has been brainwashed....


there is no word for TRUE !!



they just cant be bothered doing ANY logic for 2018-1931 YEARS!




SHOW a LoGIcIeN a formula with TRUE and he'll tell you about the True Platonic Universe full of PuPPY DoGS and RAINBoWS!!

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


#172785

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-15 09:06 -0600
Message-ID<2JSdnWtuRs16PBjHnZ2dnUU7-bGdnZ2d@giganews.com>
In reply to#172769
On 2/15/2018 12:57 AM, grahamcooper7@gmail.com wrote:
> On Thursday, February 15, 2018 at 1:00:28 PM UTC+10, Pete Olcott wrote:
>> On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
>>> peteolcott <peterolcott2@gmail.com> writes:
>>> <snip>
>>>> I have correctly refuted the whole class of HP proofs.
>>>
>>> Utter tosh.  You don't even accept what the theorem is about, and that
>>> is simply a matter of fact.  Your PO-halting problem (which permits an
>>> as yet rather vague set of strings to be rejected) is irrelevant.
>>>
>>> (There is a deep irony in all this: the set of strings you want to
>>> reject as "semantically incorrect" is probably empty since it is almost
>>> certainly only those hypothetical strings you've seen in the one proof
>>> you've read and non of them actually exists.)
>>>
>>
>> The Liar Paradox is the simplest possible example that I can provide
>> that shows a syntactically WFF can indeed be semantically incorrect.
>>
>> “This sentence is not true”.  // is not true
>> Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics
>>
>> Since you are rejecting the concept of a semantically incorrect WFF
>> then you would be able to provide a formal proof showing exactly how
>> and why the formalized Liar Paradox is exactly one of True or False.
> 
> Now now Peter... your forgeting SCI.LOGIC has been brainwashed....
> there is no word for TRUE !!
> they just cant be bothered doing ANY logic for 2018-1931 YEARS!
> 
> SHOW a LoGIcIeN a formula with TRUE and he'll tell you about the True Platonic Universe full of PuPPY DoGS and RAINBoWS!!
> 
> 

Yet when you anchor your statements about True(X) in well-founded
sources the ones here that are not Trolls tend to respond appropriately.

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

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


#172851

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-15 21:38 +0000
Message-ID<87y3ju6ihp.fsf@bsb.me.uk>
In reply to#172759
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
>> peteolcott <peterolcott2@gmail.com> writes:
>> <snip>
>>> I have correctly refuted the whole class of HP proofs.
>>
>> Utter tosh.  You don't even accept what the theorem is about, and that
>> is simply a matter of fact.  Your PO-halting problem (which permits an
>> as yet rather vague set of strings to be rejected) is irrelevant.
>>
>> (There is a deep irony in all this: the set of strings you want to
>> reject as "semantically incorrect" is probably empty since it is almost
>> certainly only those hypothetical strings you've seen in the one proof
>> you've read and non of them actually exists.)
>
> The Liar Paradox is the simplest possible example that I can provide
> that shows a syntactically WFF can indeed be semantically incorrect.

It's not an example of a halting problem.  Unlike this paradox, every
halting problem instance has a correct yes/no answer.  You will never
understand any of your other errors until you accept this basic fact.

There are no "incorrect" halting instances.

> “This sentence is not true”.  // is not true
> Liar-Paradox ≡ ~True(Liar-Paradox) // HOL with self-reference semantics
>
> Since you are rejecting the concept of a semantically incorrect WFF
> then you would be able to provide a formal proof showing exactly how
> and why the formalized Liar Paradox is exactly one of True or False.

I know you'd like to talk about something else now, but I won't let you
off the hook about halting.  Clearly one can write sentences with no
correct answer, but you can't do that with halting instances, so the
analogy serves only as a distraction.

The two facts that have finally driven you to stop talking about halting
are these:

First, the problem is not as you have tried to re-define it.  It is the
problem of deciding which finite strings encode an TM/input pair where
the encoded TM would halt when run with the encoded input.  Every string
that does not encode such a pair must be rejected.  Every string that
does must be accepted or rejected based only on what the encoded TM
would do.

Second, every TM, when run with some finite string halts or does not
halt.  No other possibility exists. (I find it strange that I even have
to say this, but you have refused to accept it in the past -- I don't
know where you stand on the point right now).

Presumably you still reject one or other (or both) of these.  Until you
accept them both you should stick to waffling about WFFs and the liar
paradox and keep well away from the halting theorem.  Nothing you say
about halting will make sense until you agree on these trivial matters
of fact.

-- 
Ben.

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


#172858

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-15 17:27 -0600
Message-ID<2qydnRtyvbDXihvHnZ2dnUU7-f3NnZ2d@giganews.com>
In reply to#172851
On 2/15/2018 3:38 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
>>> peteolcott <peterolcott2@gmail.com> writes:
>>> <snip>
>>>> I have correctly refuted the whole class of HP proofs.
>>>
>>> Utter tosh.  You don't even accept what the theorem is about, and that
>>> is simply a matter of fact.  Your PO-halting problem (which permits an
>>> as yet rather vague set of strings to be rejected) is irrelevant.
>>>
>>> (There is a deep irony in all this: the set of strings you want to
>>> reject as "semantically incorrect" is probably empty since it is almost
>>> certainly only those hypothetical strings you've seen in the one proof
>>> you've read and non of them actually exists.)
>>
>> The Liar Paradox is the simplest possible example that I can provide
>> that shows a syntactically WFF can indeed be semantically incorrect.
> 
> It's not an example of a halting problem.  Unlike this paradox, every
> halting problem instance has a correct yes/no answer.  You will never
> understand any of your other errors until you accept this basic fact.

This error occurs in numerous decision problems:

There exists syntactically correct WFF X of language L such that a
mathematical proof from X to the semantic values of True and False
does not exist because of a semantic error in X.

The Liar Paradox, Halting Problem and Incompleteness Theorem are three
different instances of this exact same error. I have known this for
two decades.

"This sentence is not true" is clearly not true yet no mathematical
proof from the above finite string to the semantic values of True
and False exists because the sentence itself is semantically incorrect.

"This sentence is not provable" is clearly not provable yet no mathematical
proof from the above finite string to the semantic values of True and False
exists because the sentence itself is semantically incorrect.

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/

Definition of Turing Machine Ĥx
Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy
Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn

Ĥx [Ĥx][Ĥx]

When we assume that Ĥx was constructed on the basis of a correct halt
decider H then the above expression does represent a TMD that would halt
on its input yet no mathematical proof from that expression to the
semantic values of True( Halts([Ĥx][Ĥx]) ) or False( Halts([Ĥx][Ĥx]) )
exists because the expression is semantically incorrect.

All three of these cases are shown to be semantically incorrect when they
evaluated as David Hilbert Formalisms, in that no mathematical proof
can be constructed from their finite strings to the semantic values
of True or False.

When-so-ever there does not exist a formal proof in language L from any
closed WFF X of L to the Boolean values of True or False, X is semantically
incorrect in L.

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


#172859

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-15 17:34 -0600
Message-ID<9MOdnVJq-d6BhBvHnZ2dnUU7-U2dnZ2d@giganews.com>
In reply to#172858
On 2/15/2018 5:27 PM, Pete Olcott wrote:
> On 2/15/2018 3:38 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 2/14/2018 8:19 PM, Ben Bacarisse wrote:
>>>> peteolcott <peterolcott2@gmail.com> writes:
>>>> <snip>
>>>>> I have correctly refuted the whole class of HP proofs.
>>>>
>>>> Utter tosh.  You don't even accept what the theorem is about, and that
>>>> is simply a matter of fact.  Your PO-halting problem (which permits an
>>>> as yet rather vague set of strings to be rejected) is irrelevant.
>>>>
>>>> (There is a deep irony in all this: the set of strings you want to
>>>> reject as "semantically incorrect" is probably empty since it is almost
>>>> certainly only those hypothetical strings you've seen in the one proof
>>>> you've read and non of them actually exists.)
>>>
>>> The Liar Paradox is the simplest possible example that I can provide
>>> that shows a syntactically WFF can indeed be semantically incorrect.
>>
>> It's not an example of a halting problem.  Unlike this paradox, every
>> halting problem instance has a correct yes/no answer.  You will never
>> understand any of your other errors until you accept this basic fact.
> 
> This error occurs in numerous decision problems:
> 
> There exists syntactically correct WFF X of language L such that a
> mathematical proof from X to the semantic values of True and False
> does not exist because of a semantic error in X.
> 
> The Liar Paradox, Halting Problem and Incompleteness Theorem are three
> different instances of this exact same error. I have known this for
> two decades.
> 
> "This sentence is not true" is clearly not true yet no mathematical
> proof from the above finite string to the semantic values of True
> and False exists because the sentence itself is semantically incorrect.
> 
> "This sentence is not provable" is clearly not provable yet no mathematical
> proof from the above finite string to the semantic values of True and False
> exists because the sentence itself is semantically incorrect.
> 
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> 
> Definition of Turing Machine Ĥx
> Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy
> Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn
> 
> Ĥx [Ĥx][Ĥx]
> 
> When we assume that Ĥx was constructed on the basis of a correct halt
> decider H then the above expression does represent a TMD that would halt
> on its input yet no mathematical proof from that expression to the
> semantic values of True( Halts([Ĥx][Ĥx]) ) or False( Halts([Ĥx][Ĥx]) )
> exists because the expression is semantically incorrect.
> 
> All three of these cases are shown to be semantically incorrect when they
> evaluated as David Hilbert Formalisms, in that no mathematical proof
> can be constructed from their finite strings to the semantic values
> of True or False.
> 
> When-so-ever there does not exist a formal proof in language L from any
> closed WFF X of L to the Boolean values of True or False, X is semantically
> incorrect in L.

Copyright 2018 Pete Olcott

-- 
*∀L ∈ Formal_Systems
∀X
True(L, X) ↔ ∃Γ ⊆ Axioms(L) Provable(Γ, X) *

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


Page 1 of 3  [1] 2 3  Next page →

Back to top | Article view | sci.logic


csiph-web