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 4 of 6 — ← Prev page 1 2 3 [4] 5 6  Next page →


#12009

Frompeteolcott <Pete@NoEmail.address>
Date2017-04-29 14:45 -0500
Message-ID<6N2dneAhzaPIcJnEnZ2dnUU7-e_NnZ2d@giganews.com>
In reply to#11995
On 4/29/2017 2:35 PM, peteolcott wrote:
> Logical Equivalence between → and ⊢
>
> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
> (1) P & P → Q [rewritten as] Q
> (2) Q & Q → R [rewritten as] R
> (3) ∴ {P, P → Q, Q → R} ⊢ R
>
> The above example provides the logical equivalence of the LHS to the RHS.
> The LHS is a set of premises from which the RHS conclusion is derived.
>
> Truth Table of the above formal proof:
>
> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
> ---------------------------------------------------
> _0_________?__?______?____?__1______?_____?__0__?
> _1_________1__1______1____1__1______1_____1__1__1
>
>
>

I was testing the formatting of HTML

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


#12010

Frompeteolcott <Pete@NoEmail.address>
Date2017-04-30 13:23 -0500
Message-ID<3fCdnUz4p9QytpvEnZ2dnUU7-eudnZ2d@giganews.com>
In reply to#12009
(P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
(1) P & P → Q [rewritten as] Q
(2) Q & Q → R [rewritten as] R
(3) ∴ {P, P → Q, Q → R} ⊢ R

The above example provides the logical equivalence of the LHS to the RHS.
The LHS is a set of premises from which the RHS conclusion is derived.

Truth Table of the above formal proof:

(P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
---------------------------------------------------
_0_________?__?______?____?__1______?_____?__0__?
_1_________1__1______1____1__1______1_____1__1__1

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


#12012

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2017-04-30 23:05 +0100
Message-ID<87wpa1h7q4.fsf@bsb.me.uk>
In reply to#12010
peteolcott <Pete@NoEmail.address> writes:

> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R

Is this your own syntax?  It is defined anywhere?  Is the meaning ⊢
defined anywhere?

> (1) P & P → Q [rewritten as] Q
> (2) Q & Q → R [rewritten as] R

What is &?

> (3) ∴ {P, P → Q, Q → R} ⊢ R

What rule of inference lets you deduce (3) from (1) and (2)?

> The above example provides the logical equivalence of the LHS to the
> RHS.

It make no reference to the LHS so that seems unlikely.  Maybe all this
is just another of you "symbol poems" where you use symbols you seen in
a soft of metaphorical way in an attempt to hint at what's going on in
your head.

> The LHS is a set of premises from which the RHS conclusion is derived.
>
> Truth Table of the above formal proof:
>
> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
> ---------------------------------------------------
> _0_________?__?______?____?__1______?_____?__0__?
> _1_________1__1______1____1__1______1_____1__1__1

You don't know what a truth table is, do you?

-- 
Ben.

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


#12013

Frompeteolcott <Pete@NoEmail.address>
Date2017-04-30 18:43 -0500
Message-ID<zvednVtW3ZsF65vEnZ2dnUU7-QHNnZ2d@giganews.com>
In reply to#12012
On 4/30/2017 5:05 PM, Ben Bacarisse wrote:
> peteolcott <Pete@NoEmail.address> writes:
>
>> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
>
> Is this your own syntax?  It is defined anywhere?  Is the meaning ⊢
> defined anywhere?
>
>> (1) P ∧ P → Q [rewritten as] Q
>> (2) Q ∧ Q → R [rewritten as] R
>
> What is &?

A typo that has now been corrected.

>
>> (3) ∴ {P, P → Q, Q → R} ⊢ R
>
> What rule of inference lets you deduce (3) from (1) and (2)?
>
>> The above example provides the logical equivalence of the LHS to the
>> RHS.
>
> It make no reference to the LHS so that seems unlikely.  Maybe all this
> is just another of you "symbol poems" where you use symbols you seen in
> a soft of metaphorical way in an attempt to hint at what's going on in
> your head.
>
>> The LHS is a set of premises from which the RHS conclusion is derived.
>>
>> Truth Table of the above formal proof:
>>
>> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
>> ---------------------------------------------------
>> _0_________?__?______?____?__1______?_____?__0__?
>> _1_________1__1______1____1__1______1_____1__1__1
>
> You don't know what a truth table is, do you?
>

This stuff is more relevant to the other forum.
I only posted it here to test the HTML table alignment
of the columns of the Truth table.

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


#12014

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2017-05-01 13:45 +0100
Message-ID<87k2603fvx.fsf@bsb.me.uk>
In reply to#12013
peteolcott <Pete@NoEmail.address> writes:

> On 4/30/2017 5:05 PM, Ben Bacarisse wrote:
>> peteolcott <Pete@NoEmail.address> writes:
>>
>>> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
>>
>> Is this your own syntax?  It is defined anywhere?  Is the meaning ⊢
>> defined anywhere?
>>
>>> (1) P ∧ P → Q [rewritten as] Q
>>> (2) Q ∧ Q → R [rewritten as] R
>>
>> What is &?
>
> A typo that has now been corrected.
>>
>>> (3) ∴ {P, P → Q, Q → R} ⊢ R
>>
>> What rule of inference lets you deduce (3) from (1) and (2)?
>>
>>> The above example provides the logical equivalence of the LHS to the
>>> RHS.
>>
>> It make no reference to the LHS so that seems unlikely.  Maybe all this
>> is just another of you "symbol poems" where you use symbols you seen in
>> a soft of metaphorical way in an attempt to hint at what's going on in
>> your head.
>>
>>> The LHS is a set of premises from which the RHS conclusion is derived.
>>>
>>> Truth Table of the above formal proof:
>>>
>>> (P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
>>> ---------------------------------------------------
>>> _0_________?__?______?____?__1______?_____?__0__?
>>> _1_________1__1______1____1__1______1_____1__1__1
>>
>> You don't know what a truth table is, do you?
>>
>
> This stuff is more relevant to the other forum.

It is just as wrong in both and you seem just as keen to avoid
addressing the points raised there as here.

-- 
Ben.

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


#12011

Frompeteolcott <Pete@NoEmail.address>
Date2017-04-30 13:24 -0500
Message-ID<3fCdnU74p9RntpvEnZ2dnUU7-eudnZ2d@giganews.com>
In reply to#12009
(P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
(1) P & P → Q [rewritten as] Q
(2) Q & Q → R [rewritten as] R
(3) ∴ {P, P → Q, Q → R} ⊢ R

The above example provides the logical equivalence of the LHS to the RHS.
The LHS is a set of premises from which the RHS conclusion is derived.

Truth Table of the above formal proof:

(P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R
---------------------------------------------------
_0_________?__?______?____?__1______?_____?__0__?
_1_________1__1______1____1__1______1_____1__1__1

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


#12007

FromPeter Percival <peterxpercival@hotmail.com>
Date2017-04-27 21:16 +0100
Message-ID<odtji8$mgm$1@news.albasani.net>
In reply to#11993
peteolcott wrote:

>
> There is a joker in the other forum that just can't seem to accept
> that "7 < 3" is false.

And there's a lying cunt in this one.


-- 
Do, as a concession to my poor wits, Lord Darlington, just explain
to me what you really mean.
I think I had better not, Duchess.  Nowadays to be intelligible is
to be found out. -- Oscar Wilde, Lady Windermere's Fan

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


#12461

FromPete Olcott <Pete@NoEmail.address>
Date2018-01-26 11:37 -0600
Message-ID<A6-dncbHSYLy-vbHnZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#11925
On 1/26/2018 6:10 AM, George Greene wrote:
> On Friday, January 26, 2018 at 12:49:43 AM UTC-5, peteolcott wrote:
>> On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
>>> Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
>>> start a new thread ABOUT THOSE and stop talking in this one??
>>
>> The only "rebuttal" talked about TMs calling other TMs and TMs
>> returning values. Everyone that knows TMs knows that this is not
>> the way that they work.
> 
> I repeat, this everyone DOES NOT INCLUDE YOU.
> MY GOD, are you going to allege that BB, PP, and EVERY OTHER TEXTBOOK THAT EXPLAINS HOW one TM calls another is WRONG?  And yet you and "everyone" are still right, that "everyone" does not include all this?
> 
> YOUR OWN TREATMENT says that from a certain point, H^ BEHAVES LIKE H'.

That is not my own treatment that is the author's explanation that I
quoted to confirm that he was talking about H^ and not H'

> EVEN IF YOU WON'T CONCEDE that that is "calling H' ", that STILL MEANS

TMs do not call other TMs that is not the way that they work.
You either know this and are lying or do not have an MSCS.

> THAT I AM RIGHT AND YOU ARE WRONG, and that STILL CONSTITUTES a rebuttal
> of your claim that H^ (and H', by extension, since what H^ is doing after
> doubling its input is, after all, only and exactly THE SAME thing that
> H' WOULD be doing on that doubled input IF IT had been called with this
> w^,w^ input) is "executing w^" and re-performing the copying!

That sounds reasonable.

> J' *DOES*NOT* execute w^!  In the first place, w^ CAN"T be executed because IT

There is no J'

> is not a TM!  It is the code-string of H^, so it is H^ that would be again

A UTM could execute it, if H^ is a UTM then w^ could be executed.

> getting executed! for the Nth time, the TM itself NEEDS to be though of
> AS SOFTWARE, NOT hardware, in this AND ALL situations!  If you want to speak

This aspect makes no difference. The aspect that makes a difference
is glossing over key details such as the details of state transitions.

> AT A HIGHER LEVEL OF ABSTRACTION, as you wrongly claim you don't, then yes,
> OF COURSE, ONE COULD say by overloading/extension that one can "execute a string" by INTERPRETING IT AS A CODE FOR A TM PROGRAM and emulating THAT tm
> as opposed to behaving some other way, BUT EVEN IF WE CONCEDE THAT THAT IS

UTMs can already execute TMDs and this is not a high level abstraction.
We still have reading a tape element, writing a tape element, moving
the tape head, transitioning to another state.

> HAPPENING, *again*, the FIRST thing H' does IS NOT emulate the execution of
> w^=H^ -- the FIRST thing H' does IS CALL H!  That is NOT just according to ME!

No TM ever calls another TM this is a high level abstraction figure of
speech. It is still always only a matter of moving the tape head
reading / writing tape elements and transitioning to a next state based
on the current state and the currently read tape element.

> YOUR OWN TREATMENT AND DIAGRAM shows the program for H' *BEGINNING*WITH*
> the program FOR *H*!!  So NOTHING HAS BEGUN TO RE-COPY ANY INPUT YET!

No it does not that is a flat out falsehood.
My diagram defines H^ showing that its initial tape element is the
first character of w^.

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

> After doubling its input
> H^ EMULATES H', WHICH IN TURN BEGINS by emulating *H*.

H^ never emulates H' it has its own set of states some of which
correspond to H's states.

> SO THE ONLY way any input is going to get re-copied is
> IF H
> decides to emulate w^=H^.  

Now we are finally getting to the interesting part. With all of your
dodges it seemed like you wanted to avoid talking about the interesting
part.

It is true that the only way that w^ is actually going to be recopied
is if H^ actually executes the TMD w^. H^ could do this if H^ is a UTM.

> WHICH IT WON'T, because H is defined
> AS ALWAYS HALTING, and H DOESN'T KNOW YET whether H^(w^) WILL OR WON'T
> halt!  H DOES NOT DARE actually INVOKE or emulate H^ on w^ because IF it
> should turn out that that loops, H WILL NEVER RETURN TO TELL YOU!
> H will be STUCK IN THE SAME loop that H^(w^) is in!
> SO
> H
> DOESN'T
> *DO*
> *THAT*,
> *D*U*M*B*A*S*S*.
> 

That whole last paragraph was correct except that I am a genius
rather than a dumbass.

H^ is supposed to evaluate w^ and decide Halting or non Halting
for w^. The problem that I first discovered August 2016,
(after spending about 3000 hours on this since 2004) is that
the detailed step by step analysis of H^ analyzing w^ indicates
that the evaluation sequence itself has an infinite length.

This point is very very subtle. I would have never noticed it
if I did not detect the same problem with the Liar Paradox.

The evaluation of the Liar Paradox and the HP proof counter-example
both specify an infinitely recursive evaluation sequence.

My Facebook friend Scott Brizel got me looking at the Truth teller
paradox in July 20, 2016. This was the key that lead to all of my
other insights.

"This sentence is True" lacks the paradoxical adaptation of the
Liar Paradox and the HP proof, yet still cannot be evaluated to
either True of False.

"This sentence is True"
What is it True about?
It is True about being True.
What is it "True about being True" about?
It is True about being True about being True.

The HP proof has this same infinite recursion before it even gets
to states (qy) or (qn).

It is not the modified (qy)--->(qa) infinite loop that makes it
undecidable.

The evaluation sequence of H^ is stuck in infinite recursion  between
states (qx) and (q0) and thus never reaches either state (qy) or (qn).

Every HP proof has this same problem.

Between (q0) and (qx) H^ copies its input w^ to w^2
After (qx) H^ evaluates what w^ would do on its input w^2.

Between (q0) and (qx) w^ would copy its input w^2 to w^3
After (qx) w^ would evaluate what w^2 would do on its input w^3.

Between (q0) and (qx) w^2 would copy its input w^3 to w^4
After (qx) w^2 would evaluate what w^3 would do on its input w^4.

It might be easier to see this as a math problem rather than a computer science problem:

If we go straight out David Hilbert on this:
    "statements of mathematics and logic can be
    considered to be statements about the consequences
    of certain string manipulation rules."

Then we have this Math version of the Halting Problem
∃x ∈ Turing_Machine_Descriptions
∀y ∈ Turing_Machine_Descriptions
∀z ∈ Finite_Strings Halts(x, y, z)

Specifying the syntax of self-reference semantics:
The <ASSIGN_ALIAS> operator: "≡"
LHS is assigned as an alias name for the RHS
LHS ≡ RHS
The LHS is logically equivalent to the RHS ONLY Because
the LHS is merely an alias name for the RHS

When we evaluate the following expression of
HOL (with self-reference semantics):
H^ ≡ Halts(H^)

The translation of this expression into a directed acyclic
graph indicates that this expression is recursive and yet
lacks any recursion termination condition.
00 Halts (00)

"5 > 3" is translated into to directed acyclic graph
00 Greater_Than
01 Five
02 Three


Copyright 2016, 2017, 2018 Pete Olcott

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

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


#12484

FromPete Olcott <Pete@NoEmail.address>
Date2018-01-31 00:14 -0600
Message-ID<PbSdnTmmwYlVw-zHnZ2dnUU7-LfNnZ2d@giganews.com>
In reply to#11925
On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
> peteolcott <peterolcott2@gmail.com> writes:
> 
>> On Saturday, January 27, 2018 at 3:58:40 PM UTC-6, Ben Bacarisse wrote:
>>> I'm going to reply only the main point -- the error in your argument.
>>> It's too easy for Usenet threads to get side tracked by all the other
>>> things you say...
>>>
>>> peteolcott writes:
>>>
>>>> On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote:
>>>>> peteolcott writes:
>>>>> <snip>
>>>>>> No you only need to trace the evaluation sequence of H^ to see that
>>>>>> it gets stuck in infinite recursion after state (qx). It never even
>>>>>> reaches state (qy) or ((qn)).
>>>
>>> This is wrong by the assumption made at the start of the proof -- that H
>>> decides halting (the fact that it decides anything is enough).  The
>>> first time round I missed this clearly erroneous statement but I make
>>> the same point later on:
>>>
>>>>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>>>>>
>>>>>> Definition of Turing Machine Ĥ (state transition sequence)
>>>>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>>>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
>>> <remove side issue>
>>>>>> q0 to qx it copies its input ŵ to ŵ2
>>>>>> after qx it evaluates its input ŵ ŵ2
>>>>>
>>>>> No.  You do not know exactly what H^ does from state qx onward.  You
>>>>> certainly can't say it "evaluates" its input.
>>>>
>>>>  From a David Hilbert Formalism pure math POV the entire process
>>>> is the evaluation of finite strings H^ w^.
>>>
>>> You are not allowed to change the formalism.  H^ is a TM and it's action
>>> is determined by it's state transition function.  To see your error you
>>> must stick with Turning machines and their actions.
>>>
>>> But in *any* formalism you may not assume what H^ does from state qx on.
>>> Any arguments that does so is flawed.  You wanted to know where the
>>> error is.  It is here.
>>>
>>> The only valid assumptions about H^'s behaviour are those you can derive
>>> from the assumption in the argument: that H decides halting.  From that
>>> premise we know that all traces of H^ take the machine from state qx to
>>> either qy or qn.
>>
>> If we create a machine specification that counts the characters
>> of strings and a string of infinite length is provided as input
>> we cannot expect this machine to halt on every input.
> 
> That's wrong in so many ways.  No TM is ever provided with a string of
> infinite length (a good book will tell you this).  A TM might construct
> a string that never ends, but that's not the same thing.
> 

It is sufficiently analogous. If a TM is provided with a problem that
specifies infinite recursion then a David Hilbert finite string
formalization of this problem inherently requires infinite recursion.

This is an analogous idea to a TM that counts the characters of a string
and would otherwise halt except in the case where this string is (for
all practical purpose) infinite.

>> The same thing is occurring with the HP proof counter-example. H^ is
>> not actually provided a single TM / input pair, it superficially
>> seems that it is, but, deeper analysis indicates that H^ is actually
>> provided with an infinitely recursive set of TM / input pairs.
> 
> No it isn't.  I don't expect you to see why you wrong because you are no
> longer engaging with any arguments -- you are just repeating the error
> again and again.  If you want to know why you are wrong, you need to
> take the time to find out what I am saying.  Really find out -- ask
> about the why I said X or Y.  Probe my statements.  Repeating yourself
> will not help.
> 

I will tell you what try and find out why the Truth teller paradox:
"This sentence is true" is not true
and then you might actually begin to see what I mean.

>> It took me at least 3,000 hours 12 years to see this so if you don't
>> get it right away that is quite understandable.
> 
> The length of time is immaterial.  I've been studies this material for
> far more than 3000 hours, but that does not make me right.  What makes
> me right is that what I said is correct and what you said is wrong:
> 
> You are making an incorrect assumption about what H^ does from state qx
> onwards.  If you want to know why that's wrong (and what I wrote before
> is not enough to help you see it) just ask me some questions.

A David Hilbert finite string evaluation inherently specifies the sequence
that I am claiming. The Truth Teller paradox will show you this.

> 
> Feel free to re-state your error again a few more times, but it won't
> alter the fact that your argument is unsound.
> 

Lets use a process of elimination to get to the truth.
You would of course agree that the sequence that I am specifying
is one of the possible sequences, right?

∃x ∈ Turing_Machines_Descriptions
∀y ∈ Turing_Machine_Descriptions
∀z ∈ Finite_Strings Halts(x, y, z)
H ≡ Halts(H, H, H) // HOL with self-reference semantics

Try and provide a counter-example that does not violate the above specs.

>> H^ can only decide if w^ halts on it input w^2
>> on the basis of w^2 halting on its input w^3...
> 
> No.  From state qx on, H^ behaves like H' (which behaves like H until
> the very last state).  The H (or the copy of H -- you decide which view
> you take) which is embedded in H^ must simply do what it does with any
> input it is asked to "decide".  

It lacks sufficient information to decide.
H^ can only decide what w^ does on its input w^2 based on what w^ decides.
The essence of this (like the Truth Teller Paradox) is infinitely recursive.

If it is not infinitely recursive (and it is) then w^ would simply decide
that w^2 halts on its NULL input. The H^ decides that this will cause w^
to loop so it simply transitions to ((qn)).

> You can't (and mustn't) say anything
> about how it does that, but you *can* be sure that state qy or qn is
> reached in a finite number of steps.  That's because, however it does
> it, it is a decider.

Making that assumption turns out to be exactly analogous to being certain
that the Liar Paradox must be True or False. It turns out the the LP is
simply incorrect.

> 
>> This is far too subtle for anyone in the world to notice until now.
> 
> Nonsense.  It's taken this long for someone misinformed enough to think
> that this is what H^ does.  Everyone else has understood that H^ behaves
> like H' and H' will always transition into state qy or qn because that
> is required by the assumption at the start of the proof.
> 
> The one thing that H^ can not do from state qx on is what you are
> assuming it does, and that is to "run" (or emulate or evaluate) its

It cannot run, it cannot emulate, in math terms evaluate is all that is left.
All math expressions are evaluated, that is how math works.

> input.  H^ is built from a decider, and no decider can run (or emulate
> or evaluate) its input.  Such behaviour is ruled out from the start.
> 

The title of my final published paper will be:
The Halting Problem proof is merely the Liar Paradox in disguise.

> That's a bit sweeping: a decider can *start* to run its input as a
> machine, but it can not get into a loop doing that.  It has to go on to
> do something else that will cause it to terminate.
> 
> You have a notation for this which you wrote out:
> 
>    qx w^ w^ |-H^ qy oo
>    qx w^ w^ |-H^ qn
> 
> Do you know what that means?  If you do, why did you write it?  It is
> correct and it contradicts what you are saying in words.
> 

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
You left some key state transitions out:

Definition of Turing Machine Ĥ (state transition sequence)
q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn

// As a David Hilbert mathematical formalism.
Ĥ ≡ Halts(Ĥ, Ĥ, Ĥ) // HOL with self-reference semantics

Every possible definition of the above Ĥ must necessarily fail
because the problem itself inherently specifies infinite recursion
in the same way that the Liar Paradox and the Truth Teller Paradox
inherently specify infinite recursion:

LP ≡ ~True(LP)  // HOL with self-reference semantics
TT ≡ True(TT)   // HOL with self-reference semantics

Copyright 2016, 2017, 2018 Pete Olcott


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

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


#12489

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-01-31 21:57 +0000
Message-ID<87fu6lbsjp.fsf@bsb.me.uk>
In reply to#12484
Pete Olcott <Pete@NoEmail.address> writes:

> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>> peteolcott <peterolcott2@gmail.com> writes:
>>
<snip>
>>> If we create a machine specification that counts the characters
>>> of strings and a string of infinite length is provided as input
>>> we cannot expect this machine to halt on every input.
>>
>> That's wrong in so many ways.  No TM is ever provided with a string of
>> infinite length (a good book will tell you this).  A TM might construct
>> a string that never ends, but that's not the same thing.
>
> It is sufficiently analogous. If a TM is provided with a problem that
> specifies infinite recursion then a David Hilbert finite string
> formalization of this problem inherently requires infinite recursion.
>
> This is an analogous idea to a TM that counts the characters of a string
> and would otherwise halt except in the case where this string is (for
> all practical purpose) infinite.

There is no "for all practical purposes" here.  TMs can not be provided
with infinite input.  The input is always finite.

I don't know why you want to keep defending this minor mistake because
your argument incorrect though it is, does not depend on a TM being
given an infinite input string.

We all know that some finite input strings can cause some TMs to loop
without end.

<snip>
>>> H^ can only decide if w^ halts on it input w^2
>>> on the basis of w^2 halting on its input w^3...
>>
>> No.  From state qx on, H^ behaves like H' (which behaves like H until
>> the very last state).  The H (or the copy of H -- you decide which view
>> you take) which is embedded in H^ must simply do what it does with any
>> input it is asked to "decide".  
>
> It lacks sufficient information to decide.
> H^ can only decide what w^ does on its input w^2 based on what w^ decides.
> The essence of this (like the Truth Teller Paradox) is infinitely recursive.
>
> If it is not infinitely recursive (and it is) then w^ would simply decide
> that w^2 halts on its NULL input. The H^ decides that this will cause w^
> to loop so it simply transitions to ((qn)).

No.  I won't explain again because you are not listening.  Your words
have all sort of errors (H^ is not a decider so it does not decide
anything, w^ is a string so it can not loop, and so on) but I'm just
glossing over those -- you no longer care about details.

>> You can't (and mustn't) say anything
>> about how it does that, but you *can* be sure that state qy or qn is
>> reached in a finite number of steps.  That's because, however it does
>> it, it is a decider.
>
> Making that assumption turns out to be exactly analogous to being certain
> that the Liar Paradox must be True or False.

I don't care about your analogies -- mathematics requires stronger
arguments than "it's like this other thing".  Provided you accept that
the assumption must go we are in agreement.  As a result, I suspect you
will have to say you misspoke here.  Do you, in fact, agree that the
assumption made at the start of the proof must be wrong?

>> The one thing that H^ can not do from state qx on is what you are
>> assuming it does, and that is to "run" (or emulate or evaluate) its
>
> It cannot run, it cannot emulate, in math terms evaluate is all that is left.
> All math expressions are evaluated, that is how math works.

No, that is not how maths works, but going into that would derail the
whole thread.

You are wrong in this specific case because your argument assumes
something it can not assume.  H^ *always* transitions from qx to either
qn or qy by the assumption made at the start of the proof.  Any other
assumptions are unwarranted.  Anything else you say along the line of
"H^ must always..." or "the only way H^ can..." are red-flags showing
that you are making assumptions about behaviour with is entirely
unknown.  You know only two significant facts about H^: one of which is
that H^ always transitions to state qy or qn in a finite number of steps
(the second is not currently important).

>> input.  H^ is built from a decider, and no decider can run (or emulate
>> or evaluate) its input.  Such behaviour is ruled out from the start.
>
> The title of my final published paper will be:
> The Halting Problem proof is merely the Liar Paradox in disguise.

An odd title (problems don't have proofs), but it does at least make it
clear that you accept that the halting *theorem* (presumably that's what
you meant) has a proof.

>> You have a notation for this which you wrote out:
>>
>>    qx w^ w^ |-H^ qy oo
>>    qx w^ w^ |-H^ qn
>>
>> Do you know what that means?  If you do, why did you write it?  It is
>> correct and it contradicts what you are saying in words.
>
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> You left some key state transitions out:

No.  You don't know what this notation means so you think the part I
left off matters.  I can't really help with that because I don't think
you want to learn about the notation.

> Definition of Turing Machine Ĥ (state transition sequence)
> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn

This contradicts what you are saying in words, and it backs up (it is in
fact exactly) what I am saying with *my* words.  You clearly don't know
what this notation means or you would not keep writing something that
contradicts yourself again and again.

I've said this before, but I think you should stick to words.  It's a
shame, because they can be so very ambiguous, but you don't seem to have
the right mentality for formal notations.  Lots of the formulas you
write are either under-specified (and thus have a sort of vague poetic
quality) or are well-defined and say something you don't mean.

I repeat: those two lines are correct and they say what I am saying not
what you are trying to say.

-- 
Ben.

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


#12494

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

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

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


#12496

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

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

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

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

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

-- 
Ben.

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


#12516

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-03 00:38 -0600
Message-ID<kvGdnadq9Kp2xejHnZ2dnUU7-a3NnZ2d@giganews.com>
In reply to#12496
On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/2/2018 3:38 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>
>>>> On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
>>>>> Pete Olcott <Pete@NoEmail.address> writes:
>>>>>
>>>>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote:
>>> <snip>
>>>>>>> The argument you presented has an error which I pointed out.  You have
>>>>>>> not addressed it (and I don't mind that) but you have not even responded
>>>>>>> to a simple request for a clarification.  I think you've entered "post
>>>>>>> any old answer" mode now so I expect you will soon be gone for a
>>>>>>> while...
>>>>>>
>>>>>> OK F is not expressive enough to have a provability predicate so I will use H.
>>>>>>
>>>>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉).
>>>>>> (G2) H ⊢ GH ↔ ¬ProvF(GH).
>>>>>> G2 is precisely analogous to G1 such that showing G2 is erroneous
>>>>>> shows that G1 is erroneous. ---
>>>>>
>>>>> You made incorrect statements about a well-know proof.  I pointed out
>>>>> why they were wrong.  Do you retract them?  They are still on your blog
>>>>> (along with some more new errors).
>>>>
>>>> Can you be more evasive? If you try really hard I think that you can.
>>>
>>> I have been as direct as I can be.  You have not addressed the error I
>>> pointed out.
>>>
>>>> In any case we are not talking about my blog we are talking about the
>>>> above two formulas.
>>>
>>> No, I'm not talking about them.  I am still talking about the error you
>>> are avoiding.  You have no addressed it.  I mention your blog only
>>> because you keep posting the reference and you've stopped talking about
>>> the error here.
>>
>> Then be completely specific about the error on the blog, I have at least
>> forty blog posts, and so far the closest you came to pointing out any error
>> was a vague assertion that I made some mistake somewhere.
> 
> I was very explicit about the error when you posted it here.  You did
> not address it.  I can't imagine why you want me to tell you again but
> here goes...  At
> 
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> 
> you repeat the incorrect conclusion that "The HP proof counter-examples
> all get stuck in infinite recursion (never reaching states qy or qn)".
> This is incorrect and you reach this incorrect conclusion by making (at
> step (2)) and unwarranted assumption that is contrary to what you know
> about H^ a this point -- contrary to how H^ is defined.
> 

OK great you are getting specific here.
It is not contrary to how H^ is defined.
I am working on proving this more unequivocally.

The essential nature of the problem presented to H^ is inherently infinitely recursive.

Whether or not H^ actually executes infinite recursion is a different question.

These are Facts:
After H^ makes a copy of its input
H^ must decide based on what H^2 H^3 would do.
H^2 would make a copy and then it would
decide based on what H^3 H^4 would do.

The definition of the problem is infinitely recursive.
That does not necessarily entail that H^ would actually execute infinite recursion.

> Oddly, to explain why H^ does not get to either qy or qn you write
> 
>    q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>    q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
> 

The potential halt decider and every instance of its input are all defined
to have exactly the same behavior.

This is the part that makes the inherent definition of the problem infinitely recursive:

Every instance of the above definition would begin at q0 copy its input and then transition to qx.

If H^ would copy its input H^2 to H^3,
then H^2 would also copy its input H^3 to H^4
on and on...

> which says exactly what you deny.  Those two lines happen to be correct
> and they state that H^ transitions into either state qn or state qy in a
> finite number of steps.
> 
> There are, of course, lots of other errors.  (3) and (4) talk about
> strings doing things.  It might be poetry, but it's not mathematics.
> 

H^ evaluates what H^2 would do even if H^2 actually does nothing besides
just sit there. If H^2 was executed by a UTM it would copy its input.
H^ must decide what H^2 would do if it was executed by a UTM.

> You then go on to eliminate something that does no exist by showing a
> machine configuration that has nothing to do with the halting problem.
> Then you assert that the notation you clearly don't understand:
> 
>    q0 ŵ ŵ2 ⊢* Ĥ qy ∞
>    q0 ŵ ŵ2 ⊢* Ĥ qn
> 
> says that H^ *will* (in this case) transition to either state qy or qn
> in a finite number of steps.  But if you applied the (admittedly
> incorrect) argument you did a few lines previously you'd see it applies
> to this configuration as well.  You are not even consistently wrong.
> 

There is no infinitely recursive evaluation sequence defined in that
machine. (The H' machine of Figure 12.2)
H'3 --> qn (NULL input)
H'2 --> qy loops
H'  --> qn

If the above was evaluated by H (Figure 12.1) H would be a decider for H' H'.
H'2 --> qn (NULL input)
H'  --> qy loops
H   --> qn

> And that is far from being the full list.  There are strings
> transitioning and talk about counter-examples and odd things being
> "decidable" and so on, but the main error is the first: 

> you assume
> something about H^ that is contrary to it's definition.
> 

I never did this. Hopefully my clarifications will make my point
more clear. I am shooting to get published, first I must be understood.

>> The reason that you have to stick with vague assertions and cannot
>> point out a specific mistake and why it is a mistake is that there is
>> no mistake at all.
> 
> No, the assertions become vague when I see you won't respond to them.
> Why not bookmark or save this post because I'm sure you will again tell
> me I have not told you where you are wrong in a few posts time.
> 

As long as you remain totally specific I will very carefully study
everything that you say. I want to focus in the infinite recursion
aspect though. I will try to use terminology precisely correctly.
With the HP proof the correct terms exist.

> Not that there is nothing here that is new.  I've said it all before.
> 
> To be fair, you did try to address this key error at one time, but your
> conclusion -- that the assumptions made about H must be wrong -- is
> exactly what the poof is establishing.  Maybe you realised that, because
> you stopped saying this and switched to posting more of your symbol
> poems.
> 

The two key errors that you claimed and I responded to are not errors at all.
Let's focus on the infinite recursion aspect. It is not that I am wrong,
it is that I have not yet proven my point.


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

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


#12517

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-03 13:37 +0000
Message-ID<87vafe19f9.fsf@bsb.me.uk>
In reply to#12516
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
<snip>
>>> Then be completely specific about the error on the blog, I have at least
>>> forty blog posts, and so far the closest you came to pointing out any error
>>> was a vague assertion that I made some mistake somewhere.
>>
>> I was very explicit about the error when you posted it here.  You did
>> not address it.  I can't imagine why you want me to tell you again but
>> here goes...  At
>>
>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>
>> you repeat the incorrect conclusion that "The HP proof counter-examples
>> all get stuck in infinite recursion (never reaching states qy or qn)".
>> This is incorrect and you reach this incorrect conclusion by making (at
>> step (2)) and unwarranted assumption that is contrary to what you know
>> about H^ a this point -- contrary to how H^ is defined.
>
> OK great you are getting specific here.

I have said all of this before and the key part (your main mistake)
several times.  I'm not inclined to accuse you of dishonesty so I must
assume that have not been reading the posts you are replying to.  Is
that the case?

> It is not contrary to how H^ is defined.

Yes it is.  H^ is derived from H' which is derived from H which is
assumed to be halt decider.  You must only make deductions that are
consistent with this definition.

> I am working on proving this more unequivocally.
>
> The essential nature of the problem presented to H^ is inherently
> infinitely recursive.

The essential nature of H^ is that it does not exist.  Thus the supposed
problem (which involves [H^] -- that's my way of writing H^'s encoding)
does not exist either.  You often loose track of this rather basic fact.

> Whether or not H^ actually executes infinite recursion is a different
> question.

Actually it's the key question and the key to your error.  You keep
saying (and you say it again below) that H^ really does execute
indefinitely rather than transitioning to qy or qn in a finite number of
steps as per its definition.
 
> These are Facts:
> After H^ makes a copy of its input
> H^ must decide based on what H^2 H^3 would do.
> H^2 would make a copy and then it would
> decide based on what H^3 H^4 would do.

No.  There is only one "must" you can say about H^ -- it must transition
to either qy or qn in a finite number of steps.

You then compound this error by talking about what strings do.  You
really need to stop saying anything about what a string does.  If you
are assuming that H^ is or behaves line a universal TM (thereby making
the idea of a string doing something at least metaphorically
reasonable), that too is an error.

> The definition of the problem is infinitely recursive.
> That does not necessarily entail that H^ would actually execute infinite recursion.
>
>> Oddly, to explain why H^ does not get to either qy or qn you write
>>
>>    q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>    q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
>
> The potential halt decider and every instance of its input are all defined
> to have exactly the same behavior.

Does this remark have anything to do with your incorrect use of Linz's
notation?  Those two lines, which you keep writing to show the "infinite
recursion", actually state the opposite.  Some correction of this error
would be appreciated.  Either that or you could explain why you think
those two lines support your case rather than directly refute it.  That
would allow me to see what it is you've misunderstood about these two
simple lines.

> This is the part that makes the inherent definition of the problem
> infinitely recursive:
>
> Every instance of the above definition would begin at q0 copy its
> input and then transition to qx.

The above is not a definition.  H^'s definition in given only in words
and diagrams in Linz.  The two lines you are not understand say
something (but not everything) about what H^ *does* in some particular
cases.  It does *not* say (because that would be wrong) what you claim.

> If H^ would copy its input H^2 to H^3,

Don't keep inventing new, bad, notations.  There is no need to keep
numbering strings, and you should not label them with a capital letter.
H^2 looks like a machine, not a string.  If you stick with writing out
configurations there can be no confusion.

This is the initial configuration of H^, written out properly:

  q0 [H^]

q0 is the state of the machine, [H^] is the encoding of H^.  By the
definition of H^, the following happens:

  q0 [H^] |-* qx [H^] [H^]

There is no need to keep writing H^ under the |- symbol since it's the
only machine whose traces we will be writing.  qx is the state of H^
that corresponds to the initial state of H (and also of H').  This line
says "after copying the input string, H^ behaves exactly like H'".

Also form the definition of H^ we may go on to say

  q0 [H^] |-* qx [H^] [H^] |-* qy oo    (that's an infinity symbol)
  q0 [H^] |-* qx [H^] [H^] |-* qn
  
This says that H^ goes on to transition into either state qy or qn.
This follows from the fact the H^ is now behaving like H' and H' is
defined to do this.

> then H^2 would also copy its input H^3 to H^4
> on and on...

H^2 is a string, confusingly named in a way that makes it look like a
machine.  It does not copy anything.  Part of the reason you keep making
these category errors is that you have no good notation to write what is
going on.

I know as well as anyone that what you write as H^2 (and I write as
[H^]) is the encoding of a machine, but encodings -- even of machines --
can't do anything.  They can be interpreted by a UTM, but it is still
the UTM that is doing things, changing state and writing symbols and so
on.

From what you write below it's clear that you talk of strings doing
things because you can think of no other way that H could decide halting
but to interpret (or run or evaluate) its input string.  However, that
is one thing you can *not* assume about H (or the H' and H^ derived from
it).

>> which says exactly what you deny.  Those two lines happen to be correct
>> and they state that H^ transitions into either state qn or state qy in a
>> finite number of steps.
>>
>> There are, of course, lots of other errors.  (3) and (4) talk about
>> strings doing things.  It might be poetry, but it's not mathematics.
>
> H^ evaluates what H^2 would do even if H^2 actually does nothing besides
> just sit there. If H^2 was executed by a UTM it would copy its input.
> H^ must decide what H^2 would do if it was executed by a UTM.

No.  You may not assume that H^ evaluates what H^2 would do.  Any
argument that relies on such an unwarranted assumption must be
rejected.

>> You then go on to eliminate something that does no exist by showing a
>> machine configuration that has nothing to do with the halting problem.
>> Then you assert that the notation you clearly don't understand:
>>
>>    q0 ŵ ŵ2 ⊢* Ĥ qy ∞
>>    q0 ŵ ŵ2 ⊢* Ĥ qn
>>
>> says that H^ *will* (in this case) transition to either state qy or qn
>> in a finite number of steps.  But if you applied the (admittedly
>> incorrect) argument you did a few lines previously you'd see it applies
>> to this configuration as well.  You are not even consistently wrong.
>
> There is no infinitely recursive evaluation sequence defined in that
> machine.

It does not matter.  This configuration is irrelevant.  You are fixing a
non-extent problem in some computation by presenting a new computation
that does not occur.  You happen to be wrong about this new computation
as well, but since it does not matter, we should not waste time on it.

What matters is what happens in *this* configuration:

  q0 [H^]

not what happens in this new one you've pulled out of a hat:

  q0 [H^] [H^]

<snip>
> The two key errors that you claimed and I responded to are not errors at all.
> Let's focus on the infinite recursion aspect.

Absolutely.  Nothing else matter after you make your unwarranted
assumption about what H^ does, but it would help if you understood the
notation you keep using since you keep contradicting your words with the
symbols you write.

-- 
Ben.

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


#12520

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-03 14:27 -0600
Message-ID<f8KdnRcZ5MqwhuvHnZ2dnUU7-IHNnZ2d@giganews.com>
In reply to#12517
On 2/3/2018 7:37 AM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> 
>> On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
> <snip>
>>>> Then be completely specific about the error on the blog, I have at least
>>>> forty blog posts, and so far the closest you came to pointing out any error
>>>> was a vague assertion that I made some mistake somewhere.
>>>
>>> I was very explicit about the error when you posted it here.  You did
>>> not address it.  I can't imagine why you want me to tell you again but
>>> here goes...  At
>>>
>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>>
>>> you repeat the incorrect conclusion that "The HP proof counter-examples
>>> all get stuck in infinite recursion (never reaching states qy or qn)".
>>> This is incorrect and you reach this incorrect conclusion by making (at
>>> step (2)) and unwarranted assumption that is contrary to what you know
>>> about H^ a this point -- contrary to how H^ is defined.
>>
>> OK great you are getting specific here.
> 
> I have said all of this before and the key part (your main mistake)
> several times.  I'm not inclined to accuse you of dishonesty so I must
> assume that have not been reading the posts you are replying to.  Is
> that the case?
> 
>> It is not contrary to how H^ is defined.
> 
> Yes it is.  H^ is derived from H' which is derived from H which is
> assumed to be halt decider.  You must only make deductions that are
> consistent with this definition.
> 

I agree with this completely you disagree with it below.

>> I am working on proving this more unequivocally.
>>
>> The essential nature of the problem presented to H^ is inherently
>> infinitely recursive.
> 
> The essential nature of H^ is that it does not exist.  Thus the supposed
> problem (which involves [H^] -- that's my way of writing H^'s encoding)
> does not exist either.  You often loose track of this rather basic fact.
> 
>> Whether or not H^ actually executes infinite recursion is a different
>> question.
> 
> Actually it's the key question and the key to your error.  You keep
> saying (and you say it again below) that H^ really does execute
> indefinitely rather than transitioning to qy or qn in a finite number of

No I do not say this. I have said it before, I have retracted that now.
Since I just retracted that above you must not be paying enough attention.

> steps as per its definition.
>   
>> These are Facts:
>> After H^ makes a copy of its input
>> H^ must decide based on what H^2 H^3 would do.
>> H^2 would make a copy and then it would
>> decide based on what H^3 H^4 would do.
> 
> No.  There is only one "must" you can say about H^ -- it must transition
> to either qy or qn in a finite number of steps.

Ah, but, here is where you contradict yourself. If H^ inherits all
of its behavior from H and H (until it is contradicted) is a possible
halt decider (it has not be contradicted yet), then H could only
transition to its states entirely based on what H^ actually does.

If what H^ does is copy its input, then H must consider this as
a part of what H^ does. The next thing that H^ does from its state
qx is examine what H^2 would do on its input H^3.

Thus we have at least these necessary dependencies.
H depends on what H^ does which depends upon what H^2 does which
depends upon what H3 does.

Because we are assuming (until contradicted) that H is a halt decider
it must make an actual attempt at deciding, it must examine its input
and base its decision on what its input would do if this input was
executed by a UTM.

> 
> You then compound this error by talking about what strings do.  You
> really need to stop saying anything about what a string does.  If you
> are assuming that H^ is or behaves line a universal TM (thereby making
> the idea of a string doing something at least metaphorically
> reasonable), that too is an error.
> 

H examines what H^ actually would do if H^ was executed by a UTM.
If H determines that H^ would get stuck in infinite recursion then
H itself need not get stuck, H would simply transition to its final
state ((qn)).

>> The definition of the problem is infinitely recursive.
>> That does not necessarily entail that H^ would actually execute infinite recursion.
>>
>>> Oddly, to explain why H^ does not get to either qy or qn you write
>>>
>>>     q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>>     q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
>>
>> The potential halt decider and every instance of its input are all defined
>> to have exactly the same behavior.
> 
> Does this remark have anything to do with your incorrect use of Linz's
> notation?  Those two lines, which you keep writing to show the "infinite
> recursion", actually state the opposite.  

For simplicity of communication I am assuming that all labeled
machines are finite string Turing Machine Descriptions capable of
being executed by a UTM. This is like a David Hilbert formalist
approach where the formal language is Turing Machine descriptions.

Every instance of H^ executed by a UTM:
(1) Begins at its start state q0 with input w^
(2) Copies this input w^ to w^2 and transitions to its qx state
(3) Begins evaluating w^ w^2 at state qx

When H^ is executed by a UTM it performs these same steps.
When H^ is at its qx state its configuration looks like this: Ĥ qx [Ĥ2] [Ĥ3] ⊢*

Because [H^] is derived from H it must also determine what [Ĥ2] would do on
its input [Ĥ3] as if [Ĥ2]/[Ĥ3] was being executed on a UTM.

The fact that H^ inherits from H mandates these steps.

We have at least these necessary dependencies:
H depends on what H^ does which depends upon what H^2 does which depends upon what H3 does.

> Some correction of this error
> would be appreciated.  Either that or you could explain why you think
> those two lines support your case rather than directly refute it.  That
> would allow me to see what it is you've misunderstood about these two
> simple lines.
> 

I think that I may have been clear enough now that you will understand that I am correct.

>> This is the part that makes the inherent definition of the problem
>> infinitely recursive:
>>
>> Every instance of the above definition would begin at q0 copy its
>> input and then transition to qx.
> 
> The above is not a definition.  H^'s definition in given only in words
> and diagrams in Linz.  The two lines you are not understand say
> something (but not everything) about what H^ *does* in some particular
> cases.  It does *not* say (because that would be wrong) what you claim.

>>>     q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>>     q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn

This says that every instance of H^ (executed by a UTM)
begins at its start state,
copies its input and
then transitions to qx where it begins evaluating ŵ ŵ.

> 
>> If H^ would copy its input H^2 to H^3,
> 
> Don't keep inventing new, bad, notations.  There is no need to keep
> numbering strings, and you should not label them with a capital letter.
> H^2 looks like a machine, not a string.  If you stick with writing out
> configurations there can be no confusion.

As explained above I am using David Hilbert formalist approach to
eliminate the extraneous complexity of distinguishing between TM
and TMDs. Everything is a TMD, and H is executed by a UTM.

> 
> This is the initial configuration of H^, written out properly:
> 
>    q0 [H^]
> 
> q0 is the state of the machine, [H^] is the encoding of H^.  By the
> definition of H^, the following happens:
> 
>    q0 [H^] |-* qx [H^] [H^]
> 

That is a reasonable approach that eliminates verbosity.

> There is no need to keep writing H^ under the |- symbol since it's the
> only machine whose traces we will be writing.  

Actually I have switched to examining H evaluating [H^] [H^]
otherwise we are only proving that an otherwise correct halt
decider can be broken by appending infinite loops to its halt states.

> qx is the state of H^
> that corresponds to the initial state of H (and also of H').  This line
> says "after copying the input string, H^ behaves exactly like H'".
> 

Yes

> Also form the definition of H^ we may go on to say
> 
>    q0 [H^] |-* qx [H^] [H^] |-* qy oo    (that's an infinity symbol)
>    q0 [H^] |-* qx [H^] [H^] |-* qn
>    
> This says that H^ goes on to transition into either state qy or qn.
> This follows from the fact the H^ is now behaving like H' and H' is
> defined to do this.
> 

Not quite.

>> then H^2 would also copy its input H^3 to H^4
>> on and on...
> 
> H^2 is a string, confusingly named in a way that makes it look like a
> machine.  It does not copy anything.  Part of the reason you keep making
> these category errors is that you have no good notation to write what is
> going on.
> 

Not really H (no category error) must evaluate what [H^] would do one its
input [H^] as if [H^] was executed on a UTM. So that we can keep track of
the dependency chain I append subscripts to some of these TMDs.

H is evaluating what [H^] would do on its input [H^2] if [H^] was executed on a UTM.
The first thing that [H^] would do is copy its input [H^2] to [H^3].

> I know as well as anyone that what you write as H^2 (and I write as
> [H^]) is the encoding of a machine, but encodings -- even of machines --
> can't do anything.  They can be interpreted by a UTM, but it is still
> the UTM that is doing things, changing state and writing symbols and so
> on.
> 

All this is really just a general purpose computer executing a program.
So If the program (TMD) specifies an infinite loop then the computer
(UTM) would faithfully execute this infinite loop.


>  From what you write below it's clear that you talk of strings doing
> things because you can think of no other way that H could decide halting
> but to interpret (or run or evaluate) its input string.  However, that
> is one thing you can *not* assume about H (or the H' and H^ derived from
> it).
> 

That is not what I am saying at all. I am saying that H must determine
what [H^][H^] {would do} if it was executed on a UTM. This is not the same
thing as saying that H determines what H^ {does}. {would do} and {does}
are different things. H must determine what H^ {would do} within the
premise that (until contradicted) that H is a halt decider.

>>> which says exactly what you deny.  Those two lines happen to be correct
>>> and they state that H^ transitions into either state qn or state qy in a
>>> finite number of steps.
>>>
>>> There are, of course, lots of other errors.  (3) and (4) talk about
>>> strings doing things.  It might be poetry, but it's not mathematics.
>>
>> H^ evaluates what H^2 would do even if H^2 actually does nothing besides
>> just sit there. If H^2 was executed by a UTM it would copy its input.
>> H^ must decide what H^2 would do if it was executed by a UTM.
> 
> No.  You may not assume that H^ evaluates what H^2 would do.  Any
> argument that relies on such an unwarranted assumption must be
> rejected.

I am not assuming that, it is an aspect of the foundational premise
that H is (until contradicted) a halt decider. All halt deciders must
necessarily determine what their input {would do}. We are not allowed
to drop that foundational premise until it is contradicted.

> 
>>> You then go on to eliminate something that does no exist by showing a
>>> machine configuration that has nothing to do with the halting problem.
>>> Then you assert that the notation you clearly don't understand:
>>>
>>>     q0 ŵ ŵ2 ⊢* Ĥ qy ∞
>>>     q0 ŵ ŵ2 ⊢* Ĥ qn
>>>
>>> says that H^ *will* (in this case) transition to either state qy or qn
>>> in a finite number of steps.  But if you applied the (admittedly
>>> incorrect) argument you did a few lines previously you'd see it applies
>>> to this configuration as well.  You are not even consistently wrong.
>>
>> There is no infinitely recursive evaluation sequence defined in that
>> machine.
> 
> It does not matter.  This configuration is irrelevant.  You are fixing a
> non-extent problem in some computation by presenting a new computation
> that does not occur.  You happen to be wrong about this new computation
> as well, but since it does not matter, we should not waste time on it.
> 
> What matters is what happens in *this* configuration:
> 
>    q0 [H^]
> 
> not what happens in this new one you've pulled out of a hat:
> 
>    q0 [H^] [H^]

An execution trace of what H^ would when when executed by a UTM:
q0 [H^] ⊢* Ĥ qx [H^][H^]

> 
> <snip>
>> The two key errors that you claimed and I responded to are not errors at all.
>> Let's focus on the infinite recursion aspect.
> 
> Absolutely.  Nothing else matter after you make your unwarranted
> assumption about what H^ does, but it would help if you understood the
> notation you keep using since you keep contradicting your words with the
> symbols you write.
> 

I have spent over three hours on this single reply.
The second sentence below may take more than on hour to fully understand.

Halt Decider definition:
(1) A Halt Decider decides whether or not its input TMD would halt on its
input (as if this input TMD was executed on a UTM).

(2) This requires the halt decider to evaluate the chain-of-inference
leading to the halting or non halting behavior of the TMD.

This same Halt Decider definition applies recursively to every TMD in the inference chain.

Copyright 2015,2016,2017,2018 Pete Olcott

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

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


#12521

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-02-03 23:49 +0000
Message-ID<87k1vtzla4.fsf@bsb.me.uk>
In reply to#12520
Pete Olcott <Pete@NoEmail.address> writes:

> On 2/3/2018 7:37 AM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
<snip>
>>> Whether or not H^ actually executes infinite recursion is a different
>>> question.
>>
>> Actually it's the key question and the key to your error.  You keep
>> saying (and you say it again below) that H^ really does execute
>> indefinitely rather than transitioning to qy or qn in a finite number of
>
> No I do not say this. I have said it before, I have retracted that now.
> Since I just retracted that above you must not be paying enough
> attention.

Yes, it did look a bit like a retraction, but at no point did you
concede the key point.  Saying "whether or not H^ actually executes
infinite recursion is a different question" just sounded like hedging
unless you state that H^ will *never* get stuck in a loop (before the
loop at the very end) and will, instead, *always* get to state qy
or qn.

This is the key point and I would be very happy to see you that really
do now accept it.  Could you be clear and state unequivocally that you
agree that H^ always gets to state qy or state qn in a finite number of
steps?

This point is really the only one that matters.  All the other errors
are just details in comparison.

BTW, when did you last edit the blog post

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

?  It's still wrong, but it's less wrong than I remember it being,
despite being dated Jan 18.

<text removed>
-- 
Ben.

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


#12495

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

That assumption provide itself to be false. Once an assumption is
proven to be false that assumption no longer holds.

>Any other
> assumptions are unwarranted.  Anything else you say along the line of
> "H^ must always..." or "the only way H^ can..." are red-flags showing
> that you are making assumptions about behaviour with is entirely
> unknown.  You know only two significant facts about H^: one of which is
> that H^ always transitions to state qy or qn in a finite number of steps
> (the second is not currently important).

If we assume that a machine TM1 defined to count the tape head movements
of another machine TM2 halts, and this machine is instructed to count the
tape head movements of another machine TM2 that does not halt, then our
assumption is simply proven to be incorrect.

If we assume that a finite string evaluation sequence is finite, yet
this finite string evaluation sequence specifies infinite recursion
then our assumption that the finite string evaluation sequence is
finite is proven to be incorrect.

> 
>>> input.  H^ is built from a decider, and no decider can run (or emulate
>>> or evaluate) its input.  Such behaviour is ruled out from the start.
>>
>> The title of my final published paper will be:
>> The Halting Problem proof is merely the Liar Paradox in disguise.
> 
> An odd title (problems don't have proofs), but it does at least make it
> clear that you accept that the halting *theorem* (presumably that's what
> you meant) has a proof.
> 
>>> You have a notation for this which you wrote out:
>>>
>>>     qx w^ w^ |-H^ qy oo
>>>     qx w^ w^ |-H^ qn
>>>
>>> Do you know what that means?  If you do, why did you write it?  It is
>>> correct and it contradicts what you are saying in words.
>>
>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>> You left some key state transitions out:
> 
> No.  You don't know what this notation means so you think the part I
> left off matters.  I can't really help with that because I don't think
> you want to learn about the notation.
> 
>> Definition of Turing Machine Ĥ (state transition sequence)
>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
> 
> This contradicts what you are saying in words, and it backs up (it is in
> fact exactly) what I am saying with *my* words.  You clearly don't know
> what this notation means or you would not keep writing something that
> contradicts yourself again and again.

You know that is a lie. Quit lying.
H^ must examine what w^ does
this requires an examination of what w^2 does
which requires an examination of what w^3 does...

otherwise w^2 would simply transition to ((qn)) based on NULL input
which would cause w^ to transition to (qy)
which would cause H^ to transition to ((qn))

Thus H^ would correctly decide halting for w^ w^2.

In either case the HP proof counter-example fails to be a counter-example.

> 
> I've said this before, but I think you should stick to words.  It's a
> shame, because they can be so very ambiguous, but you don't seem to have
> the right mentality for formal notations.  Lots of the formulas you
> write are either under-specified (and thus have a sort of vague poetic
> quality) or are well-defined and say something you don't mean.
> 
> I repeat: those two lines are correct and they say what I am saying not
> what you are trying to say.
> 

No you have simply not devoted a single-minded focus sufficiently to see that this is not the case.

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

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


#12497

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

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

Exactly!!

Bells ring out over the land.  The people rejoice.  The long winter of
ignorance is over.

(You do know how a proof be contradiction works, yes?)

<snip>
>>>> You have a notation for this which you wrote out:
>>>>
>>>>     qx w^ w^ |-H^ qy oo
>>>>     qx w^ w^ |-H^ qn
>>>>
>>>> Do you know what that means?  If you do, why did you write it?  It is
>>>> correct and it contradicts what you are saying in words.
>>>
>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>> You left some key state transitions out:
>>
>> No.  You don't know what this notation means so you think the part I
>> left off matters.  I can't really help with that because I don't think
>> you want to learn about the notation.
>>
>>> Definition of Turing Machine Ĥ (state transition sequence)
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
>>
>> This contradicts what you are saying in words, and it backs up (it is in
>> fact exactly) what I am saying with *my* words.  You clearly don't know
>> what this notation means or you would not keep writing something that
>> contradicts yourself again and again.
>
> You know that is a lie. Quit lying.

No you appear not to know what the notation you are using means.  If you
did know you would write what you are claiming using that notation, but
instead you keep writing what I am saying.

It would be very much better if you would stop calling things you
disagree with lies.  Even convinced as you are that you know what that
notation means, there is no reason to suppose that I am lying about what
I think it means.

> H^ must examine what w^ does
> this requires an examination of what w^2 does
> which requires an examination of what w^3 does...

That is not what the notation says.  The notation says what I keep
telling you.  It's not ambiguous.  There is no room for
misunderstanding.  The |- with the * and the machine name are all quite
clear.  You keep saying (in symbols) that H^ always transitions from
state qx to either state qy or state qn in a finite number of steps.
Then you keep denying that in words despite saying it in symbols again
and again.

> otherwise w^2 would simply transition to ((qn)) based on NULL input
> which would cause w^ to transition to (qy)
> which would cause H^ to transition to ((qn))
>
> Thus H^ would correctly decide halting for w^ w^2.
>
> In either case the HP proof counter-example fails to be a
> counter-example.

There is no counter-example.  This is a proof by contradiction and you
have agreed above that the assumption being posited for rejection must
indeed be rejected.  (You have an invalid argument for that rejection,
but I am not going to quibble about that -- we both appear to agree now
that assuming that H is a halt decider leads to a contradiction.)

>> I've said this before, but I think you should stick to words.  It's a
>> shame, because they can be so very ambiguous, but you don't seem to have
>> the right mentality for formal notations.  Lots of the formulas you
>> write are either under-specified (and thus have a sort of vague poetic
>> quality) or are well-defined and say something you don't mean.
>>
>> I repeat: those two lines are correct and they say what I am saying not
>> what you are trying to say.
>
> No you have simply not devoted a single-minded focus sufficiently to
> see that this is not the case.

An educated reader can work out what the notation says in a few minutes.
You keep writing two lines that say exactly what you are trying to deny.
However long you have not spent on it you have not spent enough time to
understand the symbol you are throwing about.  It will vary from person
to person how many hours are needed, but since it's not a complicated
notation it might be worth your tying.

Or would could keep writing out what I am saying in symbols whilst
denying it in words.  That looks bonkers to educated onlookers, but it
suits me down to the ground.

-- 
Ben.

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


#12511

FromPete Olcott <Pete@NoEmail.address>
Date2018-02-01 21:15 -0600
Message-ID<xo-dnQx52bdTSu7HnZ2dnUU7-N_NnZ2d@giganews.com>
In reply to#12489
On 2/1/2018 7:54 PM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
> <snip>
>> In any case once we remove the infinite recursion H^ w^ w^2 becomes
>> decidable.
> 
> (a) There is no infinite recursion in the instance you keep quoting.  I
> have explained why your argument is wrong: you may assume nothing about
> H^'s behaviour after state qx other than the fact that it transitions to
> either state qy or qn in a finite number of steps.  Each H^ is derived
> from a machine H about which you know nothing at all except that it does
> as I keep telling you.  (Well, we know one more thing but that does not
> com into play until you accept the first.)
> 

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

None the less when I remove this "non existent" infinite recursion
H^ correctly decides whether or not one instance of its own TM description
would halt on another instance of its TM description.

Furthermore it is impossible to construct any single pair of finite string TM
descriptions that would confirm the HP proof conclusion.

The Halting Problem is about whether or not a TM exists that can decide
halting for a single TM input pair. No valid counter-examples exist.

Copyright 2016 2017 2018 Pete Olcott

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


#12514

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

> On 2/1/2018 7:54 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pete@NoEmail.address> writes:
>> <snip>
>>> In any case once we remove the infinite recursion H^ w^ w^2 becomes
>>> decidable.
>>
>> (a) There is no infinite recursion in the instance you keep quoting.  I
>> have explained why your argument is wrong: you may assume nothing about
>> H^'s behaviour after state qx other than the fact that it transitions to
>> either state qy or qn in a finite number of steps.  Each H^ is derived
>> from a machine H about which you know nothing at all except that it does
>> as I keep telling you.  (Well, we know one more thing but that does not
>> com into play until you accept the first.)
>>
>
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>
> None the less when I remove this "non existent" infinite recursion

You can't remove something that is not there.  What's more, if it is
there, it can't be "removed" by changing the input to H^ -- that's just
some other vaguely similar computation whose behaviour is of no
relevance to the case hypothesised in the proof.

> H^ correctly decides whether or not one instance of its own TM description
> would halt on another instance of its TM description.

H^ is not a decider, but that's the sort of detail you don't care about.
More significant, though, is that deciding one case is trivial.  No one
cares if some machine decides one case or not.

> Furthermore it is impossible to construct any single pair of finite string TM
> descriptions that would confirm the HP proof conclusion.

I wonder what that means.  What is "the HP proof"?  Problems don't have
proofs.  What is a "proof conclusion"?  Is it what everyone else calls a
theorem?  If so, how could any single anything confirm it?  And what
significance could there be to not being able to confirm it with some
single thing?

> The Halting Problem is about whether or not a TM exists that can decide
> halting for a single TM input pair.

No.  How many years have you been working on this?  Understanding the
problem should surely have been the very first step.  No wonder you are
confused about the proof if you can't even state the problem.

> No valid counter-examples exist.

Indeed.  Everyone agrees on that.

It seems that you don't yet know what the halting problem is.  I'd like
to think that maybe you just don't know how to express it in words, odd
though that would be after all this time, but I can't shake the thought
that maybe you really don't know what computational problem the halting
theorem is about.

-- 
Ben.

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


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

Back to top | Article view | comp.theory


csiph-web