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


Groups > comp.theory > #11910 > unrolled thread

Infinitely Recursive input on HP Proofs

Started bypeteolcott <peteolcott@gmail.com>
First post2017-03-11 13:13 -0800
Last post2018-02-15 12:25 -0600
Articles 20 on this page of 118 — 9 participants

Back to article view | Back to comp.theory


Contents

  Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-11 13:13 -0800
    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-12 11:25 +0000
      Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-12 10:58 -0700
        Re: Infinitely Recursive input on HP Proofs Kaz Kylheku <336-986-7787@kylheku.com> - 2017-03-12 19:34 +0000
          Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-13 07:23 -0700
            Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 08:46 -0700
          Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 12:17 -0700
            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-15 20:40 +0000
              Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 14:01 -0700
                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 14:09 +0000
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-16 09:53 -0700
                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 21:54 +0000
                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-17 07:09 -0700
                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 01:39 +0000
                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-18 05:40 -0700
                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 15:35 +0000
                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-18 12:52 -0700
                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 21:35 +0000
                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-20 07:16 -0700
                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-20 18:07 +0000
                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-21 05:03 -0700
                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-21 19:47 +0000
                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-22 05:35 -0700
                                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-22 16:41 +0000
                                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-23 06:24 -0700
                                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-25 01:11 +0000
                                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-25 08:09 -0700
                                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-25 21:58 +0000
                                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-27 06:18 -0700
                                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-27 22:20 +0100
                                                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-28 15:33 -0700
                                                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-29 01:29 +0100
                                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-25 19:57 -0700
                                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-26 23:53 +0100
        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-13 03:14 +0000
          Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-13 07:23 -0700
            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-15 17:12 +0000
              Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 13:56 -0700
                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 03:23 +0000
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 21:22 -0700
                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 10:19 +0000
                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-16 09:26 -0700
                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 22:00 +0000
                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-17 07:17 -0700
              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-28 10:20 -0700
                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-29 01:18 +0100
                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-29 10:09 -0700
                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-01 02:55 +0100
                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-01 05:30 -0700
                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-02 00:50 +0100
                          Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-01 19:10 -0700
                            Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-02 03:19 +0100
                              Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-03 06:28 -0700
                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-04 01:27 +0100
                                  Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-09 21:41 -0700
                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-10 14:35 +0100
                                      Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-10 13:58 -0700
                                        Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-11 00:58 +0100
                                          Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2017-04-10 20:29 -0500
                                            Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-29 14:29 -0500
                                            Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-29 14:45 -0500
                                              Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 13:23 -0500
                                                Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-30 23:05 +0100
                                                  Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 18:43 -0500
                                                    Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-05-01 13:45 +0100
                                              Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 13:24 -0500
                                        Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2017-04-27 21:16 +0100
              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 Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:14 -0600
                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 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-03 00:38 -0600
                        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 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 Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:15 -0600
                    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 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 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 peteolcott <peterolcott2@gmail.com> - 2017-03-25 19:56 -0700
    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 00:18 -0600
      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 13:06 +0000
        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 16:55 -0600
          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 00:30 +0000
            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 19:38 -0600
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 02:27 +0000
          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-14 22:55 +0000
            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 17:22 -0600
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 21:00 -0600
                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-15 21:38 +0000
                  Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:27 -0600
                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:34 -0600
                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 00:15 +0000
                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 18:43 -0600
                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 01:05 +0000
                          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 19:37 -0600
                            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 02:34 +0000
                              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 20:51 -0600
                                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 03:32 +0000
                                  Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 22:42 -0600
                                    Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 12:06 +0000
                                      Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 10:26 -0600
                                        Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 20:42 +0000
                                          Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 17:48 -0600
                                            Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-17 01:33 +0000
                                              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-19 15:48 +0000
                                              Re: Infinitely Recursive input on HP Proofs (Final Solution?) David Kleinecke <dkleinecke@gmail.com> - 2018-02-22 12:40 -0800
                                                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-22 15:31 -0600
              Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-15 12:24 +0000
                Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 12:25 -0600

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


#12515

FromPeter Percival <peterxpercival@hotmail.com>
Date2018-02-02 21:30 +0000
Message-ID<p52l8v$ods$1@news.albasani.net>
In reply to#12511
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"?

But in any case, isn't this all about Linz's book which you have?  And 
it surely says what the halting problem is.

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


#12518

FromAndy Walker <anw@cuboid.co.uk>
Date2018-02-03 18:17 +0000
Message-ID<p54ubv$1spq$1@gioia.aioe.org>
In reply to#12515
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
there are several related problems with which that can be confused,
because "arbitrary" could here also mean "pick one" [and don't bother
with all the others], or "pick *this* but not *that*, because *that*
is not arbitrary but has been carefully chosen" [to defeat a proposed
halt decider, or to be recursive, or whatever].

	Either of these seems to be close to what Mr Olcott has been
struggling with lo! these many years, at different times.

	Two mini-anecdotes:

  -- A former colleague tried to run a supplementary maths course for
     some engineers who were having difficulties with complex analysis.
     The course collapsed because he was unable to convince them that
     it could matter that something worked everywhere bar one single
     solitary point.  They knew that 1/r couldn't be used when r == 0,
     but couldn't square that in their minds with Cauchy's Theorem.

  -- I was invited to comment on the minutes of a recent meeting, and
     the secretary had written "One can [blah]."  I pointed out that it
     was unclear, both as a matter of English and in the specific case
     to hand, whether this meant "Everyone can ...", or "Anyone can ..."
     or "Someone can ...", and was met by incomprehension.  This sort
     of problem is not well-understood by mpm-mathematicians.

-- 
Andy Walker,
Nottingham.

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


#12519

FromAndy Walker <anw@cuboid.co.uk>
Date2018-02-03 18:42 +0000
Message-ID<p54vr2$1v48$1@gioia.aioe.org>
In reply to#12518
On 03/02/18 18:17, I wrote:
>  This sort of problem is not well-understood by mpm-mathematicians.

	Nor, for that matter, by non-mathematicians.

-- 
Andy Walker,
Nottingham.

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


#12550

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-08 18:44 -0600
Message-ID<I5adnfULwsiUcuHHnZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#12518
On 2/8/2018 3:05 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/7/2018 10:27 AM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 2/6/2018 9:49 PM, Ben Bacarisse wrote:
>>>>> peteolcott <peterolcott2@gmail.com> writes:
>>>>> <snip>
>>>>>> 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:
>>>>>>
>>>>>> It becomes a false claim when the key semantic property that prevents
>>>>>> all other semantic properties from being evaluated is itself correctly
>>>>>> evaluated.
>>>>>
>>>>> What?  The validity of a theorem is not contingent on random words you
>>>>> post on Usenet.  It's validity depends on the published proofs.  They
>>>>> are correct.
>>>>
>>>> The validity of any theorem is ultimately dependent upon all of the
>>>> details of the underlying semantics.
>>>
>>> No.
>>
>> So for example if the semantic consequence of a famous theorem
>> is contradictory, then you are saying that all is well because
>> it is only the syntax that counts?
> 
> For the theorem to be a theorem, yes.
> 
> That's not to say the semantics don't count for other reasons.  For
> example, there are "machines" (models of computation, TM variations and
> so on) for which halting is decidable.  These crop up in textbooks and
> are of theoretical interest but they don't "model" the sort of program
> we write.  Turing machines (and all the other equivalent models) are so
> extensively studied because the semantics match the semantics of the
> program we actually write (except when a program runs out of storage, of
> course).
> 
> All of this nonsense could end right here if you said that you now see
> that a proof is an essentially syntactic construct and that, therefore,
> you accept the proof.  You can then "reformulate the essential nature of
> truth" so that these (syntactic) facts about TMs not longer trouble you.
> 

Because a proof is a syntactic construct and very little semantics
has ever been fully formalized syntactic formal proofs can have very
large inference gaps.

This causes syntactic proofs to form conclusions that contradict the
results derived though semantic inference chains.

I have recently shown that it is impossible for any language (formal
or otherwise to have any statements of this language that cannot be
proved or disproved within this language.

∀L ∈ Formal_Systems
∀Y ⊆ WFF(L)
∀X
Statement(L,Y,X) → ( Provable(L, Y, X) ∨ Refutable(L, Y, X) )

I provide a sketch of the reasoning that supports the above
formal statement below, very informally. I wrote it so that
non technical people could verify my proof.

>>>> The reason that my approach
>>>> seems so weird is that I go directly to this underlying semantics
>>>> not bothering to carefully learn all of the conventional misconceptions
>>>> along the way.
>>>
>>> That not why it's weird, it's why its irrelevant.
>>>
>>> But if you want to write puff pieces about the meaning of these theorems
>>> go ahead.  No one cares.  (That is what you were doing a few years ago.)
>>
>> http://liarparadox.org/index.php/2018/02/08/the-nature-of-truth-in-plain-english/
>>
>> By doing it this way I am reformulating the essential nature of truth
>> such that my reformulation eliminates all of the extremely subtle
>> semantic incoherence that was expressly defined to form the essential
>> nature of the existing terms of the art.
> 
> You reformulation of truth is of no interest to me, particularly if you
> keep it way from Usenet.  I have always tried to limit my posts to
> correcting errors in the posts you make.  That is the extent of my
> interest.
> 

http://liarparadox.org/index.php/2018/02/08/the-nature-of-truth-in-plain-english/

The Nature of Analytic Truth in Plain English

A Statement in English is only known to be True when it is established
to be a Verified Fact. Analytical expressions of language are completely
verified as True entirely based on the meaning of their words.

A Base analytical fact is an expression of language defined to be True.

To prove that an expression of language is an Analytical Fact we confirm
that there is a correct line-of-reasoning from one or more Base Analytical
Facts that make this expression necessarily True.

Since every Statement of language must be True or False and this is
verified by proving that the statement is a Analytical Fact or
contradicts an Analytical Fact all Statements of language can always
be proved or disproved.

---------------------------------------------------
This is the ultimate foundation of all analytic Truth:
Some expressions of language are defined to be True.

∀L ∈ Formal_Systems
∀X ∈ Base_Analytical_Fact(L) → True(X)

As a David Hilbert Formalist approach Base Analytical Facts are
members of a set of set of finite strings that have been defined
to have the semantic property of True.

An expression X of language L (formal or natural) is only verified
to be a statement of L iff there exists a chain-of-inference from
(one or more) base analytical fact(s) confirming that X is necessarily
True or necessarily False in L.

Copyright 2017, 2018 Pete Olcott

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

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


#12552

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-09 11:08 +0000
Message-ID<87372actdi.fsf@bsb.me.uk>
In reply to#12550
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/8/2018 3:05 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>>
>>> On 2/7/2018 10:27 AM, Ben Bacarisse wrote:
>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>>
>>>>> On 2/6/2018 9:49 PM, Ben Bacarisse wrote:
>>>>>> peteolcott <peterolcott2@gmail.com> writes:
>>>>>> <snip>
>>>>>>> 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:
>>>>>>>
>>>>>>> It becomes a false claim when the key semantic property that prevents
>>>>>>> all other semantic properties from being evaluated is itself correctly
>>>>>>> evaluated.
>>>>>>
>>>>>> What?  The validity of a theorem is not contingent on random words you
>>>>>> post on Usenet.  It's validity depends on the published proofs.  They
>>>>>> are correct.
>>>>>
>>>>> The validity of any theorem is ultimately dependent upon all of the
>>>>> details of the underlying semantics.
>>>>
>>>> No.
>>>
>>> So for example if the semantic consequence of a famous theorem
>>> is contradictory, then you are saying that all is well because
>>> it is only the syntax that counts?
>>
>> For the theorem to be a theorem, yes.
>>
>> That's not to say the semantics don't count for other reasons.  For
>> example, there are "machines" (models of computation, TM variations and
>> so on) for which halting is decidable.  These crop up in textbooks and
>> are of theoretical interest but they don't "model" the sort of program
>> we write.  Turing machines (and all the other equivalent models) are so
>> extensively studied because the semantics match the semantics of the
>> program we actually write (except when a program runs out of storage, of
>> course).
>>
>> All of this nonsense could end right here if you said that you now see
>> that a proof is an essentially syntactic construct and that, therefore,
>> you accept the proof.  You can then "reformulate the essential nature of
>> truth" so that these (syntactic) facts about TMs not longer trouble you.
>
> Because a proof is a syntactic construct and very little semantics
> has ever been fully formalized syntactic formal proofs can have very
> large inference gaps.

No.  In particular there is no inference gap in the theorem you are
struggling with here.  Just accept the theorem for what it is (a valud
inference chain) and then you can pontificate to your heart's content
that it does not mean what it seems to mean because you've "reformulated
truth".

> This causes syntactic proofs to form conclusions that contradict the
> results derived though semantic inference chains.

You mean that some theorems seem contradict what you believe about God.
Your starting point here is religious conviction but you prefer to call
it a "semantic inference chain".

> I have recently shown that it is impossible for any language (formal
> or otherwise to have any statements of this language that cannot be
> proved or disproved within this language.

No you haven't.  It's possible that you can show that it is POimpossible
for any POlanguage (POformal or otherwise) to have any POstatements of
this POlanguage that cannot be POproved or POdisproved within this
POlanguage, but that would not do because no one would care.  The only
way you can get people to care it to incorrectly use the words everyone
else uses.

The rest of the post is waffle that you are much better at.  Provided
you don't try to address technical questions about well-established
proofs, you can post as much waffle as you like.

-- 
Ben.

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


#12582

FromPeter Percival <peterxpercival@hotmail.com>
Date2018-02-11 17:55 +0000
Message-ID<p5q03b$jnh$1@news.albasani.net>
In reply to#12550
Pete Olcott wrote:


> Because a proof is a syntactic construct and very little semantics
> has ever been fully formalized

Not so.  See, for starters, Tarski, /Concept of truth in formalized 
languages/ in /Logic semantics metamathematics/, ed. Corcoran, OUP; and 
Carnap, /Logical syntax of language/, RKP.

> syntactic formal proofs can have very
> large inference gaps.

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


#12588

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-12 20:39 -0600
Message-ID<oaKdnXv8Y4tx0h_HnZ2dnUU7-LPNnZ2d@giganews.com>
In reply to#12582
On 2/11/2018 11:55 AM, Peter Percival wrote:
> Pete Olcott wrote:
> 
> 
>> Because a proof is a syntactic construct and very little semantics
>> has ever been fully formalized
> 
> Not so.  See, for starters, Tarski, /Concept of truth in formalized languages/ in /Logic semantics metamathematics/, ed. Corcoran, OUP; and Carnap, /Logical syntax of language/, RKP.
> 

Of all the semantics that exists including the exhaustively complete meaning of every word of every human language hardly any has been formalized.

When we get to the formalization of the semantics of formal languages there are key gaps as proven by the existence of many paradoxes.

Some of those key gaps allow the mistakes of the Halting Problem proofs and the 1931 Incompleteness Theorem to slip through as undetected errors.



>> syntactic formal proofs can have very
>> large inference gaps.
> 


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

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


#11959

Frompeteolcott <peterolcott2@gmail.com>
Date2017-03-25 19:56 -0700
Message-ID<f5a8a9fa-d826-4c4d-9d1a-18e24d460365@googlegroups.com>
In reply to#11910
On Saturday, March 11, 2017 at 3:13:03 PM UTC-6, peteolcott wrote:
> http://LiarParadox.org/HP_Infinite_Recursion.pdf 
> 
> As this page 319 of An Introduction to Formal Languages and Automata
> by Peter Linz 1990 indicates
> 
> From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'.
>  
> q0 Wm |-* H-Hat q0 Wm Wm...
> 
> Page 320 indicates that we apply H-Hat to itself as input.
> 
> The problem is that every H-Hat needs a pair of inputs.
> 
> H-Hat takes an H-Hat as input and copies it so that it 
> can analyze how its input H-hat would analyze the copy
> of H-Hat that it just made. 
> 
> The input H-Hat would have to copy its own input H-Hat 
> so that it can analyze what its own input H-Hat would 
> do on its own input, on and on forever...
> 
> Copyright 2016 and 2017 Pete Olcott.

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


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

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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

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

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

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

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

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

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

-- 
Ben.

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


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

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

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

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

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

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

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

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

Sure then you correctly answer my incorrect question!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 00:30 +0000
SubjectRe: Infinitely Recursive input on HP Proofs (Final Solution?)
Message-ID<87a7wcfm4k.fsf@bsb.me.uk>
In reply to#12604
Pete Olcott <Pete@NoEmail.address> writes:

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-14 02:27 +0000
SubjectRe: Infinitely Recursive input on HP Proofs (Final Solution?)
Message-ID<87k1vge25w.fsf@bsb.me.uk>
In reply to#12611
Pete Olcott <Pete@NoEmail.address> writes:

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

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

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

No.

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

No.

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

No.

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

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

-- 
Ben.

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


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

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

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

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

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

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

-- 
Andy Walker,
Nottingham.

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

Copyright 2018 Pete Olcott

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

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-15 21:38 +0000
SubjectRe: Infinitely Recursive input on HP Proofs (Final Solution?)
Message-ID<87y3ju6ihp.fsf@bsb.me.uk>
In reply to#12656
Pete Olcott <Pete@NoEmail.address> writes:

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

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

There are no "incorrect" halting instances.

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

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

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

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

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

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

-- 
Ben.

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


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

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

This error occurs in numerous decision problems:

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

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

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

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

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

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

Ĥx [Ĥx][Ĥx]

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

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

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

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


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

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

Copyright 2018 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web