Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #11910 > unrolled thread
| Started by | peteolcott <peteolcott@gmail.com> |
|---|---|
| First post | 2017-03-11 13:13 -0800 |
| Last post | 2018-02-15 12:25 -0600 |
| Articles | 20 on this page of 118 — 9 participants |
Back to article view | Back to comp.theory
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 →
| From | Peter Percival <peterxpercival@hotmail.com> |
|---|---|
| Date | 2018-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]
| From | Andy Walker <anw@cuboid.co.uk> |
|---|---|
| Date | 2018-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]
| From | Andy Walker <anw@cuboid.co.uk> |
|---|---|
| Date | 2018-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | Peter Percival <peterxpercival@hotmail.com> |
|---|---|
| Date | 2018-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-13 00:18 -0600 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-13 13:06 +0000 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-13 16:55 -0600 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-14 00:30 +0000 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-13 19:38 -0600 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-14 02:27 +0000 |
| Subject | Re: 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]
| From | Andy Walker <anw@cuboid.co.uk> |
|---|---|
| Date | 2018-02-14 22:55 +0000 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-14 17:22 -0600 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-14 21:00 -0600 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-15 21:38 +0000 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-15 17:27 -0600 |
| Subject | Re: 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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-15 17:34 -0600 |
| Subject | Re: 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