Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #172283 > unrolled thread
| Started by | George Greene <greeneg@email.unc.edu> |
|---|---|
| First post | 2018-02-09 11:34 -0800 |
| Last post | 2018-02-12 21:36 -0800 |
| Articles | 15 — 5 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.
Re: Necessary sequence of halt decider's inference chain George Greene <greeneg@email.unc.edu> - 2018-02-09 11:34 -0800
Re: Necessary sequence of halt decider's inference chain peteolcott <peterolcott2@gmail.com> - 2018-02-09 13:15 -0800
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-09 21:40 +0000
Re: Necessary sequence of halt decider's inference chain Pete Olcott <Pete@NoEmail.address> - 2018-02-09 23:48 -0600
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-10 12:57 +0000
Re: Necessary sequence of halt decider's inference chain Pete Olcott <Pete@NoEmail.address> - 2018-02-10 09:52 -0600
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-10 17:06 +0000
Re: Necessary sequence of halt decider's inference chain Pete Olcott <Pete@NoEmail.address> - 2018-02-11 00:36 -0600
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-11 16:13 +0000
Re: Necessary sequence of halt decider's inference chain Pete Olcott <Pete@NoEmail.address> - 2018-02-12 20:34 -0600
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 04:18 +0000
Re: Necessary sequence of halt decider's inference chain Pete Olcott <Pete@NoEmail.address> - 2018-02-13 10:03 -0600
Re: Necessary sequence of halt decider's inference chain Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 17:13 +0000
Re: Necessary sequence of halt decider's inference chain grahamcooper7@gmail.com - 2018-02-13 16:59 -0800
Re: Necessary sequence of halt decider's inference chain grahamcooper7@gmail.com - 2018-02-12 21:36 -0800
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-02-09 11:34 -0800 |
| Subject | Re: Necessary sequence of halt decider's inference chain |
| Message-ID | <a6efdffb-6e41-476a-945d-f83194cb4a41@googlegroups.com> |
On Friday, February 9, 2018 at 10:34:11 AM UTC-5, Pete Olcott wrote: > http://www.liarparadox.org/H_evaluates_S.pdf > > > > This > is the text from the PDF. It is much more easily understood > > when > the state transition diagrams can be seen. Peter, YOU DO NOT understand SHIT here! STOP TRYING to EXPLAIN! WE KNOW what is happening in these diagrams! YOU DO NOT!! > > > > Understanding > this > is a necessary prerequisite to understanding > > how H Ĥx Ĥx would > be evaluated. Ĥx is constructed using H as its basis. Of course it is, but THE TREATMENT SAYS *NOTHING*WHATSOEVER* about H, other than that it is intended TO ALWAYS halt!! THAT HAS some implications! > > > > > Definition > of Turing Machine Ĥx > > > q0 > Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy > > > q0 > Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn THAT, WHATEVER else it may be, IS NOT the definition of Turing Machine Ĥx. Wn is a descriptive definition of TM Ĥx, as a string in a programming language. Other descriptions are possible. The two things above are both what YOU would call "execution traces" of the call Ĥx(Wm), or Ĥx([Ĥx]) -- Wm =df= [Ĥx], although Linz, to his discredit, is using Wm instead of [Ĥx]. Another thing about THE TWO execution traces you have presented above is that they are MUTUALLY EXCLUSIVE -- they are NOT BOTH happening. On any given H, either ONE OR THE OTHER of these must happen, unless H loops and never gets there -- which in theory it shouldn't since it WAS DEFINED as at least TRYING to ALWAYS Halt.
[toc] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-02-09 13:15 -0800 |
| Message-ID | <0a8ef82a-f27d-4632-8f1c-45cd2b472392@googlegroups.com> |
| In reply to | #172283 |
On Friday, February 9, 2018 at 1:34:39 PM UTC-6, George Greene wrote: > On Friday, February 9, 2018 at 10:34:11 AM UTC-5, Pete Olcott wrote: > > http://www.liarparadox.org/H_evaluates_S.pdf > > > > > > > > This > > is the text from the PDF. It is much more easily understood > > > > when > > the state transition diagrams can be seen. > > Peter, YOU DO NOT understand SHIT here! > STOP TRYING to EXPLAIN! WE KNOW what is happening in these diagrams! > YOU DO NOT!! > > > > > > > > > Understanding > > this > > is a necessary prerequisite to understanding > > > > how H Ĥx Ĥx would > > be evaluated. Ĥx is constructed using H as its basis. > > Of course it is, but THE TREATMENT SAYS *NOTHING*WHATSOEVER* about H, > other than that it is intended TO ALWAYS halt!! THAT HAS some implications! > > > > > > > > > > > Definition > > of Turing Machine Ĥx > > > > > > q0 > > Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy > > > > > > q0 > > Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn > > THAT, WHATEVER else it may be, IS NOT the definition of Turing Machine Ĥx. > Wn is a descriptive definition of TM Ĥx, as a string in a programming > language. Other descriptions are possible. The two things above are both > what YOU would call "execution traces" of the call Ĥx(Wm), or Ĥx([Ĥx]) -- > Wm =df= [Ĥx], although Linz, to his discredit, is using Wm instead of [Ĥx]. > > Another thing about THE TWO execution traces you have presented above > is that they are MUTUALLY EXCLUSIVE -- they are NOT BOTH happening. > On any given H, either ONE OR THE OTHER of these must happen, unless H > loops and never gets there -- which in theory it shouldn't since it WAS > DEFINED as at least TRYING to ALWAYS Halt. I provided this concrete example to correctly refute Ben's claim that there is no specific sequence of syntactic logical consequence required when evaluating a pair of David Hilbert finite strings in the language or Turing Machine descriptions. Heh Ben you were wrong! The only way to prove that you are not wrong (impossible thus most likely dodged) is to show any other way that any halt decider could decide [S] "ENN" without tracing through the entire state transition sequence of [S] "ENN". Of course as we all know this must be a hypothetical trace and not an actual simulation.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-09 21:40 +0000 |
| Message-ID | <87fu69c058.fsf@bsb.me.uk> |
| In reply to | #172290 |
peteolcott <peterolcott2@gmail.com> writes: <snip> > I provided this concrete example to correctly refute Ben's claim > that there is no specific sequence of syntactic logical consequence > required when evaluating a pair of David Hilbert finite strings in > the language or Turing Machine descriptions. I could never make that claim because it's just a word salad to me. A more honest way to contest someone's claims is by quoting their words. If you think I'm wrong, quote me and explain why. Don't just make stuff up. (At the very least, if you quote what I said that makes you think I made the above claim, I might stand a chance of finding out what that apparently random assemblage of words means. I've long since given up asking you to define your terms.) -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-09 23:48 -0600 |
| Message-ID | <2vWdnW0EN54oGuPHnZ2dnUU7-RPNnZ2d@giganews.com> |
| In reply to | #172292 |
On 2/9/2018 3:40 PM, Ben Bacarisse wrote: > peteolcott <peterolcott2@gmail.com> writes: > <snip> >> I provided this concrete example to correctly refute Ben's claim >> that there is no specific sequence of syntactic logical consequence >> required when evaluating a pair of David Hilbert finite strings in >> the language or Turing Machine descriptions. > > I could never make that claim because it's just a word salad to me. You have to actually look at the words of the original post BEFORE providing your rebuttal. > A > more honest way to contest someone's claims is by quoting their words. This is the whole thing about the sequ3ence that H must follow to evaluate the halting behavior of H^. > If you think I'm wrong, quote me and explain why. Here is why: http://www.liarparadox.org/H_evaluates_S.pdf > Don't just make stuff > up. (At the very least, if you quote what I said that makes you think I > made the above claim, I might stand a chance of finding out what that > apparently random assemblage of words means. I've long since given up > asking you to define your terms.) > This is the whole thing about the necessary sequence that H must follow to evaluate the halting behavior of H^. You said that it should be free to do anything. I proved by a concrete example that no halt decider is free at all. It is strictly bound by the syntactic logical consequence defined by the input strings within the formal language of Turing machine Descriptions. The concrete example challenges you to come up with a counter-example such that H decides [S] "ENN" without following every state transition that [S] would make. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-10 12:57 +0000 |
| Message-ID | <87sha9ngsu.fsf@bsb.me.uk> |
| In reply to | #172314 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/9/2018 3:40 PM, Ben Bacarisse wrote: >> peteolcott <peterolcott2@gmail.com> writes: >> <snip> >>> I provided this concrete example to correctly refute Ben's claim >>> that there is no specific sequence of syntactic logical consequence >>> required when evaluating a pair of David Hilbert finite strings in >>> the language or Turing Machine descriptions. >> >> I could never make that claim because it's just a word salad to me. > > You have to actually look at the words of the original post BEFORE > providing your rebuttal. Eh? Quote where I said what you claim or shut up. >> A >> more honest way to contest someone's claims is by quoting their words. > > This is the whole thing about the sequ3ence that H must follow to > evaluate the halting behavior of H^. I am accusing you of misrepresenting what I said. Most people consider this morally wrong as well as a terrible way to conduct a discussion. >> If you think I'm wrong, quote me and explain why. > Here is why: http://www.liarparadox.org/H_evaluates_S.pdf Quote me. Posting links to more junk does not excuse your dishonesty. >> Don't just make stuff >> up. (At the very least, if you quote what I said that makes you think I >> made the above claim, I might stand a chance of finding out what that >> apparently random assemblage of words means. I've long since given up >> asking you to define your terms.) >> > > This is the whole thing about the necessary sequence that H must follow > to evaluate the halting behavior of H^. You said that it should be > free to do anything. ... provided it behaves as specified. You ignore that, probably because you don't know what the notation means, though you copy it out enough times. > I proved by a concrete example that no halt decider is free at all. It > is strictly bound by the syntactic logical consequence defined by the > input strings within the formal language of Turing machine > Descriptions. Nope. > The concrete example challenges you to come up with a counter-example > such that H decides [S] "ENN" without following every state transition > that [S] would make. There is no machine in the class denoted by H. Learn what a counter example is before asking for one. Normally, I'd give you an analogy for this absurd request, but you are not engaging with any technical remarks anymore so I don't see the point. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-10 09:52 -0600 |
| Message-ID | <htGdnTKFV8y4iOLHnZ2dnUU7-bHNnZ2d@giganews.com> |
| In reply to | #172323 |
On 2/10/2018 6:57 AM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 2/9/2018 3:40 PM, Ben Bacarisse wrote: >>> peteolcott <peterolcott2@gmail.com> writes: >>> <snip> >>>> I provided this concrete example to correctly refute Ben's claim >>>> that there is no specific sequence of syntactic logical consequence >>>> required when evaluating a pair of David Hilbert finite strings in >>>> the language or Turing Machine descriptions. >>> >>> I could never make that claim because it's just a word salad to me. >> >> You have to actually look at the words of the original post BEFORE >> providing your rebuttal. > > Eh? Quote where I said what you claim or shut up. > >>> A >>> more honest way to contest someone's claims is by quoting their words. >> >> This is the whole thing about the sequ3ence that H must follow to >> evaluate the halting behavior of H^. > > I am accusing you of misrepresenting what I said. Most people > consider this morally wrong as well as a terrible way to conduct a > discussion. > >>> If you think I'm wrong, quote me and explain why. >> Here is why: http://www.liarparadox.org/H_evaluates_S.pdf > > Quote me. Posting links to more junk does not excuse your dishonesty. > >>> Don't just make stuff >>> up. (At the very least, if you quote what I said that makes you think I >>> made the above claim, I might stand a chance of finding out what that >>> apparently random assemblage of words means. I've long since given up >>> asking you to define your terms.) >>> >> >> This is the whole thing about the necessary sequence that H must follow >> to evaluate the halting behavior of H^. You said that it should be >> free to do anything. > > .... provided it behaves as specified. You ignore that, probably because > you don't know what the notation means, though you copy it out enough > times. > >> I proved by a concrete example that no halt decider is free at all. It >> is strictly bound by the syntactic logical consequence defined by the >> input strings within the formal language of Turing machine >> Descriptions. > > Nope. > >> The concrete example challenges you to come up with a counter-example >> such that H decides [S] "ENN" without following every state transition >> that [S] would make. > > There is no machine in the class denoted by H. Learn what a counter > example is before asking for one. Normally, I'd give you an analogy for > this absurd request, but you are not engaging with any technical remarks > anymore so I don't see the point. > It is always the case that every halt decider must trace the precise sequence of state transitions of its input TMD up to the point where this TMD halts or demonstrates non halting behavior. A halt decider performs a mathematical proof of syntactic logical consequence from its input strings to its final halt decision states. It cannot skip any steps along the way. In the case of halt deciders evaluating finite strings defined within the language or Turing Machine Descriptions this chain of inference must necessarily involve every single state transition of the TMD until this TMD halts or demonstrates non-halting behavior. You have disagreed with this and now H [S] "ENN"proves that you have always been wrong about this. I am not talking about simulation of the TMD, I have disavowed this many times. An execution trace is like a step-by-step debug trace. It can break out of the "debugger" at any time. It does break out of the debugger as soon as it detects halting or non-halting behavior, but it cannot break out before this. Definition of Turing Machine H (state transition sequence) H.q0 Wm W ⊢* H.qy H.q0 Wm W ⊢* H.qn 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] After thousands of hours of very careful study I can now finally see that H would transition to its state H.qn indicating that [Ĥx] is an incorrect Turing Machine Description. It was the 3000 hours that I spent working on the Liar Paradox formulating a whole new branch of mathematics in the process that lead me to this key insight. Since I have explained this to you it should only take paying very close attention to what I am saying to confirm that what I say is necessarily correct. At H.qx [Ĥx] [Ĥx2] H would be required to trace the state transitions of [Ĥx] until [Ĥx] reaches [Ĥx].qx which would require [Ĥx] to trace the state transitions of [Ĥx2] until [Ĥx2] reaches [Ĥx2].qx At this point H decides** that [Ĥx] is not a correct TMD thus transitions to its own state of H.qn. ** detects the pathological self-reference(olcott 2004) of its input. Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-10 17:06 +0000 |
| Message-ID | <87mv0gn593.fsf@bsb.me.uk> |
| In reply to | #172341 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/10/2018 6:57 AM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: >> >>> On 2/9/2018 3:40 PM, Ben Bacarisse wrote: >>>> peteolcott <peterolcott2@gmail.com> writes: >>>> <snip> >>>>> I provided this concrete example to correctly refute Ben's claim >>>>> that there is no specific sequence of syntactic logical consequence >>>>> required when evaluating a pair of David Hilbert finite strings in >>>>> the language or Turing Machine descriptions. >>>> >>>> I could never make that claim because it's just a word salad to me. >>> >>> You have to actually look at the words of the original post BEFORE >>> providing your rebuttal. >> >> Eh? Quote where I said what you claim or shut up. >> >>>> A >>>> more honest way to contest someone's claims is by quoting their words. >>> >>> This is the whole thing about the sequ3ence that H must follow to >>> evaluate the halting behavior of H^. >> >> I am accusing you of misrepresenting what I said. Most people >> consider this morally wrong as well as a terrible way to conduct a >> discussion. >> >>>> If you think I'm wrong, quote me and explain why. >>> Here is why: http://www.liarparadox.org/H_evaluates_S.pdf >> >> Quote me. Posting links to more junk does not excuse your dishonesty. >> >>>> Don't just make stuff >>>> up. (At the very least, if you quote what I said that makes you think I >>>> made the above claim, I might stand a chance of finding out what that >>>> apparently random assemblage of words means. I've long since given up >>>> asking you to define your terms.) >>>> >>> >>> This is the whole thing about the necessary sequence that H must follow >>> to evaluate the halting behavior of H^. You said that it should be >>> free to do anything. >> >> .... provided it behaves as specified. You ignore that, probably because >> you don't know what the notation means, though you copy it out enough >> times. >> >>> I proved by a concrete example that no halt decider is free at all. It >>> is strictly bound by the syntactic logical consequence defined by the >>> input strings within the formal language of Turing machine >>> Descriptions. >> >> Nope. >> >>> The concrete example challenges you to come up with a counter-example >>> such that H decides [S] "ENN" without following every state transition >>> that [S] would make. >> >> There is no machine in the class denoted by H. Learn what a counter >> example is before asking for one. Normally, I'd give you an analogy for >> this absurd request, but you are not engaging with any technical remarks >> anymore so I don't see the point. >> > > It is always the case that every halt decider must trace the precise > sequence of state transitions of its input TMD up to the point where > this TMD halts or demonstrates non halting behavior. Every halt decider must behave /as if/ it can trace the precise sequence of state transitions of its input TMD up to the point where this TMD halts or demonstrates non halting behaviour. Any machine that actually does this will not be a halt decider. You used to talk about evaluating and tracing and even (once or twice) about universal TMs so this distinction is important. You need to be clear that "tracing" is just a metaphor. I have invented a clever encoding for TMs and inputs as binary sequences (zeros and ones) with the useful property the if you treat the sequence as a number and factor it, those numbers with an odd number of prime factors always represent halting computations and those with an even number of primes factor always represent non-halting computations. My halt decider therefore just does a little basic arithmetic. Is it "tracing the precise sequence of state transitions of its input TMD up to the point where this TMD halts or demonstrates non halting behaviour"? > A halt decider performs a mathematical proof of syntactic logical > consequence from its input strings to its final halt decision states. Yes. We call that deciding correctly. > It cannot skip any steps along the way. You have no idea what steps it takes to do the job, but yes, it must do them all, obviously. > In the case of halt deciders > evaluating finite strings defined within the language or Turing Machine > Descriptions this chain of inference must necessarily involve every > single state transition of the TMD until this TMD halts or demonstrates > non-halting behavior. But it must do this is a finite number of steps, agreed? > You have disagreed with this and now H [S] "ENN"proves that you have > always been wrong about this. I am not talking about simulation of the > TMD, I have disavowed this many times. > > An execution trace is like a step-by-step debug trace. It can break out of > the "debugger" at any time. It does break out of the debugger as soon as it > detects halting or non-halting behavior, but it cannot break out before this. > > Definition of Turing Machine H (state transition sequence) > H.q0 Wm W ⊢* H.qy > H.q0 Wm W ⊢* H.qn No. Stop using this notation until you have learned it. > 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 No. Stop using this notation until you have learned it. > H [Ĥx] [Ĥx] > > After thousands of hours of very careful study I can now finally > see that H would transition to its state H.qn indicating that [Ĥx] > is an incorrect Turing Machine Description. There is no machine in the class H. As it happens, since you are misuing the notation, there are actually lots of machine in the class you are calling H but that's just because you don't know what the notation means. I don't know which I should respond to. > It was the 3000 hours that I spent working on the Liar Paradox > formulating a whole new branch of mathematics in the process that > lead me to this key insight. Yes, it's led you astray because they are very different. I can't do anything about that now. I don't think I can even stop you wasting more time. > Since I have explained this to you it should only take paying very > close attention to what I am saying to confirm that what I say is > necessarily correct. Paying close attention to what I have explained has not had that effect on you. Why do you think the reverse would be any better? > At H.qx [Ĥx] [Ĥx2] H would be required to trace the state transitions > of [Ĥx] until [Ĥx] reaches [Ĥx].qx No machine in the class H has a state called qx. At least not in any of the material you have posted here. qx was your name for a state in H^ and later H^x. > which would require [Ĥx] to trace the state transitions > of [Ĥx2] until [Ĥx2] reaches [Ĥx2].qx > > At this point H decides** that [Ĥx] is not a correct TMD thus transitions > to its own state of H.qn. H has no state qx. > ** detects the pathological self-reference(olcott 2004) of its input. Obviously wrong, though it might be a typo. Then it would be wrong for some other reason. > Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott BTW, do you have permission to use the diagrams from Linz's book? Maybe you don't need it. I don't know US copyright law. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-11 00:36 -0600 |
| Message-ID | <JdCdna8MAbPHeeLHnZ2dnUU7-aXNnZ2d@giganews.com> |
| In reply to | #172349 |
On 2/10/2018 11:06 AM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 2/10/2018 6:57 AM, Ben Bacarisse wrote: >>> Pete Olcott <Pete@NoEmail.address> writes: >>> >>>> On 2/9/2018 3:40 PM, Ben Bacarisse wrote: >>>>> peteolcott <peterolcott2@gmail.com> writes: >>>>> <snip> >>>>>> I provided this concrete example to correctly refute Ben's claim >>>>>> that there is no specific sequence of syntactic logical consequence >>>>>> required when evaluating a pair of David Hilbert finite strings in >>>>>> the language or Turing Machine descriptions. >>>>> >>>>> I could never make that claim because it's just a word salad to me. >>>> >>>> You have to actually look at the words of the original post BEFORE >>>> providing your rebuttal. >>> >>> Eh? Quote where I said what you claim or shut up. >>> >>>>> A >>>>> more honest way to contest someone's claims is by quoting their words. >>>> >>>> This is the whole thing about the sequ3ence that H must follow to >>>> evaluate the halting behavior of H^. >>> >>> I am accusing you of misrepresenting what I said. Most people >>> consider this morally wrong as well as a terrible way to conduct a >>> discussion. >>> >>>>> If you think I'm wrong, quote me and explain why. >>>> Here is why: http://www.liarparadox.org/H_evaluates_S.pdf >>> >>> Quote me. Posting links to more junk does not excuse your dishonesty. >>> >>>>> Don't just make stuff >>>>> up. (At the very least, if you quote what I said that makes you think I >>>>> made the above claim, I might stand a chance of finding out what that >>>>> apparently random assemblage of words means. I've long since given up >>>>> asking you to define your terms.) >>>>> >>>> >>>> This is the whole thing about the necessary sequence that H must follow >>>> to evaluate the halting behavior of H^. You said that it should be >>>> free to do anything. >>> >>> .... provided it behaves as specified. You ignore that, probably because >>> you don't know what the notation means, though you copy it out enough >>> times. >>> >>>> I proved by a concrete example that no halt decider is free at all. It >>>> is strictly bound by the syntactic logical consequence defined by the >>>> input strings within the formal language of Turing machine >>>> Descriptions. >>> >>> Nope. >>> >>>> The concrete example challenges you to come up with a counter-example >>>> such that H decides [S] "ENN" without following every state transition >>>> that [S] would make. >>> >>> There is no machine in the class denoted by H. Learn what a counter >>> example is before asking for one. Normally, I'd give you an analogy for >>> this absurd request, but you are not engaging with any technical remarks >>> anymore so I don't see the point. >>> >> >> It is always the case that every halt decider must trace the precise >> sequence of state transitions of its input TMD up to the point where >> this TMD halts or demonstrates non halting behavior. > > Every halt decider must behave /as if/ it can trace the precise sequence > of state transitions of its input TMD up to the point where this TMD > halts or demonstrates non halting behaviour. Any machine that actually > does this will not be a halt decider. > I have aid it this way many dozens of times and you always disagreed. Maybe that comes form only glancing a a few of my words before forming your rebuttal. > You used to talk about evaluating and tracing and even (once or twice) > about universal TMs so this distinction is important. You need to be > clear that "tracing" is just a metaphor. > It is not a metaphor. The Halt Decider must essentially execute the TMD in step-by-step debug mode, until the TMD either halts or exhibits non-halting behavior, then the Halt Decider breaks out of debug mode and transitions to one of its final states. > I have invented a clever encoding for TMs and inputs as binary sequences > (zeros and ones) with the useful property the if you treat the sequence > as a number and factor it, those numbers with an odd number of prime > factors always represent halting computations and those with an even > number of primes factor always represent non-halting computations. My > halt decider therefore just does a little basic arithmetic. Is it > "tracing the precise sequence of state transitions of its input TMD up > to the point where this TMD halts or demonstrates non halting > behaviour"? > Remember what I said about key semantic meaning slipping through the cracks undetected because the formal system is insufficiently expressive to detect these gaps? (I said this to you years ago). Your system has the same short-coming. >> A halt decider performs a mathematical proof of syntactic logical >> consequence from its input strings to its final halt decision states. > > Yes. We call that deciding correctly. > Definition of Turing Machine H H.q0 Wm W ⊢* H.qy H.q0 Wm W ⊢* H.qn Definition of Turing Machine Ĥx Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy // NO LOOP Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn // NO LOOP HERE EITHER So then apply that here: H [Ĥx] [Ĥx] >> It cannot skip any steps along the way. > > You have no idea what steps it takes to do the job, but yes, it must do > them all, obviously. I know exactly what steps it must take along the way it must trace every state transition of [Ĥx] until [Ĥx] halts or exhibits non-halting behavior. (Remember what I said above about debug mode). > >> In the case of halt deciders >> evaluating finite strings defined within the language or Turing Machine >> Descriptions this chain of inference must necessarily involve every >> single state transition of the TMD until this TMD halts or demonstrates >> non-halting behavior. > > But it must do this is a finite number of steps, agreed? Yes. So it looks like we are getting somewhere. We are arriving at mutual understanding. > >> You have disagreed with this and now H [S] "ENN"proves that you have >> always been wrong about this. I am not talking about simulation of the >> TMD, I have disavowed this many times. >> >> An execution trace is like a step-by-step debug trace. It can break out of >> the "debugger" at any time. It does break out of the debugger as soon as it >> detects halting or non-halting behavior, but it cannot break out before this. >> >> Definition of Turing Machine H (state transition sequence) >> H.q0 Wm W ⊢* H.qy >> H.q0 Wm W ⊢* H.qn > > No. Stop using this notation until you have learned it. I know exactly what this notation means and it really seems dishonest of you to say otherwise. The notation is a triviality compared to my published patents: 7,046,848, 9,171,207 > >> 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 > > No. Stop using this notation until you have learned it. > You know that I must know what this triviality means Quit being so damned disrespectful! >> H [Ĥx] [Ĥx] >> >> After thousands of hours of very careful study I can now finally >> see that H would transition to its state H.qn indicating that [Ĥx] >> is an incorrect Turing Machine Description. > > There is no machine in the class H. As it happens, since you are > misuing the notation, there are actually lots of machine in the class > you are calling H This is true yet too cumbersome to keep specifying. > but that's just because you don't know what the > notation means. I don't know which I should respond to. > Quit being so damned disrespectful ! I have already proven that I know what this means countless times. Even though you have not proven that you know what it means I would look like quite an ass if I claimed that you did not understand such simple stuff. We are getting to some key mutual agreement though as shown above. >> It was the 3000 hours that I spent working on the Liar Paradox >> formulating a whole new branch of mathematics in the process that >> lead me to this key insight. > > Yes, it's led you astray because they are very different. I can't do > anything about that now. I don't think I can even stop you wasting more > time. > >> Since I have explained this to you it should only take paying very >> close attention to what I am saying to confirm that what I say is >> necessarily correct. > > Paying close attention to what I have explained has not had that > effect on you. Why do you think the reverse would be any better? > I have known for 21 years that if the HP and the GIT are correct then Truth itself is broken. That is why I remain persistent in the certainty of my eventual success. Tarski even "proved" that Truth itself is broken. I only found out about that in the last 18 months. It is not possible for Truth itself to be broken thus any conclusion to the contrary is necessarily incorrect. >> At H.qx [Ĥx] [Ĥx2] H would be required to trace the state transitions >> of [Ĥx] until [Ĥx] reaches [Ĥx].qx > > No machine in the class H has a state called qx. At least not in any of > the material you have posted here. > qx was your name for a state in H^ > and later H^x. Technically all of these machine are derived from class H, thus in class H. Lets just ignore that trivial detail and call them H, [Ĥ] and [Ĥx]. > >> which would require [Ĥx] to trace the state transitions >> of [Ĥx2] until [Ĥx2] reaches [Ĥx2].qx >> >> At this point H decides** that [Ĥx] is not a correct TMD thus transitions >> to its own state of H.qn. > > H has no state qx. > Yes I sad that incorrectly, it would be H.q0. Here is the corrected sequence. -- At H.q0 [Ĥx] [Ĥx2] H would be required to trace the state transitions -- of [Ĥx] until [Ĥx] reaches [Ĥx].qx -- which would require [Ĥx] to trace the state transitions -- of [Ĥx2] until [Ĥx2] reaches [Ĥx2].qx -- -- At this point H decides** that [Ĥx] is not a correct TMD thus transitions -- to its own state of H.qn. -- ** detects the pathological self-reference(olcott 2004) of its input. >> ** detects the pathological self-reference(olcott 2004) of its input. > > Obviously wrong, though it might be a typo. Then it would be wrong for > some other reason. No this is the part that you do not perform the execution trace correctly. We can work on this after your reply to this. Its OK this part took me 3000 hours and a dozen years to understand. We got this far though so that it very great, really superbly excellent. https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example August 2016, I thought it was merely a mistake by Linz: It looks like the original specification provided in the Linz text may be infinitely recursive in that each TM requires its own input. We fix this by providing simple input that definitely halts. Here is when I began to pursue it as a possible correct resolution: https://groups.google.com/d/msg/comp.theory/NcFS02hKs1U/PlBF-1LRBAAJ > >> Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott > > BTW, do you have permission to use the diagrams from Linz's book? Maybe > you don't need it. I don't know US copyright law. > In the US there is Fair Use of copyrighted works without permission. I am very pleased with the progress that we have made. I think that we are finally coming to a very significant mutual understanding. If I am eventually proved correct I will cite you as my most valuable reviewer of all Halting Problem related discussions. Copyright 2004, 2015, 2016, 2017, 2018 Pete Olcott -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-11 16:13 +0000 |
| Message-ID | <874lmnjyhc.fsf@bsb.me.uk> |
| In reply to | #172399 |
I had lots of comments but then got to the part where we agree. It seemed silly to reply to all the details before that. The agreement seems significant so I cut the rest to concentrate on this bit: Pete Olcott <Pete@NoEmail.address> writes: > On 2/10/2018 11:06 AM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: <snip> >>> In the case of halt deciders >>> evaluating finite strings defined within the language or Turing Machine >>> Descriptions this chain of inference must necessarily involve every >>> single state transition of the TMD until this TMD halts or demonstrates >>> non-halting behavior. >> >> But it must do this is [in] a finite number of steps, agreed? > > Yes. So it looks like we are getting somewhere. We are arriving > at mutual understanding. Yes! Whatever the decider does it much be able to make its determination in a finite number of steps. That's key and it's what H.q0 [M] W ⊢* H.qy when M halts on input W H.q0 [M] W ⊢* H.qn when M does not halt on input W means. H^ (built from H' built from some H meeting this specification) just copies it's input and then (from the state you helpful renamed H^.qx) behaves like H'. H' behaves like H right up until the last extra states that were added to H. So now I can no longer see what part of the proof is bothering you. We have H^.q0 W |-* H^.qx W W |-* H^.qy oo if W encodes a TM that halts on W H^.q0 W |-* H^.qx W W |-* H^.qn otherwise Set W=[H^] in these lines to get this: H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qy oo if [H^] encodes a TM that halts on [H^] and H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qn otherwise. From this it's clear that H^ [H^] is a computation that does not halt if [H^] encodes a machine that halts on input [H^], or it is a computation that does halt if [H^] doesn't encode a machine that halts on input [H^]. No? <snip> >>> Definition of Turing Machine H (state transition sequence) >>> H.q0 Wm W ⊢* H.qy >>> H.q0 Wm W ⊢* H.qn >> >> No. Stop using this notation until you have learned it. > > I know exactly what this notation means and it really seems dishonest > of you to say otherwise. It does /not/ define a Turning machine. And without extra annotations it does not even say what sort of machine H is. When you put those annotation back it describes behaviour -- it does define a machine. >>> 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 >> >> No. Stop using this notation until you have learned it. > > You know that I must know what this triviality means > Quit being so damned disrespectful! For many posts you adamantly refused to accept that H^ always got to state qy or state qn, yet you kept saying that it did using this notation. What possible interpretation can there be other than you did not know what you were writing? However, it does not define a Turning machine and you need specify in what cases each line applies. The rest of the post seems odd to me now that you agree that, to be a halt decider, as assumed by the proof, H must make its determination in a finite number of steps. The most helpful reply would be for you to say what part of the proof now bothers you. Maybe you could just mark the part above where you come unstuck? <snip> > I am very pleased with the progress that we have made. I think that we > are finally coming to a very significant mutual understanding. Maybe. I am, however, now not sure what part of the proof is bothering you. The most progress would my made were you to simply point out the step in the reasoning you think is wrong. Take the argument and just put a **THIS!** at the bit you don't accept. I fear that instead of doing that you will write lots of words. > If I am > eventually proved correct I will cite you as my most valuable reviewer > of all Halting Problem related discussions. If you publish anything, I would very much appreciate it if you did not use my name in any way. This includes blog posts and so on. I know I can not stop you, but I hope you will honour this request. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-12 20:34 -0600 |
| Message-ID | <eYydnSl6VsUH0x_HnZ2dnUU7-YHNnZ2d@giganews.com> |
| In reply to | #172431 |
On 2/11/2018 10:13 AM, Ben Bacarisse wrote: > I had lots of comments but then got to the part where we agree. It > seemed silly to reply to all the details before that. The agreement > seems significant so I cut the rest to concentrate on this bit: > > Pete Olcott <Pete@NoEmail.address> writes: >> On 2/10/2018 11:06 AM, Ben Bacarisse wrote: >>> Pete Olcott <Pete@NoEmail.address> writes: > <snip> >>>> In the case of halt deciders >>>> evaluating finite strings defined within the language or Turing Machine >>>> Descriptions this chain of inference must necessarily involve every >>>> single state transition of the TMD until this TMD halts or demonstrates >>>> non-halting behavior. >>> >>> But it must do this is [in] a finite number of steps, agreed? >> >> Yes. So it looks like we are getting somewhere. We are arriving >> at mutual understanding. > > Yes! Whatever the decider does it much be able to make its > determination in a finite number of steps. That's key and it's what > > H.q0 [M] W ⊢* H.qy when M halts on input W > H.q0 [M] W ⊢* H.qn when M does not halt on input W > Not quite. H.qy if [M] W is a correct TMD that halts on its input else H.qn > means. > > H^ (built from H' built from some H meeting this specification) just > copies it's input and then (from the state you helpful renamed H^.qx) > behaves like H'. H' behaves like H right up until the last extra states > that were added to H. > > So now I can no longer see what part of the proof is bothering you. We > have > You have to actually pay very close attention to what I am actually saying and not leap ahead to what you think that I am saying. H' is dead off topic done. H^ is dead off topic done. H^x is H with only the H^ states H^ prepended to H and none of the H' states appended. I have said this at least 20 times so it is really not that hard to get this point. > H^.q0 W |-* H^.qx W W |-* H^.qy oo if W encodes a TM that halts on W > H^.q0 W |-* H^.qx W W |-* H^.qn otherwise > > Set W=[H^] in these lines to get this: > > H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qy oo > > if [H^] encodes a TM that halts on [H^] and > > H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qn > > otherwise. From this it's clear that H^ [H^] is a computation that does > not halt if [H^] encodes a machine that halts on input [H^], or it is a > computation that does halt if [H^] doesn't encode a machine that halts > on input [H^]. No? > > <snip> >>>> Definition of Turing Machine H (state transition sequence) >>>> H.q0 Wm W ⊢* H.qy >>>> H.q0 Wm W ⊢* H.qn >>> >>> No. Stop using this notation until you have learned it. >> >> I know exactly what this notation means and it really seems dishonest >> of you to say otherwise. > > It does /not/ define a Turning machine. And without extra > annotations it does not even say what sort of machine H is. When you > put those annotation back it describes behaviour -- it does define a > machine. > Those are already assumed to be a part of the discourse context. Here is the complete discourse: http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >>>> 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 >>> >>> No. Stop using this notation until you have learned it. >> >> You know that I must know what this triviality means >> Quit being so damned disrespectful! > > For many posts you adamantly refused to accept that H^ always got to > state qy or state qn, yet you kept saying that it did using this > notation. What possible interpretation can there be other than you did > not know what you were writing? > Now that I have fully elaborated all of the nuances it turns out that I was right all along. When H performs a debug trace on Ĥx it aborts this trace before Ĥx ever gets to Ĥx.qy or Ĥx.qn. Ĥx [Ĥx] [Ĥx] specifies the pathological self-reference(Olcott 2004) and the halt evaluation is aborted with a transition to H.qn. > However, it does not define a Turning machine and you need specify in > what cases each line applies. > > The rest of the post seems odd to me now that you agree that, to be a > halt decider, as assumed by the proof, H must make its determination in > a finite number of steps. The most helpful reply would be for you to > say what part of the proof now bothers you. Maybe you could just mark > the part above where you come unstuck? None of it bothers me, I simply found out where it went wrong, how and why it is incorrect. I posted the answer way back in March 11, 2017 @ 3:13 PM in comp.theory. All of the HP proofs inherently specify an infinitely recursive evaluation sequence because each TM\D must have its own TMD / input pair. > > <snip> >> I am very pleased with the progress that we have made. I think that we >> are finally coming to a very significant mutual understanding. > > Maybe. I am, however, now not sure what part of the proof is bothering > you. The most progress would my made were you to simply point out the > step in the reasoning you think is wrong. I have already done that many times in may ways. That is OK that you don't get it yet it took me decades and thousands of hours. > Take the argument and just > put a **THIS!** at the bit you don't accept. I fear that instead of > doing that you will write lots of words. THIS: That all HP proof inherently specify an infinitely recursive set of TMD / input pairs because every TMD in this sequence requires its own TMD / Input pair. I will write it up more formally and publish it to www.researchgate.net. The one key piece that is missing is a really good abstract. > >> If I am >> eventually proved correct I will cite you as my most valuable reviewer >> of all Halting Problem related discussions. > > If you publish anything, I would very much appreciate it if you did not > use my name in any way. This includes blog posts and so on. I know I > can not stop you, but I hope you will honour this request. > So if I am correct and have correctly refuted the Halting Problem proofs you want to remain anonymous? Its a little too late for that because of USENET. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-13 04:18 +0000 |
| Message-ID | <87po59h69h.fsf@bsb.me.uk> |
| In reply to | #172537 |
Pete Olcott <Pete@NoEmail.address> writes:
> On 2/11/2018 10:13 AM, Ben Bacarisse wrote:
>> I had lots of comments but then got to the part where we agree. It
>> seemed silly to reply to all the details before that. The agreement
>> seems significant so I cut the rest to concentrate on this bit:
>>
>> Pete Olcott <Pete@NoEmail.address> writes:
>>> On 2/10/2018 11:06 AM, Ben Bacarisse wrote:
>>>> Pete Olcott <Pete@NoEmail.address> writes:
>> <snip>
>>>>> In the case of halt deciders
>>>>> evaluating finite strings defined within the language or Turing Machine
>>>>> Descriptions this chain of inference must necessarily involve every
>>>>> single state transition of the TMD until this TMD halts or demonstrates
>>>>> non-halting behavior.
>>>>
>>>> But it must do this is [in] a finite number of steps, agreed?
>>>
>>> Yes. So it looks like we are getting somewhere. We are arriving
>>> at mutual understanding.
>>
>> Yes! Whatever the decider does it much be able to make its
>> determination in a finite number of steps. That's key and it's what
>>
>> H.q0 [M] W ⊢* H.qy when M halts on input W
>> H.q0 [M] W ⊢* H.qn when M does not halt on input W
>>
>
> Not quite.
> H.qy if [M] W is a correct TMD that halts on its input
> else
> H.qn
No, that's not the halting problem. That's the PO-halting problem and it
may well have a decider (I'll let you know if tell me what a "correct" TDM
is). If you simply mean the [M] must encode a TM, well that's right
there in the notation. If that is not what you mean, the thread comes
to a screeching halt.
(There is a decider for strings of the form [M] for some TM M so it
makes no difference what version of the HP you consider. If you insist
on the "full" version you have to drop the rather convenient [M]
notation and say
H.q0 V W ⊢* H.qy iff V encodes a machine M that halts on input W
H.q0 V W ⊢* H.qn otherwise)
>> means.
>>
>> H^ (built from H' built from some H meeting this specification) just
>> copies it's input and then (from the state you helpful renamed H^.qx)
>> behaves like H'. H' behaves like H right up until the last extra states
>> that were added to H.
>>
>> So now I can no longer see what part of the proof is bothering you. We
>> have
>
> You have to actually pay very close attention to what I am actually saying
> and not leap ahead to what you think that I am saying.
>
> H' is dead off topic done.
> H^ is dead off topic done.
No, they are how the proof works. You can't tell me what part of the
proof is still giving you trouble if you think two key constructs are
off topic. They are the very core of the proof you claim to reject.
> H^x is H with only the H^ states H^ prepended to H and none of the H'
> states appended.
> I have said this at least 20 times so it is really not that hard to
> get this point.
H^x does not appear in the proof. I asked what part of the proof is
still bothering you. I wrote out the last steps since you have finally
accepted the step that seemed to be holding you up.
>> H^.q0 W |-* H^.qx W W |-* H^.qy oo if W encodes a TM that halts on W
>> H^.q0 W |-* H^.qx W W |-* H^.qn otherwise
>>
>> Set W=[H^] in these lines to get this:
>>
>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qy oo
>>
>> if [H^] encodes a TM that halts on [H^] and
>>
>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qn
>>
>> otherwise. From this it's clear that H^ [H^] is a computation that does
>> not halt if [H^] encodes a machine that halts on input [H^], or it is a
>> computation that does halt if [H^] doesn't encode a machine that halts
>> on input [H^]. No?
No doubt you read these words very carefully (as you expect me to do
with yours) so I wonder why you were not able to point out the flaw in
the logic. We have what could be called "trace equations" that I don't
think you dispute and they show the behaviour of H^ [H^] (were it to
exist) leads to a contradiction. I really can't see why you still
reject this clear and simple argument, and you are not helping by
refusing to say which step in the chain you dispute.
<snip>
>> For many posts you adamantly refused to accept that H^ always got to
>> state qy or state qn, yet you kept saying that it did using this
>> notation. What possible interpretation can there be other than you did
>> not know what you were writing?
>
> Now that I have fully elaborated all of the nuances it turns out
> that I was right all along. When H performs a debug trace on Ĥx
> it aborts this trace before Ĥx ever gets to Ĥx.qy or Ĥx.qn.
The proof makes no reference H^x. You need to say which step of the
proof is still bothering you. H^ /does/ always get to either qy or qn.
What some other machine might do is irrelevant.
> Ĥx [Ĥx] [Ĥx] specifies the pathological self-reference(Olcott 2004)
> and the halt evaluation is aborted with a transition to H.qn.
Whatever H^x does has no bearing on the key question. Which part of the
proof that you have so very nearly understood do you reject as invalid?
H^x may be how you go on to resolve what you see as a problem, but if
you want to claim that the proof is incorrect you must point out which
step you think does not follow form the previous ones.
>> However, it does not define a Turning machine and you need specify in
>> what cases each line applies.
>>
>> The rest of the post seems odd to me now that you agree that, to be a
>> halt decider, as assumed by the proof, H must make its determination in
>> a finite number of steps. The most helpful reply would be for you to
>> say what part of the proof now bothers you. Maybe you could just mark
>> the part above where you come unstuck?
>
> None of it bothers me, I simply found out where it went wrong, how and why
> it is incorrect.
Of course something about it bothers you -- you don't accept it. You
can just reject it by simply saying you'll simply never believe it, but
no one will take that seriously. You need to point out which step is
the one you don't accept.
> I posted the answer way back in March 11, 2017 @ 3:13 PM in comp.theory.
> All of the HP proofs inherently specify an infinitely recursive
> evaluation sequence because each TM\D must have its own TMD / input
> pair.
That is not a step in the proof. You can't refute a sound proof with
waffle. One of the steps must be wrong. If this notion of "infinitely
recursive evaluation" makes some step of the proof wrong, that's what
you need to point out. Otherwise, whatever it means, it has no bearing
on the argument.
>> <snip>
>>> I am very pleased with the progress that we have made. I think that we
>>> are finally coming to a very significant mutual understanding.
>>
>> Maybe. I am, however, now not sure what part of the proof is bothering
>> you. The most progress would my made were you to simply point out the
>> step in the reasoning you think is wrong.
>
> I have already done that many times in may ways. That is OK that
> you don't get it yet it took me decades and thousands of hours.
Ah, the old, I did it already ploy. So you won't say which step you
think is wrong by simply writing "THIS!!!" under the line you don't
accept? I wrote out the rest of the proof so you could do just that.
>> Take the argument and just
>> put a **THIS!** at the bit you don't accept. I fear that instead of
>> doing that you will write lots of words.
>
> THIS: That all HP proof inherently specify an infinitely recursive
> set of TMD / input pairs because every TMD in this sequence requires
> its own TMD / Input pair.
That's not a step in the proof. I wrote it out for you so you could
very simply say which step you reject.
> I will write it up more formally and publish it to www.researchgate.net.
> The one key piece that is missing is a really good abstract.
You are also missing a valid objection to a sound proof. And knowledge
of all the other proofs of this theorem.
>>> If I am
>>> eventually proved correct I will cite you as my most valuable reviewer
>>> of all Halting Problem related discussions.
>>
>> If you publish anything, I would very much appreciate it if you did not
>> use my name in any way. This includes blog posts and so on. I know I
>> can not stop you, but I hope you will honour this request.
>
> So if I am correct and have correctly refuted the Halting Problem proofs
> you want to remain anonymous?
> Its a little too late for that because of USENET.
I did not say that. I do not want or need to be anonymous here because
here I can defend myself. If you publish a paper I have no right of
reply. You could publish any old rubbish and my name would then be
associated with it. Will you accept my request?
If you answer no other question in the reply, please explicitly answer
this one.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-13 10:03 -0600 |
| Message-ID | <fqqdnTjeI4zwkR7HnZ2dnUU7-UvNnZ2d@giganews.com> |
| In reply to | #172552 |
On 2/12/2018 10:18 PM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 2/11/2018 10:13 AM, Ben Bacarisse wrote: >>> I had lots of comments but then got to the part where we agree. It >>> seemed silly to reply to all the details before that. The agreement >>> seems significant so I cut the rest to concentrate on this bit: >>> >>> Pete Olcott <Pete@NoEmail.address> writes: >>>> On 2/10/2018 11:06 AM, Ben Bacarisse wrote: >>>>> Pete Olcott <Pete@NoEmail.address> writes: >>> <snip> >>>>>> In the case of halt deciders >>>>>> evaluating finite strings defined within the language or Turing Machine >>>>>> Descriptions this chain of inference must necessarily involve every >>>>>> single state transition of the TMD until this TMD halts or demonstrates >>>>>> non-halting behavior. >>>>> >>>>> But it must do this is [in] a finite number of steps, agreed? >>>> >>>> Yes. So it looks like we are getting somewhere. We are arriving >>>> at mutual understanding. >>> >>> Yes! Whatever the decider does it much be able to make its >>> determination in a finite number of steps. That's key and it's what >>> >>> H.q0 [M] W ⊢* H.qy when M halts on input W >>> H.q0 [M] W ⊢* H.qn when M does not halt on input W >>> >> >> Not quite. >> H.qy if [M] W is a correct TMD that halts on its input >> else >> H.qn > > No, that's not the halting problem. That's the PO-halting problem and it It is the Halting Problem and you already agreed to this one. > may well have a decider (I'll let you know if tell me what a "correct" TDM > is). If you simply mean the [M] must encode a TM, well that's right > there in the notation. If that is not what you mean, the thread comes > to a screeching halt. If the finite string is an English poem H.qn. If the finite string is Pathological-self-reference(Olcott 2004) then H.qn If the finite string is a correct TMD that does not halt then H.qn This is the hardest part that everyone in the world failed to notice since 1937, so it is okay if it takes you a while to understand this. It even fooled me for 3000 hours over a dozen years. Until 2016 or 2017 I always thought that the Pathological Self-reference(Olcott 2004) came from the infinite loop appended to the (qy) state. > > (There is a decider for strings of the form [M] for some TM M so it > makes no difference what version of the HP you consider. If you insist > on the "full" version you have to drop the rather convenient [M] > notation and say > > H.q0 V W ⊢* H.qy iff V encodes a machine M that halts on input W > H.q0 V W ⊢* H.qn otherwise) > That way of saying it has a semantic gap that ignores the PSR error. The Truth is that every correct halt decider must abort the halt evaluation sequence specified by H [Ĥx] [Ĥx] before any halting decision is made because the halt evaluation sequence specifies infinite recursion. >>> means. >>> >>> H^ (built from H' built from some H meeting this specification) just >>> copies it's input and then (from the state you helpful renamed H^.qx) >>> behaves like H'. H' behaves like H right up until the last extra states >>> that were added to H. >>> >>> So now I can no longer see what part of the proof is bothering you. We >>> have >> >> You have to actually pay very close attention to what I am actually saying >> and not leap ahead to what you think that I am saying. >> >> H' is dead off topic done. >> H^ is dead off topic done. > > No, they are how the proof works. You can't tell me what part of the > proof is still giving you trouble if you think two key constructs are > off topic. They are the very core of the proof you claim to reject. I am and only will talk about H [Ĥx] [Ĥx]. Because we can know (by the David Hilbert formalist approach the precise chain of syntactic logical consequence (formal proof from finite string pair to H.qy or H.qn) we can know that every [Ĥx] begins a debug trace of its input at Ĥx.qx. Because we know that every [Ĥx] begins a debug trace of its input at Ĥx.qx we (and the halt decider) can decide that [Ĥx] [Ĥx] specifies the Pathological Self-reference(Olcott 2004) error. > >> H^x is H with only the H^ states H^ prepended to H and none of the H' >> states appended. >> I have said this at least 20 times so it is really not that hard to >> get this point. > > H^x does not appear in the proof. I asked what part of the proof is > still bothering you. I wrote out the last steps since you have finally > accepted the step that seemed to be holding you up. I simplified the proof to get rid of a possible source of endless digression. The same problem exists in the original proof, yet with the extraneous complexity** of the infinite loop appended to otherwise final state (qy). ** 1999 Turing Award winner Fred Brooks inessential complexity. The only way that I can solve these enormously difficult problems is to boil them down to their (Fred Brooks) essence. > >>> H^.q0 W |-* H^.qx W W |-* H^.qy oo if W encodes a TM that halts on W >>> H^.q0 W |-* H^.qx W W |-* H^.qn otherwise >>> >>> Set W=[H^] in these lines to get this: >>> >>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qy oo >>> >>> if [H^] encodes a TM that halts on [H^] and >>> >>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qn >>> >>> otherwise. From this it's clear that H^ [H^] is a computation that does >>> not halt if [H^] encodes a machine that halts on input [H^], or it is a >>> computation that does halt if [H^] doesn't encode a machine that halts >>> on input [H^]. No? > > No doubt you read these words very carefully (as you expect me to do > with yours) so I wonder why you were not able to point out the flaw in > the logic. We have what could be called "trace equations" that I don't > think you dispute and they show the behaviour of H^ [H^] (were it to > exist) leads to a contradiction. I really can't see why you still > reject this clear and simple argument, and you are not helping by > refusing to say which step in the chain you dispute. H [Ĥx] [Ĥx2] becomes [Ĥx] [Ĥx2] [Ĥx3] becomes [Ĥx2] [Ĥx3] [Ĥx4] becomes [Ĥx3] [Ĥx4] [Ĥx5] becomes on and on because every halt decider can only base its halting decision on its input pair and each TMD in the infinite sequence requires its own input pair (As I said March 11, 2017 @ 3:13 PM in comp.theory). > > <snip> >>> For many posts you adamantly refused to accept that H^ always got to >>> state qy or state qn, yet you kept saying that it did using this >>> notation. What possible interpretation can there be other than you did >>> not know what you were writing? >> >> Now that I have fully elaborated all of the nuances it turns out >> that I was right all along. When H performs a debug trace on Ĥx >> it aborts this trace before Ĥx ever gets to Ĥx.qy or Ĥx.qn. > > The proof makes no reference H^x. You need to say which step of the > proof is still bothering you. H^ /does/ always get to either qy or qn. > What some other machine might do is irrelevant. Bottom of page 319 verbatim q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ ∞ q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ y1 qn y2 Corrected, simplified, and clarified Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy ∞ Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn (1) I corrected his specified erroneous second start state (2) I got rid of the tape specification at qn (3) I made each state labeled with its machine name using dot notation When I refer to Ĥ.qx this is specified in Linz as a second start state. > >> Ĥx [Ĥx] [Ĥx] specifies the pathological self-reference(Olcott 2004) >> and the halt evaluation is aborted with a transition to H.qn. > > Whatever H^x does has no bearing on the key question. Which part of the > proof that you have so very nearly understood do you reject as invalid? > I can't even specify the debug trace of Ĥ [Ĥ] [Ĥ] because Linz has incorrectly specified two start states. > H^x may be how you go on to resolve what you see as a problem, but if > you want to claim that the proof is incorrect you must point out which > step you think does not follow form the previous ones. It is specified right here in the Linz notation: q0 Wm ⊢* Ĥ q0 Wm Wm, the execution trace of Wm Wm by Ĥ specifies an infinitely recursive evaluation sequence: Ĥ Wm Wm2 Wm Wm2 Wm3 Wm2 Wm3 Wm4 Wm3 Wm4 Wm5... > >>> However, it does not define a Turning machine and you need specify in >>> what cases each line applies. >>> >>> The rest of the post seems odd to me now that you agree that, to be a >>> halt decider, as assumed by the proof, H must make its determination in >>> a finite number of steps. The most helpful reply would be for you to >>> say what part of the proof now bothers you. Maybe you could just mark >>> the part above where you come unstuck? >> >> None of it bothers me, I simply found out where it went wrong, how and why >> it is incorrect. > > Of course something about it bothers you -- you don't accept it. You > can just reject it by simply saying you'll simply never believe it, but > no one will take that seriously. You need to point out which step is > the one you don't accept. > I am not bothered by the question: "What time is it (yes or no)?" I simply reject it as incorrect. >> I posted the answer way back in March 11, 2017 @ 3:13 PM in comp.theory. >> All of the HP proofs inherently specify an infinitely recursive >> evaluation sequence because each TM\D must have its own TMD / input >> pair. > > That is not a step in the proof. You can't refute a sound proof with > waffle. One of the steps must be wrong. If this notion of "infinitely > recursive evaluation" makes some step of the proof wrong, that's what > you need to point out. Otherwise, whatever it means, it has no bearing > on the argument. It is only the conclusion of the proof that is wrong. H [Ĥx] [Ĥx] correctly decides that this is erroneous. > >>> <snip> >>>> I am very pleased with the progress that we have made. I think that we >>>> are finally coming to a very significant mutual understanding. >>> >>> Maybe. I am, however, now not sure what part of the proof is bothering >>> you. The most progress would my made were you to simply point out the >>> step in the reasoning you think is wrong. >> >> I have already done that many times in may ways. That is OK that >> you don't get it yet it took me decades and thousands of hours. > > Ah, the old, I did it already ploy. So you won't say which step you > think is wrong by simply writing "THIS!!!" under the line you don't > accept? I wrote out the rest of the proof so you could do just that. > >>> Take the argument and just >>> put a **THIS!** at the bit you don't accept. I fear that instead of >>> doing that you will write lots of words. >> >> THIS: That all HP proof inherently specify an infinitely recursive >> set of TMD / input pairs because every TMD in this sequence requires >> its own TMD / Input pair. > > That's not a step in the proof. I wrote it out for you so you could > very simply say which step you reject. Bottom of page 319 verbatim q0 Wm ⊢* Ĥ q0 Wm Wm q0 Wm ⊢* Ĥ q0 Wm Wm The execution trace of Ĥ Wm Wm at this point in is specification. > >> I will write it up more formally and publish it to www.researchgate.net. >> The one key piece that is missing is a really good abstract. > > You are also missing a valid objection to a sound proof. And knowledge > of all the other proofs of this theorem. I am not actually missing a valid objection to a sound proof I just have not yet found exactly the right words so that everyone can easily see that I obviously correct. You and I are getting very close though. > >>>> If I am >>>> eventually proved correct I will cite you as my most valuable reviewer >>>> of all Halting Problem related discussions. >>> >>> If you publish anything, I would very much appreciate it if you did not >>> use my name in any way. This includes blog posts and so on. I know I >>> can not stop you, but I hope you will honour this request. >> >> So if I am correct and have correctly refuted the Halting Problem proofs >> you want to remain anonymous? >> Its a little too late for that because of USENET. > > I did not say that. I do not want or need to be anonymous here because > here I can defend myself. If you publish a paper I have no right of > reply. You could publish any old rubbish and my name would then be > associated with it. Will you accept my request? > > If you answer no other question in the reply, please explicitly answer > this one. > When I say publish I mean like in the Journal of the ACM. If I am validated and published and asked who helped review my work I will say it was reviewed on USENET by various reviewers. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-13 17:13 +0000 |
| Message-ID | <87vaf0g6e7.fsf@bsb.me.uk> |
| In reply to | #172587 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/12/2018 10:18 PM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: >> >>> On 2/11/2018 10:13 AM, Ben Bacarisse wrote: >>>> I had lots of comments but then got to the part where we agree. It >>>> seemed silly to reply to all the details before that. The agreement >>>> seems significant so I cut the rest to concentrate on this bit: >>>> >>>> Pete Olcott <Pete@NoEmail.address> writes: >>>>> On 2/10/2018 11:06 AM, Ben Bacarisse wrote: >>>>>> Pete Olcott <Pete@NoEmail.address> writes: >>>> <snip> >>>>>>> In the case of halt deciders >>>>>>> evaluating finite strings defined within the language or Turing Machine >>>>>>> Descriptions this chain of inference must necessarily involve every >>>>>>> single state transition of the TMD until this TMD halts or demonstrates >>>>>>> non-halting behavior. >>>>>> >>>>>> But it must do this is [in] a finite number of steps, agreed? >>>>> >>>>> Yes. So it looks like we are getting somewhere. We are arriving >>>>> at mutual understanding. >>>> >>>> Yes! Whatever the decider does it much be able to make its >>>> determination in a finite number of steps. That's key and it's what >>>> >>>> H.q0 [M] W ⊢* H.qy when M halts on input W >>>> H.q0 [M] W ⊢* H.qn when M does not halt on input W >>> >>> Not quite. >>> H.qy if [M] W is a correct TMD that halts on its input >>> else >>> H.qn >> >> No, that's not the halting problem. That's the PO-halting problem and it > > It is the Halting Problem and you already agreed to this one. > >> may well have a decider (I'll let you know if tell me what a "correct" TDM >> is). If you simply mean the [M] must encode a TM, well that's right >> there in the notation. If that is not what you mean, the thread comes >> to a screeching halt. > > If the finite string is an English poem H.qn. > If the finite string is Pathological-self-reference(Olcott 2004) then H.qn > If the finite string is a correct TMD that does not halt then H.qn No, this is not the halting problem. I am very happy you have sorted out the PO-halting problem to your satisfaction, but you are not saying anything interesting about /the/ halting problem. It's defined in every single textbook on the subject. If I have agrees to this being the halting problem than I was simply wrong. I won't ask you to say where I agreed to it since you rarely address direct questions, but if I did, I was wrong. The halting problem is the problem of deciding what strings represent encoded TMs and inputs where the encoded TM would halt when run with the encoded input. All other strings (those that don't encode TM/input pairs included) must be rejected. The middle category -- properly encoded computations that you don't like the look of -- must be decided according the halting of the computation, not any other criteria. (It's logically possible that all those middle category strings represent halting computations in which case you are talking about the same problem, but that seems unlikely form the word syou use. Why not just call them halting computations?) > This is the hardest part that everyone in the world failed to notice > since 1937, so it is okay if it takes you a while to understand this. Not at all. Ever single year I taught this material someone came up with this idea. It is, after all, a seemingly obvious way round what looks like a "trick" in the proof -- spot the tricksy cases and either reject them or put them into some third category (you have proposed both in the past). Maybe you were the student who came up with it when you were taught this at university, but there is always someone who does. > It even fooled me for 3000 hours over a dozen years. Until 2016 or 2017 > I always thought that the Pathological Self-reference(Olcott 2004) came > from the infinite loop appended to the (qy) state. > >> >> (There is a decider for strings of the form [M] for some TM M so it >> makes no difference what version of the HP you consider. If you insist >> on the "full" version you have to drop the rather convenient [M] >> notation and say >> >> H.q0 V W ⊢* H.qy iff V encodes a machine M that halts on input W >> H.q0 V W ⊢* H.qn otherwise) >> > > That way of saying it has a semantic gap that ignores the PSR error. Or that you are addressing a different problem. That's fine. If you want to treat some reject a set of strings because of some other criterion (PSR as you call it), that makes it a different problem. I see know that the "semantic gap" is simply that the halting problem is not the problem you are talking about. > The Truth is that every correct halt decider must abort the halt > evaluation sequence specified by H [Ĥx] [Ĥx] before any halting decision > is made because the halt evaluation sequence specifies infinite > recursion. That may well be what you want for the PO-halting problem. I'm not interesting in it. >>>> means. >>>> >>>> H^ (built from H' built from some H meeting this specification) just >>>> copies it's input and then (from the state you helpful renamed H^.qx) >>>> behaves like H'. H' behaves like H right up until the last extra states >>>> that were added to H. >>>> >>>> So now I can no longer see what part of the proof is bothering you. We >>>> have >>> >>> You have to actually pay very close attention to what I am actually saying >>> and not leap ahead to what you think that I am saying. >>> >>> H' is dead off topic done. >>> H^ is dead off topic done. >> >> No, they are how the proof works. You can't tell me what part of the >> proof is still giving you trouble if you think two key constructs are >> off topic. They are the very core of the proof you claim to reject. > > I am and only will talk about H [Ĥx] [Ĥx]. OK. It has nothing to do with the proof of the halting theorem. <snip> >>> H^x is H with only the H^ states H^ prepended to H and none of the H' >>> states appended. >>> I have said this at least 20 times so it is really not that hard to >>> get this point. >> >> H^x does not appear in the proof. I asked what part of the proof is >> still bothering you. I wrote out the last steps since you have finally >> accepted the step that seemed to be holding you up. > > I simplified the proof to get rid of a possible source of endless > digression. I saw no proof of the halting theorem. And it seems you are not even talking about the same theorem. The PO-halting problem will have a PO-halting theorem of some sort but I don't know what it is and I don't care. I doubt any one else does either. > The same problem exists in the original proof, yet with the extraneous > complexity** of the infinite loop appended to otherwise final state (qy). > > ** 1999 Turing Award winner Fred Brooks inessential complexity. > The only way that I can solve these enormously difficult problems > is to boil them down to their (Fred Brooks) essence. > >> >>>> H^.q0 W |-* H^.qx W W |-* H^.qy oo if W encodes a TM that halts on W >>>> H^.q0 W |-* H^.qx W W |-* H^.qn otherwise >>>> >>>> Set W=[H^] in these lines to get this: >>>> >>>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qy oo >>>> >>>> if [H^] encodes a TM that halts on [H^] and >>>> >>>> H^.q0 [H^] |-* H^.qx [H^] [H^] |-* H^.qn >>>> >>>> otherwise. From this it's clear that H^ [H^] is a computation that does >>>> not halt if [H^] encodes a machine that halts on input [H^], or it is a >>>> computation that does halt if [H^] doesn't encode a machine that halts >>>> on input [H^]. No? >> >> No doubt you read these words very carefully (as you expect me to do >> with yours) so I wonder why you were not able to point out the flaw in >> the logic. We have what could be called "trace equations" that I don't >> think you dispute and they show the behaviour of H^ [H^] (were it to >> exist) leads to a contradiction. I really can't see why you still >> reject this clear and simple argument, and you are not helping by >> refusing to say which step in the chain you dispute. > > H [Ĥx] [Ĥx2] becomes > [Ĥx] [Ĥx2] [Ĥx3] becomes > [Ĥx2] [Ĥx3] [Ĥx4] becomes > [Ĥx3] [Ĥx4] [Ĥx5] becomes on and on > because every halt decider can only base its halting decision on its input > pair and each TMD in the infinite sequence requires its own input pair None of that has any relevance to the proof you claimed to reject. (It happens to be wrong, but since it's irrelevant, I won't waste more time trying to explain to you why it's wrong). > (As I said March 11, 2017 @ 3:13 PM in comp.theory). > >> >> <snip> >>>> For many posts you adamantly refused to accept that H^ always got to >>>> state qy or state qn, yet you kept saying that it did using this >>>> notation. What possible interpretation can there be other than you did >>>> not know what you were writing? >>> >>> Now that I have fully elaborated all of the nuances it turns out >>> that I was right all along. When H performs a debug trace on Ĥx >>> it aborts this trace before Ĥx ever gets to Ĥx.qy or Ĥx.qn. >> >> The proof makes no reference H^x. You need to say which step of the >> proof is still bothering you. H^ /does/ always get to either qy or qn. >> What some other machine might do is irrelevant. > > Bottom of page 319 verbatim > q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ ∞ > q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ y1 qn y2 > > Corrected, simplified, and clarified > Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qy ∞ > Ĥx.q0 Wm ⊢* Ĥx.qx Wm Wm ⊢* Ĥx.qn No, you broke the proof by inventing a new construction. You now even have a way out -- you can accept the proof because it shows there is not halt decider. You have been talking about a PO-halt decider, and they may well exist. > (1) I corrected his specified erroneous second start state > (2) I got rid of the tape specification at qn > (3) I made each state labeled with its machine name using dot notation > > When I refer to Ĥ.qx this is specified in Linz as a second start > state. Yes, that typo (or error or whatever) in the book was fixed long ago. The problem is you have stopped talking about the proof now that this point has been cleared up. >>> Ĥx [Ĥx] [Ĥx] specifies the pathological self-reference(Olcott 2004) >>> and the halt evaluation is aborted with a transition to H.qn. H^x transitions to qy for that input. You should know -- you inverted this construction. Obviously this mistake is not important because nothing about H^x says anything about the proof of the halting theorem. >> Whatever H^x does has no bearing on the key question. Which part of the >> proof that you have so very nearly understood do you reject as invalid? > > I can't even specify the debug trace of Ĥ [Ĥ] [Ĥ] because Linz has > incorrectly specified two start states. Yes, we know about that. You have been correctly specifying H' and H^ for some time now, so there is no need to get stuck on this typo. After all, you claim to know about all proofs of this theorem. If this typo is you only objection, I am content -- it means you accept my corrected version. >> H^x may be how you go on to resolve what you see as a problem, but if >> you want to claim that the proof is incorrect you must point out >> which step you think does not follow form the previous ones. > > It is specified right here in the Linz notation: > q0 Wm ⊢* Ĥ q0 Wm Wm, the execution trace of Wm Wm by Ĥ specifies > an infinitely recursive evaluation sequence: > Ĥ Wm Wm2 > Wm Wm2 Wm3 > Wm2 Wm3 Wm4 > Wm3 Wm4 Wm5... Yes, we all know about that. I wrote out the corrected proof for you. If your only objection is the typo in Linz, you have nothing. Is that all you have been complaining about? If so, why have you not accepted my corrected version? After all, it's a theorem about a problem you appear not to be interested in anymore. Accepting the corrected proof says nothing about the PO-halting problem. >>>> However, it does not define a Turning machine and you need specify in >>>> what cases each line applies. >>>> >>>> The rest of the post seems odd to me now that you agree that, to be a >>>> halt decider, as assumed by the proof, H must make its determination in >>>> a finite number of steps. The most helpful reply would be for you to >>>> say what part of the proof now bothers you. Maybe you could just mark >>>> the part above where you come unstuck? >>> >>> None of it bothers me, I simply found out where it went wrong, how and why >>> it is incorrect. >> >> Of course something about it bothers you -- you don't accept it. You >> can just reject it by simply saying you'll simply never believe it, but >> no one will take that seriously. You need to point out which step is >> the one you don't accept. > > I am not bothered by the question: "What time is it (yes or no)?" > I simply reject it as incorrect. That's not an answer. If you can't say what step you reject in the reasoning of the proof I wrote out, you have nothing. >>> I posted the answer way back in March 11, 2017 @ 3:13 PM in comp.theory. >>> All of the HP proofs inherently specify an infinitely recursive >>> evaluation sequence because each TM\D must have its own TMD / input >>> pair. >> >> That is not a step in the proof. You can't refute a sound proof with >> waffle. One of the steps must be wrong. If this notion of "infinitely >> recursive evaluation" makes some step of the proof wrong, that's what >> you need to point out. Otherwise, whatever it means, it has no bearing >> on the argument. > > It is only the conclusion of the proof that is wrong. So there is no step you can point to which does not follow logically from the previous ones. That means you have nothing. > H [Ĥx] [Ĥx] correctly decides that this is erroneous. H must accept that input. It is supposed to be a halting decider, and H^x halts on all inputs. Of course a PO-halt decider can do what it likes with the instance, but a decider for the halting problem must accept it. And, finally, H^x does not exist because it is derived form a class of machine that is empty. >>>> <snip> >>>>> I am very pleased with the progress that we have made. I think that we >>>>> are finally coming to a very significant mutual understanding. >>>> >>>> Maybe. I am, however, now not sure what part of the proof is bothering >>>> you. The most progress would my made were you to simply point out the >>>> step in the reasoning you think is wrong. >>> >>> I have already done that many times in may ways. That is OK that >>> you don't get it yet it took me decades and thousands of hours. >> >> Ah, the old, I did it already ploy. So you won't say which step you >> think is wrong by simply writing "THIS!!!" under the line you don't >> accept? I wrote out the rest of the proof so you could do just that. >> >>>> Take the argument and just >>>> put a **THIS!** at the bit you don't accept. I fear that instead of >>>> doing that you will write lots of words. >>> >>> THIS: That all HP proof inherently specify an infinitely recursive >>> set of TMD / input pairs because every TMD in this sequence requires >>> its own TMD / Input pair. >> >> That's not a step in the proof. I wrote it out for you so you could >> very simply say which step you reject. > > Bottom of page 319 verbatim > q0 Wm ⊢* Ĥ q0 Wm Wm > q0 Wm ⊢* Ĥ q0 Wm Wm > > The execution trace of Ĥ Wm Wm at this point in is specification. Yes, we all know about that. I wrote out the corrected proof for you. If your only complaint is the typo in the book, you have nothing. >>> I will write it up more formally and publish it to www.researchgate.net. >>> The one key piece that is missing is a really good abstract. <snip> >>>>> If I am >>>>> eventually proved correct I will cite you as my most valuable reviewer >>>>> of all Halting Problem related discussions. >>>> >>>> If you publish anything, I would very much appreciate it if you did not >>>> use my name in any way. This includes blog posts and so on. I know I >>>> can not stop you, but I hope you will honour this request. >>> >>> So if I am correct and have correctly refuted the Halting Problem proofs >>> you want to remain anonymous? >>> Its a little too late for that because of USENET. >> >> I did not say that. I do not want or need to be anonymous here because >> here I can defend myself. If you publish a paper I have no right of >> reply. You could publish any old rubbish and my name would then be >> associated with it. Will you accept my request? >> >> If you answer no other question in the reply, please explicitly answer >> this one. > > When I say publish I mean like in the Journal of the ACM. You referred to a self-publishing site. Obviously I have no worries about the JACM -- they don't publish junk, but researchgate.net may well do. > If I am validated and published and asked who helped review > my work I will say it was reviewed on USENET by various reviewers. Good enough, I suppose. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-13 16:59 -0800 |
| Message-ID | <2932931c-6240-4e75-8b7e-1c2a51c0bb82@googlegroups.com> |
| In reply to | #172593 |
On Wednesday, February 14, 2018 at 10:13:47 AM UTC+10, Pete Olcott wrote: > This is very tricky stuff reformulating the foundations of logical > inference. SEE: BACKPEDDLING H^x HALTS !!! REPEAT THAT 35 TIMES!!! fun H-hatx( w ) if halt(w,w) then nothing
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-12 21:36 -0800 |
| Message-ID | <5b503b95-7392-4304-84bd-6aa8207825b8@googlegroups.com> |
| In reply to | #172537 |
On Tuesday, February 13, 2018 at 12:34:10 PM UTC+10, Pete Olcott wrote: > On 2/11/2018 10:13 AM, Ben Bacarisse wrote: > > I had lots of comments but then got to the part where we agree. It > > seemed silly to reply to all the details before that. The agreement > > seems significant so I cut the rest to concentrate on this bit: > > > > Pete Olcott <Pete@NoEmail.address> writes: > >> On 2/10/2018 11:06 AM, Ben Bacarisse wrote: > >>> Pete Olcott <Pete@NoEmail.address> writes: > > <snip> > >>>> In the case of halt deciders > >>>> evaluating finite strings defined within the language or Turing Machine > >>>> Descriptions this chain of inference must necessarily involve every > >>>> single state transition of the TMD until this TMD halts or demonstrates > >>>> non-halting behavior. > >>> > >>> But it must do this is [in] a finite number of steps, agreed? > >> > >> Yes. So it looks like we are getting somewhere. We are arriving > >> at mutual understanding. > > > > Yes! Whatever the decider does it much be able to make its > > determination in a finite number of steps. That's key and it's what > > > > H.q0 [M] W ⊢* H.qy when M halts on input W > > H.q0 [M] W ⊢* H.qn when M does not halt on input W > > > > Not quite. > H.qy if [M] W is a correct TMD that halts on its input > else > H.qn > > > means. > > > > H^ (built from H' built from some H meeting this specification) just > > copies it's input and then (from the state you helpful renamed H^.qx) > > behaves like H'. H' behaves like H right up until the last extra states > > that were added to H. > > > > So now I can no longer see what part of the proof is bothering you. We > > have > > > > You have to actually pay very close attention to what I am actually saying > and not leap ahead to what you think that I am saying. > > H' is dead off topic done. > H^ is dead off topic done. > H^x is H with only the H^ states H^ prepended to H and none of the H' states appended. > I have said this at least 20 times so it is really not that hard to get this point. Yeh H^x HALTS! Any basic HALT function can decide that!
[toc] | [prev] | [standalone]
Back to top | Article view | sci.logic
csiph-web