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


Groups > sci.logic > #171063 > unrolled thread

Re: Infinitely Recursive input on HP Proofs

Started byGeorge Greene <greeneg@email.unc.edu>
First post2018-01-25 20:26 -0800
Last post2018-02-03 17:00 -0800
Articles 20 on this page of 118 — 9 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 George Greene <greeneg@email.unc.edu> - 2018-01-25 20:26 -0800
    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-25 21:49 -0800
      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-26 04:10 -0800
        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-26 11:37 -0600
          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 15:12 -0800
      Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 05:34 -0800
        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-26 20:33 -0800
          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 05:05 -0800
            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 06:57 -0800
              Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 13:53 -0800
          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 20:24 +0000
            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 13:03 -0800
              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 21:58 +0000
                Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-29 19:02 -0800
                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 20:11 -0800
                    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:49 -0800
                      Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 09:43 -0800
                        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:07 -0800
                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 17:41 -0800
                            Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 18:40 -0800
                              Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 19:17 -0800
                                Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:20 -0600
                          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-30 21:21 -0800
                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 21:21 -0800
                    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:58 -0800
                  Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 03:16 +0000
                    Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:14 -0600
                      Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 22:37 -0800
                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:53 -0600
                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-31 19:38 -0800
                            Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:42 -0600
                              Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 18:08 -0800
                      Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 21:57 +0000
                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 16:21 -0600
                          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:44 +0000
                            Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:11 -0600
                              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 01:54 +0000
                                Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:15 -0600
                                  Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:36 -0800
                                  Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:13 +0000
                                  Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 21:30 +0000
                                    Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:17 +0000
                                      Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:42 +0000
                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 12:46 -0800
                                        Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-03 20:53 -0600
                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 19:51 -0800
                                            Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 18:56 -0600
                                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 17:22 -0800
                                                Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 20:45 -0600
                                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:45 -0800
                                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-06 15:34 +0000
                                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 08:02 -0800
                                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:51 +0000
                                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 10:23 -0800
                                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:52 +0000
                                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 17:19 -0800
                                                        Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:59 -0800
                                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 19:02 -0800
                                                            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:57 -0800
                                                        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 22:39 -0800
                                                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 23:14 -0800
                                                          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:45 -0800
                                                        Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 22:28 -0800
                                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:31 +0000
                                                      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:54 -0800
                                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 02:13 +0000
                                                      Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:49 +0000
                                                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-06 22:48 -0600
                                                          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 16:27 +0000
                                                            Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-07 23:22 -0600
                                                              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-08 21:05 +0000
                                                                Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-08 18:44 -0600
                                                                  Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-09 11:08 +0000
                                                                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:44 -0800
                                                                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:47 -0800
                                                                  Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-11 17:55 +0000
                                                                    Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-12 20:39 -0600
                                                          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:41 -0800
                                                          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:43 -0800
                                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 18:56 -0800
                                                        Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:50 -0800
                                                    Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-06 20:13 -0600
                                            Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:45 -0800
                                  Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-04 17:01 -0800
                                    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 16:44 -0800
                                      Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:42 -0800
                                      Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-05 18:09 -0800
                                        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:50 -0800
                          Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 19:57 -0600
                          Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-01 11:02 -0800
                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:10 -0600
                          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:51 +0000
                            Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:24 -0600
                              Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 17:34 -0800
                              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 02:04 +0000
                                Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:31 -0600
                                  Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:43 -0800
                                  Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:38 +0000
                                    Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-02 17:54 -0600
                                      Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 16:08 -0800
                                      Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 00:51 +0000
                                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 00:38 -0600
                                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 23:05 -0800
                                          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 13:37 +0000
                                            Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 14:27 -0600
                                              Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 23:49 +0000
                                                Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 16:03 -0800
                                                  Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 00:44 +0000
                                                    Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 17:11 -0800
                                                      Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 01:27 +0000
                                                      Re: Infinitely Recursive input on HP Proofs Newberry <newberryxy@gmail.com> - 2018-02-03 18:01 -0800
                                                        Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 20:44 -0800
                                                          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-04 02:32 -0800
                                                  Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 16:47 -0800
                              Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 14:12 +0000
                        Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:27 -0600
                          Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 02:13 +0000
          Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 17:00 -0800

Page 5 of 6 — ← Prev page 1 2 3 4 [5] 6  Next page →


#172130

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-07 20:50 -0800
Message-ID<e545803a-cc13-4f49-a5a9-8f80ab80b82e@googlegroups.com>
In reply to#172055
On Tuesday, February 6, 2018 at 9:56:06 PM UTC-5, peteolcott wrote:
> Sure this is Rice's claim: 
> Rice's theorem states that all non-trivial, semantic properties of 
> programs are undecidable. 
> 
> Since it can be reduced to the HP then:

You are NOT using the verb "reduce" correctly here.
Halting is NOT directly relevant to Rice's Theorem here
since that theorem is a universal generalization about INDIVIDUAL programs,
and the HP is about ALL programs.  I guess you could make it about an
individual program by choosing the UTM as your individual program but that
is still not a "reduction".
Also, in this context, "machine" MEANS *PROGRAM* -- software, NOT hardware --
a distinction that you ARE STILL getting wrong in your talk about
"execution traces" and your delusion about the title-presupposition of this thread.
The rebuttal to the title remains that there is no infinite recursion in
the Linz example.

 

> It becomes a false claim

NO theorem EVER becomes a false claim.  WHAT IN THE HELL is wrong with you??
> when the key semantic property that prevents 
> all other semantic properties from being evaluated 

THERE IS NO SUCH THING in this context.
You don't even know what "semantic property" MEANS here.
"Being self-referential' IS NOT a "semantic property" in this context.
The kind of property that Rice's Theorem is about is the property of
WHAT LANGUAGE the TM accepts.  That language represents a property
in THE ABSTRACT sense -- it is true, false, or undefined of each thing
(SEPARATELY) in the relevant DOMAIN.  It is trivial if it is one of
the above FOR ALL things (simultaneously, the SAME one value) in the
domain.

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


#172046

From"Shobe, Martin" <martin.shobe@yahoo.com>
Date2018-02-06 20:13 -0600
Message-ID<p5dnd5$52g$1@dont-email.me>
In reply to#171988
On 2/5/2018 11:45 PM, peteolcott wrote:
> On Monday, February 5, 2018 at 8:45:10 PM UTC-6, Shobe, Martin wrote:
>> On 2/5/2018 7:22 PM, peteolcott wrote:
>>> On Monday, February 5, 2018 at 6:56:34 PM UTC-6, Shobe, Martin wrote:
>>>> On 2/3/2018 9:51 PM, peteolcott wrote:
>>>>> On Saturday, February 3, 2018 at 8:53:09 PM UTC-6, Shobe, Martin wrote:
>>>>>> On 2/3/2018 2:46 PM, peteolcott wrote:
>>>>>>> On Saturday, February 3, 2018 at 12:17:39 PM UTC-6, Andy Walker wrote:
>>>>>>>> On 02/02/18 21:30, Peter Percival wrote:
>>>>>>>>> Pete Olcott wrote:
>>>>>>>>>> The Halting Problem is about whether or not a TM exists that can decide
>>>>>>>>>> halting for a single TM input pair.
>>>>>>>>> Why not look it up?  It might save you from such silliness.  From a well-known website:
>>>>>>>>>          the halting problem is the problem of determining, from a
>>>>>>>>>          description of an arbitrary computer program and an input,
>>>>>>>>>          whether the program will finish running or continue to run
>>>>>>>>>          forever
>>>>>>>>> Do you see the difference between "a single" and "an arbitrary"?
>>>>>>>>
>>>>>>>> 	Much as I sympathise with the attempts, no doubt doomed, to
>>>>>>>> educate Mr Olcott, the use of "arbitrary" in this context has its
>>>>>>>> own problems.  Almost everyone here knows that we would like to find
>>>>>>>> *one* single TM that correctly determines *every* instance of the HP,
>>>>>>>> and that there is a well-known proof that no such TM exists.  But
>>>>>>>
>>>>>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>>>>>>
>>>>>>> I have been focusing on the above specific example for a long time
>>>>>>> now, and I really believe that I have some brand new insights.
>>>>>>
>>>>>> That would be a wonderful change.
>>>>>>
>>>>>>> These insights are explained most clearly in my most recent reply to Ben.
>>>>>>>
>>>>>>> ∃x ∈ Turing_Machines_Descriptions
>>>>>>> ∀y ∈ Turing_Machine_Descriptions
>>>>>>> ∀z ∈ Finite_Strings Halts(x, y, z)
>>>>>>
>>>>>> Not a new insight. At best, it's a new error. Halt only takes two arguments.
>>>>>>
>>>>>
>>>>> Decidability of the Halting Problem as a David Hilbert formalism
>>>>> ∃x ∈ Turing_Machines_Descriptions
>>>>> ∀y ∈ Turing_Machine_Descriptions
>>>>> ∀z ∈ Finite_Strings
>>>>> Halts(x, y, z) ∨ T~Halts(x, y, z)
>>>>>
>>>>
>>>> So you made the error again.
>>>>
>>>> Martin Shobe
>>>
>>> Your failure you comprehend is not any error on my part.
>>> Its not an error to look at a problem from a different point of view.
>>> As a Math problem it is THREE finite strings and no Turing Machine.
>>>
>>
>> The halting problem is a math problem. It has a TM, a mathematical
>> object and the one whose existence we are investigating, and a string,
>> which encodes a description of a TM and an input to that TM. Anything
>> else is an error.
>>
>> Martin Shobe
> 
> So now you can see that my system of encoding three finite
> strings is a correct alternative way of specifying these things.

I see no such thing since what you did is not a correct alternative way 
of specifying these things.

> Great. My recent reply to Ben in the other thread had some
> key new insights.

Also wrong.

> H simply recognizes the Pathological-Self-Reference(Olcott 2004)
> of [H^][H^] and transitions to its ((qn)) state indicating that
> it rejects the input on the basis that it specifies an infinitely
> recursive evaluation sequence.

Which is the wrong answer as the correct answer was H^ halts on the 
input [H^].

Martin Shobe

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


#171972

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-05 17:45 -0800
Message-ID<c0e8ec8e-d70b-4855-89b9-6e8206891858@googlegroups.com>
In reply to#171835
On Saturday, February 3, 2018 at 10:51:13 PM UTC-5, peteolcott wrote:
> Decidability of the Halting Problem as a David Hilbert formalism 
> ∃x ∈ Turing_Machines_Descriptions
> ∀y ∈ Turing_Machine_Descriptions
> ∀z ∈ Finite_Strings
> Halts(x, y, z) ∨ ~Halts(x, y, z)

The last sentence in particular IS A TAUTOLOGY, YOU MORON,
and therefore was certainly NEVER PART OF ANY "Hilbert formalism".
WHY do you use terms WITHOUT defining them??  Why do you especially
invent things and think that NOBODY WILL CHECK to see that you
don't know what THE FUCK you are talking about?
Finally, Halts DOES NOT TAKE *THREE* parameters, YOU IDIOT.
IT TAKES TWO -- 1 string describing a TM and another string
that is the intended input TO That TM.
It's CALLED "Halts" because it is intended to return the truth value of
"the TM described by the first string halts when run with the second
string as its input".  THERE IS NO room for  a THIRD parameter!!


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


#171882

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-04 17:01 -0800
Message-ID<528e59d3-a0cb-4b65-9b2b-61b01546b859@googlegroups.com>
In reply to#171685
On Thursday, February 1, 2018 at 10:15:32 PM UTC-5, Pete Olcott wrote:
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> 
> None the less when I remove this "non existent" infinite recursion
> H^ correctly decides whether or not one instance of its own TM description
> would halt on another instance of its TM description.

Instances DO NOT MATTER, you idiot.
One Tm given one input string ALWAYS BEHAVES THE SAME on that input string, REGARDLESS OF ANY "instances".  Two "instances" of ONE tm ARE NOT *different*, YOU IDIOT.

You cannot "remove" anything from a TM without CHANGING IT INTO A DIFFERENT tm,
so I don't know WHAT YOU THINK you are removing.  All I noticed was that
your DEFINITION of what a halt decider was is not correct.
THE DEFINITION Is that it takes TWO inputs, NOT just a "TMD" -- one "TMD" AND ONE INPUT STRING *FOR* the TM described by the D -- AND HALTS, ALWAYS, either true if the described TM halts on the supplied input string, AND FALSE OTHERWISE.  The definition DOES NOT INCLUDE ANY of the extraneous detail
that you OH SO IGNORANTLY provided.

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


#171962

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-05 16:44 -0800
Message-ID<5625435d-7771-4215-a5ae-ccbeb699addb@googlegroups.com>
In reply to#171882
On Sunday, February 4, 2018 at 7:01:49 PM UTC-6, George Greene wrote:
> On Thursday, February 1, 2018 at 10:15:32 PM UTC-5, Pete Olcott wrote:
> > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> > 
> > None the less when I remove this "non existent" infinite recursion
> > H^ correctly decides whether or not one instance of its own TM description
> > would halt on another instance of its TM description.
> 
> Instances DO NOT MATTER, you idiot.
> One Tm given one input string ALWAYS BEHAVES THE SAME on that input string, REGARDLESS OF ANY "instances".  Two "instances" of ONE tm ARE NOT *different*, YOU IDIOT.
> 
> You cannot "remove" anything from a TM without CHANGING IT INTO A DIFFERENT tm,

Ben believed that infinite recursion was not specified I
proved that it was specified because the execution trace varies.

Ben is still not paying enough attention to realize that any 
potential halt decider must determine the precise state transition 
sequence of its input TMD at least up to the point where this TMD
gets stuck in an infinite loop or transitions to a final state. 

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


#171971

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-05 17:42 -0800
Message-ID<b920b6f7-98ba-4ff9-819c-a43c95b86e95@googlegroups.com>
In reply to#171962
On Monday, February 5, 2018 at 7:44:16 PM UTC-5, peteolcott wrote:

> Ben believed that infinite recursion was not specified I
> proved that it was specified because the execution trace varies.

Your IGNORANT ASS did NOT prove SHIT.
The execution trace CANNOT vary IF THE PARAMETERS (the input strings)
do not very, and if they do, well, THAT IS NOT looping!  That is NOT
repeating the SAME thing over and over again!  If the invocations are
DIFFERENT (with different input strings) then they may (for all you
know) be getting CLOSER eventually (most of the time) to one that will
eventually halt!

> Ben is still not paying enough attention to realize that any 
> potential halt decider must determine the precise state transition 
> sequence of its input TMD at least up to the point where this TMD
> gets stuck in an infinite loop or transitions to a final state.

There are A GREAT MANY TMs taht determine all the precise state transition
sequence of whatever computation they are emulating, but for sufficiently
complex computations, these same TMs WILL NOT determine OR RECOGNIZE that
the computation they are emulating HAS STARTED AN INFINITE LOOP.
THEY WILL ALL GO AS FAR AS you say they "need" to -- until the infinite
loop has begun -- but THEY WILL NOT KNOW it has begun, SO THEY WILL BE STUCK,
TOO, just like the machine they are emulating is.

All your SHIT about "execution traces" is JUST THAT -- SHIT.
It IS NOT RELEVANT AT ALL to the problem.

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


#171973

Fromgrahamcooper7@gmail.com
Date2018-02-05 18:09 -0800
Message-ID<5159b614-6c93-4dda-936c-5014ad061949@googlegroups.com>
In reply to#171962
On Tuesday, February 6, 2018 at 10:44:16 AM UTC+10, peteolcott wrote:
> On Sunday, February 4, 2018 at 7:01:49 PM UTC-6, George Greene wrote:
> > On Thursday, February 1, 2018 at 10:15:32 PM UTC-5, Pete Olcott wrote:
> > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> > > 
> > > None the less when I remove this "non existent" infinite recursion
> > > H^ correctly decides whether or not one instance of its own TM description
> > > would halt on another instance of its TM description.
> > 
> > Instances DO NOT MATTER, you idiot.
> > One Tm given one input string ALWAYS BEHAVES THE SAME on that input string, REGARDLESS OF ANY "instances".  Two "instances" of ONE tm ARE NOT *different*, YOU IDIOT.
> > 
> > You cannot "remove" anything from a TM without CHANGING IT INTO A DIFFERENT tm,
> 
> Ben believed that infinite recursion was not specified I
> proved that it was specified because the execution trace varies.
> 
> Ben is still not paying enough attention to realize that any 
> potential halt decider must determine the precise state transition 
> sequence of its input TMD at least up to the point where this TMD
> gets stuck in an infinite loop or transitions to a final state.


Then it goes to qYES or qNO


by everybody's agreement

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


#171989

Frompeteolcott <peterolcott2@gmail.com>
Date2018-02-05 21:50 -0800
Message-ID<b633c198-7cf6-4335-83e5-b93c40990693@googlegroups.com>
In reply to#171973
On Monday, February 5, 2018 at 8:09:19 PM UTC-6, graham...@gmail.com wrote:
> On Tuesday, February 6, 2018 at 10:44:16 AM UTC+10, peteolcott wrote:
> > On Sunday, February 4, 2018 at 7:01:49 PM UTC-6, George Greene wrote:
> > > On Thursday, February 1, 2018 at 10:15:32 PM UTC-5, Pete Olcott wrote:
> > > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> > > > 
> > > > None the less when I remove this "non existent" infinite recursion
> > > > H^ correctly decides whether or not one instance of its own TM description
> > > > would halt on another instance of its TM description.
> > > 
> > > Instances DO NOT MATTER, you idiot.
> > > One Tm given one input string ALWAYS BEHAVES THE SAME on that input string, REGARDLESS OF ANY "instances".  Two "instances" of ONE tm ARE NOT *different*, YOU IDIOT.
> > > 
> > > You cannot "remove" anything from a TM without CHANGING IT INTO A DIFFERENT tm,
> > 
> > Ben believed that infinite recursion was not specified I
> > proved that it was specified because the execution trace varies.
> > 
> > Ben is still not paying enough attention to realize that any 
> > potential halt decider must determine the precise state transition 
> > sequence of its input TMD at least up to the point where this TMD
> > gets stuck in an infinite loop or transitions to a final state.
> 
> 
> Then it goes to qYES or qNO
> 
> 
> by everybody's agreement

See my reply to Ben in the other thread. I spent four hours on it. 
H [H^][H^] the input is rejected as semantically incorrect
because it specifies an infinitely recursive evaluation sequence. 
I have been saying this since at least 2004, and now I can show it. 

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


#171556

From"Shobe, Martin" <martin.shobe@yahoo.com>
Date2018-01-31 19:57 -0600
Message-ID<p4ts5h$fls$2@dont-email.me>
In reply to#171537
On 1/31/2018 4:21 PM, Pete Olcott wrote:
> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>> peteolcott <peterolcott2@gmail.com> writes:
>>>>
>> <snip>
>>>>> If we create a machine specification that counts the characters
>>>>> of strings and a string of infinite length is provided as input
>>>>> we cannot expect this machine to halt on every input.
>>>>
>>>> That's wrong in so many ways.  No TM is ever provided with a string of
>>>> infinite length (a good book will tell you this).  A TM might construct
>>>> a string that never ends, but that's not the same thing.
>>>
>>> It is sufficiently analogous. If a TM is provided with a problem that
>>> specifies infinite recursion then a David Hilbert finite string
>>> formalization of this problem inherently requires infinite recursion.
>>>
>>> This is an analogous idea to a TM that counts the characters of a string
>>> and would otherwise halt except in the case where this string is (for
>>> all practical purpose) infinite.
>>
>> There is no "for all practical purposes" here.  TMs can not be provided
>> with infinite input.  The input is always finite.
>>
> 
> So it is an analytical impossibility for a TM to be defined to count
> the number of times that another TM moves its read write head when
> this other TM has been defined to write the result of doubling the
> integer value of 2, an infinite number of times?

Why would you think its impossible for a TM to write "aleph_0"?

Martin Shobe

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


#171620

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-02-01 11:02 -0800
Message-ID<cb7fef16-166a-482d-ab87-77b5ae8fe0c9@googlegroups.com>
In reply to#171537
On Wednesday, January 31, 2018 at 5:21:40 PM UTC-5, Pete Olcott wrote:
> So it is an analytical impossibility for a TM to be defined to count
> the number of times that another TM moves its read write head when
> this other TM has been defined to write the result of doubling the
> integer value of 2, an infinite number of times?

How is it even possible for any TM to write that result?
The result of doubling 2 an infinite number of times IS NOT a natural number!
You would first have to have A NOTATION CONVENTION *FOR* writing out that
number!

By default, the convention is that the inputs are finite, and if the machine
halts, the outputs ARE THEREFORE NECESSARILY finite also.

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


#171547

FromPete Olcott <Pete@NoEmail.address>
Date2018-01-31 19:10 -0600
Message-ID<kaSdnS4MwO6a9O_HnZ2dnUU7-enNnZ2d@giganews.com>
In reply to#171531
On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>> peteolcott <peterolcott2@gmail.com> writes:
>>>
> <snip>
>>>> If we create a machine specification that counts the characters
>>>> of strings and a string of infinite length is provided as input
>>>> we cannot expect this machine to halt on every input.
>>>
>>> That's wrong in so many ways.  No TM is ever provided with a string of
>>> infinite length (a good book will tell you this).  A TM might construct
>>> a string that never ends, but that's not the same thing.
>>
>> It is sufficiently analogous. If a TM is provided with a problem that
>> specifies infinite recursion then a David Hilbert finite string
>> formalization of this problem inherently requires infinite recursion.
>>
>> This is an analogous idea to a TM that counts the characters of a string
>> and would otherwise halt except in the case where this string is (for
>> all practical purpose) infinite.
> 
> There is no "for all practical purposes" here.  TMs can not be provided
> with infinite input.  The input is always finite.
> 
> I don't know why you want to keep defending this minor mistake because
> your argument incorrect though it is, does not depend on a TM being
> given an infinite input string.
> 
> We all know that some finite input strings can cause some TMs to loop
> without end.
> 
> <snip>
>>>> H^ can only decide if w^ halts on it input w^2
>>>> on the basis of w^2 halting on its input w^3...
>>>
>>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>>> the very last state).  The H (or the copy of H -- you decide which view
>>> you take) which is embedded in H^ must simply do what it does with any
>>> input it is asked to "decide".
>>
>> It lacks sufficient information to decide.
>> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
>> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>>
>> If it is not infinitely recursive (and it is) then w^ would simply decide
>> that w^2 halts on its NULL input. The H^ decides that this will cause w^
>> to loop so it simply transitions to ((qn)).
> 
> No.  I won't explain again because you are not listening.  Your words
> have all sort of errors (H^ is not a decider so it does not decide
> anything, w^ is a string so it can not loop, and so on) but I'm just
> glossing over those -- you no longer care about details.
> 
>>> You can't (and mustn't) say anything
>>> about how it does that, but you *can* be sure that state qy or qn is
>>> reached in a finite number of steps.  That's because, however it does
>>> it, it is a decider.
>>
>> Making that assumption turns out to be exactly analogous to being certain
>> that the Liar Paradox must be True or False.
> 
> I don't care about your analogies -- mathematics requires stronger
> arguments than "it's like this other thing".  Provided you accept that
> the assumption must go we are in agreement.  As a result, I suspect you
> will have to say you misspoke here.  Do you, in fact, agree that the
> assumption made at the start of the proof must be wrong?
> 
>>> The one thing that H^ can not do from state qx on is what you are
>>> assuming it does, and that is to "run" (or emulate or evaluate) its
>>
>> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
>> All math expressions are evaluated, that is how math works.
> 
> No, that is not how maths works, but going into that would derail the
> whole thread.
> 

(G1) F ⊢ GF ↔ ¬ProvF(⌈GF⌉).
(G2) F ⊢ GF ↔ ¬ProvF(GF).
G2 is precisely analogous to G1 such that showing G2 is erroneous shows that G1 is erroneous.

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


#171554

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-01 01:51 +0000
Message-ID<87vafha34w.fsf@bsb.me.uk>
In reply to#171547
Pete Olcott <Pete@NoEmail.address> writes:

> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>> peteolcott <peterolcott2@gmail.com> writes:
<snip>
>>>>> H^ can only decide if w^ halts on it input w^2
>>>>> on the basis of w^2 halting on its input w^3...
>>>>
>>>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>>>> the very last state).  The H (or the copy of H -- you decide which view
>>>> you take) which is embedded in H^ must simply do what it does with any
>>>> input it is asked to "decide".
>>>
>>> It lacks sufficient information to decide.
>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>>>
>>> If it is not infinitely recursive (and it is) then w^ would simply decide
>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^
>>> to loop so it simply transitions to ((qn)).
>>
>> No.  I won't explain again because you are not listening.  Your words
>> have all sort of errors (H^ is not a decider so it does not decide
>> anything, w^ is a string so it can not loop, and so on) but I'm just
>> glossing over those -- you no longer care about details.
>>
>>>> You can't (and mustn't) say anything
>>>> about how it does that, but you *can* be sure that state qy or qn is
>>>> reached in a finite number of steps.  That's because, however it does
>>>> it, it is a decider.
>>>
>>> Making that assumption turns out to be exactly analogous to being certain
>>> that the Liar Paradox must be True or False.
>>
>> I don't care about your analogies -- mathematics requires stronger
>> arguments than "it's like this other thing".  Provided you accept that
>> the assumption must go we are in agreement.  As a result, I suspect you
>> will have to say you misspoke here.  Do you, in fact, agree that the
>> assumption made at the start of the proof must be wrong?

You very often don't answer questions but it's a shame here because
this was a possible point of agreement.  Do you agree that the
assumption made at the start of the proof must be wrong?  You certainly
seem to be rejecting it.

>>>> The one thing that H^ can not do from state qx on is what you are
>>>> assuming it does, and that is to "run" (or emulate or evaluate) its
>>>
>>> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
>>> All math expressions are evaluated, that is how math works.
>>
>> No, that is not how maths works, but going into that would derail the
>> whole thread.
>
> (G1) F ⊢ GF ↔ ¬ProvF(⌈GF⌉).
> (G2) F ⊢ GF ↔ ¬ProvF(GF).
> G2 is precisely analogous to G1 such that showing G2 is erroneous
> shows that G1 is erroneous.

The argument you presented has an error which I pointed out.  You have
not addressed it (and I don't mind that) but you have not even responded
to a simple request for a clarification.  I think you've entered "post
any old answer" mode now so I expect you will soon be gone for a
while...

-- 
Ben.

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


#171672

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-01 19:24 -0600
Message-ID<14ednXhfKuxYIO7HnZ2dnUU7-SHNnZ2d@giganews.com>
In reply to#171554
On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>>> peteolcott <peterolcott2@gmail.com> writes:
> <snip>
>>>>>> H^ can only decide if w^ halts on it input w^2
>>>>>> on the basis of w^2 halting on its input w^3...
>>>>>
>>>>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>>>>> the very last state).  The H (or the copy of H -- you decide which view
>>>>> you take) which is embedded in H^ must simply do what it does with any
>>>>> input it is asked to "decide".
>>>>
>>>> It lacks sufficient information to decide.
>>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
>>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>>>>
>>>> If it is not infinitely recursive (and it is) then w^ would simply decide
>>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^
>>>> to loop so it simply transitions to ((qn)).
>>>
>>> No.  I won't explain again because you are not listening.  Your words
>>> have all sort of errors (H^ is not a decider so it does not decide
>>> anything, w^ is a string so it can not loop, and so on) but I'm just
>>> glossing over those -- you no longer care about details.
>>>
>>>>> You can't (and mustn't) say anything
>>>>> about how it does that, but you *can* be sure that state qy or qn is
>>>>> reached in a finite number of steps.  That's because, however it does
>>>>> it, it is a decider.
>>>>
>>>> Making that assumption turns out to be exactly analogous to being certain
>>>> that the Liar Paradox must be True or False.
>>>
>>> I don't care about your analogies -- mathematics requires stronger
>>> arguments than "it's like this other thing".  Provided you accept that
>>> the assumption must go we are in agreement.  As a result, I suspect you
>>> will have to say you misspoke here.  Do you, in fact, agree that the
>>> assumption made at the start of the proof must be wrong?
> 
> You very often don't answer questions but it's a shame here because
> this was a possible point of agreement.  Do you agree that the
> assumption made at the start of the proof must be wrong?  You certainly
> seem to be rejecting it.
> 
>>>>> The one thing that H^ can not do from state qx on is what you are
>>>>> assuming it does, and that is to "run" (or emulate or evaluate) its
>>>>
>>>> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
>>>> All math expressions are evaluated, that is how math works.
>>>
>>> No, that is not how maths works, but going into that would derail the
>>> whole thread.
>>
>> (G1) F ⊢ GF ↔ ¬ProvF(⌈GF⌉).
>> (G2) F ⊢ GF ↔ ¬ProvF(GF).
>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>> shows that G1 is erroneous.
> 
> The argument you presented has an error which I pointed out.  You have
> not addressed it (and I don't mind that) but you have not even responded
> to a simple request for a clarification.  I think you've entered "post
> any old answer" mode now so I expect you will soon be gone for a
> while...
> 

OK F is not expressive enough to have a provability predicate so I will use H.

(G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
(G2) H ⊢ GH ↔ ¬ProvF(GH).
G2 is precisely analogous to G1 such that showing G2 is erroneous shows that G1 is erroneous. ---

G1 can include all of the original proof because H includes F as a subset.
G2 can be expressed 100,000-fold more simply thus not totally obscuring key details.


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

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


#171675

Fromgrahamcooper7@gmail.com
Date2018-02-01 17:34 -0800
Message-ID<f388124a-a612-4ad3-af08-32dbed0b935c@googlegroups.com>
In reply to#171672
On Friday, February 2, 2018 at 11:24:28 AM UTC+10, Pete Olcott wrote:
>obscuring key details.
> 



You dont understand PROOF BY CONTRADICTION



ASSUME SOMETHING

FIND A COUNTEREXAMPLE







YOU CANT CHANGE THE COUNTEREXAMPLE

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


#171680

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-02 02:04 +0000
Message-ID<87607g406h.fsf@bsb.me.uk>
In reply to#171672
Pete Olcott <Pete@NoEmail.address> writes:

> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>>
>>>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>>>> peteolcott <peterolcott2@gmail.com> writes:
>> <snip>
>>>>>>> H^ can only decide if w^ halts on it input w^2
>>>>>>> on the basis of w^2 halting on its input w^3...
>>>>>>
>>>>>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>>>>>> the very last state).  The H (or the copy of H -- you decide which view
>>>>>> you take) which is embedded in H^ must simply do what it does with any
>>>>>> input it is asked to "decide".
>>>>>
>>>>> It lacks sufficient information to decide.
>>>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
>>>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>>>>>
>>>>> If it is not infinitely recursive (and it is) then w^ would simply decide
>>>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^
>>>>> to loop so it simply transitions to ((qn)).
>>>>
>>>> No.  I won't explain again because you are not listening.  Your words
>>>> have all sort of errors (H^ is not a decider so it does not decide
>>>> anything, w^ is a string so it can not loop, and so on) but I'm just
>>>> glossing over those -- you no longer care about details.
>>>>
>>>>>> You can't (and mustn't) say anything
>>>>>> about how it does that, but you *can* be sure that state qy or qn is
>>>>>> reached in a finite number of steps.  That's because, however it does
>>>>>> it, it is a decider.
>>>>>
>>>>> Making that assumption turns out to be exactly analogous to being certain
>>>>> that the Liar Paradox must be True or False.
>>>>
>>>> I don't care about your analogies -- mathematics requires stronger
>>>> arguments than "it's like this other thing".  Provided you accept that
>>>> the assumption must go we are in agreement.  As a result, I suspect you
>>>> will have to say you misspoke here.  Do you, in fact, agree that the
>>>> assumption made at the start of the proof must be wrong?
>>
>> You very often don't answer questions but it's a shame here because
>> this was a possible point of agreement.  Do you agree that the
>> assumption made at the start of the proof must be wrong?  You certainly
>> seem to be rejecting it.
>>
>>>>>> The one thing that H^ can not do from state qx on is what you are
>>>>>> assuming it does, and that is to "run" (or emulate or evaluate) its
>>>>>
>>>>> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
>>>>> All math expressions are evaluated, that is how math works.
>>>>
>>>> No, that is not how maths works, but going into that would derail the
>>>> whole thread.
>>>
>>> (G1) F ⊢ GF ↔ ¬ProvF(⌈GF⌉).
>>> (G2) F ⊢ GF ↔ ¬ProvF(GF).
>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>>> shows that G1 is erroneous.
>>
>> The argument you presented has an error which I pointed out.  You have
>> not addressed it (and I don't mind that) but you have not even responded
>> to a simple request for a clarification.  I think you've entered "post
>> any old answer" mode now so I expect you will soon be gone for a
>> while...
>
> OK F is not expressive enough to have a provability predicate so I will use H.
>
> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
> (G2) H ⊢ GH ↔ ¬ProvF(GH).
> G2 is precisely analogous to G1 such that showing G2 is erroneous
> shows that G1 is erroneous. ---

You made incorrect statements about a well-know proof.  I pointed out
why they were wrong.  Do you retract them?  They are still on your blog
(along with some more new errors).

-- 
Ben.

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


#171687

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-01 21:31 -0600
Message-ID<1sadnd1pYfY6Ru7HnZ2dnUU7-TfNnZ2d@giganews.com>
In reply to#171680
On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>>>
>>>>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>>>>> peteolcott <peterolcott2@gmail.com> writes:
>>> <snip>
>>>>>>>> H^ can only decide if w^ halts on it input w^2
>>>>>>>> on the basis of w^2 halting on its input w^3...
>>>>>>>
>>>>>>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>>>>>>> the very last state).  The H (or the copy of H -- you decide which view
>>>>>>> you take) which is embedded in H^ must simply do what it does with any
>>>>>>> input it is asked to "decide".
>>>>>>
>>>>>> It lacks sufficient information to decide.
>>>>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
>>>>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>>>>>>
>>>>>> If it is not infinitely recursive (and it is) then w^ would simply decide
>>>>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^
>>>>>> to loop so it simply transitions to ((qn)).
>>>>>
>>>>> No.  I won't explain again because you are not listening.  Your words
>>>>> have all sort of errors (H^ is not a decider so it does not decide
>>>>> anything, w^ is a string so it can not loop, and so on) but I'm just
>>>>> glossing over those -- you no longer care about details.
>>>>>
>>>>>>> You can't (and mustn't) say anything
>>>>>>> about how it does that, but you *can* be sure that state qy or qn is
>>>>>>> reached in a finite number of steps.  That's because, however it does
>>>>>>> it, it is a decider.
>>>>>>
>>>>>> Making that assumption turns out to be exactly analogous to being certain
>>>>>> that the Liar Paradox must be True or False.
>>>>>
>>>>> I don't care about your analogies -- mathematics requires stronger
>>>>> arguments than "it's like this other thing".  Provided you accept that
>>>>> the assumption must go we are in agreement.  As a result, I suspect you
>>>>> will have to say you misspoke here.  Do you, in fact, agree that the
>>>>> assumption made at the start of the proof must be wrong?
>>>
>>> You very often don't answer questions but it's a shame here because
>>> this was a possible point of agreement.  Do you agree that the
>>> assumption made at the start of the proof must be wrong?  You certainly
>>> seem to be rejecting it.
>>>
>>>>>>> The one thing that H^ can not do from state qx on is what you are
>>>>>>> assuming it does, and that is to "run" (or emulate or evaluate) its
>>>>>>
>>>>>> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
>>>>>> All math expressions are evaluated, that is how math works.
>>>>>
>>>>> No, that is not how maths works, but going into that would derail the
>>>>> whole thread.
>>>>
>>>> (G1) F ⊢ GF ↔ ¬ProvF(⌈GF⌉).
>>>> (G2) F ⊢ GF ↔ ¬ProvF(GF).
>>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>>>> shows that G1 is erroneous.
>>>
>>> The argument you presented has an error which I pointed out.  You have
>>> not addressed it (and I don't mind that) but you have not even responded
>>> to a simple request for a clarification.  I think you've entered "post
>>> any old answer" mode now so I expect you will soon be gone for a
>>> while...
>>
>> OK F is not expressive enough to have a provability predicate so I will use H.
>>
>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
>> (G2) H ⊢ GH ↔ ¬ProvF(GH).
>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>> shows that G1 is erroneous. ---
> 
> You made incorrect statements about a well-know proof.  I pointed out
> why they were wrong.  Do you retract them?  They are still on your blog
> (along with some more new errors).
> 

Can you be more evasive? If you try really hard I think that you can.
In any case we are not talking about my blog we are talking about the above two formulas.

When-so-ever I am correct you dodge because there is no rebuttal for correct statements
and you are only interested in rebuttal. This of course would be a form of dishonesty.

If you are not intending to be dishonest then I challenge you to accurately critique my
words regarding G1 and G2. If you dodge this it will confirm dishonest intent.

If you are a Christian you will be aware that a dishonest intent aligns you with the father of all lies.

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

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


#171689

Fromgrahamcooper7@gmail.com
Date2018-02-01 19:43 -0800
Message-ID<0ee3e5ac-75c8-4dec-9e21-94ef776db12e@googlegroups.com>
In reply to#171687
On Friday, Pete Olcott wrote:
>If you dodge this it will confirm dishonest intent.
> 
> If you are a Christian you will be aware that a dishonest intent aligns you with the father of all lies.


PETER:   THERE EXISTS A HALT FUNCTION!

LOGIC:   *THEN* THERE WOULD EXIST H^ (as specified)

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


#171730

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

> On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
<snip>
>>>> The argument you presented has an error which I pointed out.  You have
>>>> not addressed it (and I don't mind that) but you have not even responded
>>>> to a simple request for a clarification.  I think you've entered "post
>>>> any old answer" mode now so I expect you will soon be gone for a
>>>> while...
>>>
>>> OK F is not expressive enough to have a provability predicate so I will use H.
>>>
>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
>>> (G2) H ⊢ GH ↔ ¬ProvF(GH).
>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>>> shows that G1 is erroneous. ---
>>
>> You made incorrect statements about a well-know proof.  I pointed out
>> why they were wrong.  Do you retract them?  They are still on your blog
>> (along with some more new errors).
>
> Can you be more evasive? If you try really hard I think that you can.

I have been as direct as I can be.  You have not addressed the error I
pointed out.

> In any case we are not talking about my blog we are talking about the
> above two formulas.

No, I'm not talking about them.  I am still talking about the error you
are avoiding.  You have no addressed it.  I mention your blog only
because you keep posting the reference and you've stopped talking about
the error here.

Instead you've decided to write these new math-poems.  I am sure the
errors they contain will be of interest to someone else, but I am still
interested in the mistakes you made before and have not yet corrected.

The halting theorem proof you think is wrong is sound.  The argument you
used to show that it is wrong is incorrect for the reasons I gave.  If
you don't want to talk about it anymore so be it.  I can understand that
perfectly well.

<attempts at insults removed>
-- 
Ben.

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


#171734

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-02 17:54 -0600
Message-ID<9sGdna25K7-GZ-nHnZ2dnUU7-T3NnZ2d@giganews.com>
In reply to#171730
On 2/2/2018 3:38 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
> <snip>
>>>>> The argument you presented has an error which I pointed out.  You have
>>>>> not addressed it (and I don't mind that) but you have not even responded
>>>>> to a simple request for a clarification.  I think you've entered "post
>>>>> any old answer" mode now so I expect you will soon be gone for a
>>>>> while...
>>>>
>>>> OK F is not expressive enough to have a provability predicate so I will use H.
>>>>
>>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
>>>> (G2) H ⊢ GH ↔ ¬ProvF(GH).
>>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>>>> shows that G1 is erroneous. ---
>>>
>>> You made incorrect statements about a well-know proof.  I pointed out
>>> why they were wrong.  Do you retract them?  They are still on your blog
>>> (along with some more new errors).
>>
>> Can you be more evasive? If you try really hard I think that you can.
> 
> I have been as direct as I can be.  You have not addressed the error I
> pointed out.
> 
>> In any case we are not talking about my blog we are talking about the
>> above two formulas.
> 
> No, I'm not talking about them.  I am still talking about the error you
> are avoiding.  You have no addressed it.  I mention your blog only
> because you keep posting the reference and you've stopped talking about
> the error here.

Then be completely specific about the error on the blog, I have at least
forty blog posts, and so far the closest you came to pointing out any error
was a vague assertion that I made some mistake somewhere.

The reason that you have to stick with vague assertions and cannot
point out a specific mistake and why it is a mistake is that there is
no mistake at all.

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


#171735

Fromgrahamcooper7@gmail.com
Date2018-02-02 16:08 -0800
Message-ID<fcac4a15-157a-45a3-b63f-7d1f826cdd48@googlegroups.com>
In reply to#171734
On Saturday, February 3, 2018 at 9:54:10 AM UTC+10, Pete Olcott wrote:
> On 2/2/2018 3:38 PM, Ben Bacarisse wrote:
> > Pete Olcott <Pete@NoEmail.address> writes:
> > 
> >> On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
> >>> Pete Olcott <Pete@NoEmail.address> writes:
> >>>
> >>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
> > <snip>
> >>>>> The argument you presented has an error which I pointed out.  You have
> >>>>> not addressed it (and I don't mind that) but you have not even responded
> >>>>> to a simple request for a clarification.  I think you've entered "post
> >>>>> any old answer" mode now so I expect you will soon be gone for a
> >>>>> while...
> >>>>
> >>>> OK F is not expressive enough to have a provability predicate so I will use H.
> >>>>
> >>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
> >>>> (G2) H ⊢ GH ↔ ¬ProvF(GH).
> >>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
> >>>> shows that G1 is erroneous. ---
> >>>
> >>> You made incorrect statements about a well-know proof.  I pointed out
> >>> why they were wrong.  Do you retract them?  They are still on your blog
> >>> (along with some more new errors).
> >>
> >> Can you be more evasive? If you try really hard I think that you can.
> > 
> > I have been as direct as I can be.  You have not addressed the error I
> > pointed out.
> > 
> >> In any case we are not talking about my blog we are talking about the
> >> above two formulas.
> > 
> > No, I'm not talking about them.  I am still talking about the error you
> > are avoiding.  You have no addressed it.  I mention your blog only
> > because you keep posting the reference and you've stopped talking about
> > the error here.
> 
> Then be completely specific about the error on the blog, 


(2) At qx Ĥ begins to evaluate what ŵ would do on its input ŵ2.

 Execution trace of Ĥ analysis of finite string ŵ
 (3) At q0 ŵ would make a copy of its input, we will call this copy ŵ3.



Evaluate =/= Execute

It is the JOB of HALT (part of H^) to DETECT an infinite LOOP and NOT HAVE TO RUN the test program that is input.  It just OUTPUTS '0' if it detects a loop.






> I have at least
> forty blog posts, and so far the closest you came to pointing out any error
> was a vague assertion that I made some mistake somewhere.
> 
> The reason that you have to stick with vague assertions and cannot
> point out a specific mistake and why it is a mistake is that there is
> no mistake at all.


ASSUME:  HALT(,) EXISTS

ASSUME:  H^() EXISTS

CONTRADICTION!



DEFINITION:  H^ = TM_PREFIX + HALT + TM_POSTFIX


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


Page 5 of 6 — ← Prev page 1 2 3 4 [5] 6  Next page →

Back to top | Article view | sci.logic


csiph-web