Infinitely Recursive input on HP Proofs

[peteolcott]

http://LiarParadox.org/HP_Infinite_Recursion.pdf

As this page 319 of An Introduction to Formal Languages and Automata
by Peter Linz 1990 indicates

From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'.

q0 Wm |-* H-Hat q0 Wm Wm...

Page 320 indicates that we apply H-Hat to itself as input.

The problem is that every H-Hat needs a pair of inputs.

H-Hat takes an H-Hat as input and copies it so that it
can analyze how its input H-hat would analyze the copy
of H-Hat that it just made.

The input H-Hat would have to copy its own input H-Hat
so that it can analyze what its own input H-Hat would
do on its own input, on and on forever...

Copyright 2016 and 2017 Pete Olcott.

[Ben Bacarisse]

peteolcott <peteo...@gmail.com> writes:

> http://LiarParadox.org/HP_Infinite_Recursion.pdf
>
> As this page 319 of An Introduction to Formal Languages and Automata
> by Peter Linz 1990 indicates
>
> From H' we construct another Turing machine H-Hat. This new machine
> takes as input Wm, copies it then behaves exactly like H'.
>
> q0 Wm |-* H-Hat q0 Wm Wm...
>
> Page 320 indicates that we apply H-Hat to itself as input.

No, it shows H^ acting on w^ which is the representation of H^ in
{0,1}*.

> The problem is that every H-Hat needs a pair of inputs.

No. H^ needs nothing. Like any TM, it acts on a tape and has no
needs.

> H-Hat takes an H-Hat as input

No "an" H^. It takes *the* representation of H^ as input...

> and copies it so that it
> can analyze how its input H-hat would analyze the copy
> of H-Hat that it just made.

No, it copies it. It does this for no purpose at all. It might analyze
the input or it may not. It might take the square root of the input, or
it might immediately halt. H^ is simply H with an initial step. H is
arbitrary. For every possible Turing machine M, M^ can be constructed.

> The input H-Hat would have to copy its own input H-Hat
> so that it can analyze what its own input H-Hat would
> do on its own input, on and on forever...

You write as H^ has some "intent" where in fact H^ just copies the input
but is otherwise the same as H. If your humanising metaphors about what
H^ "would have" to do is intended to explain why, in your mind, no H
satisfying the requirements that were put on it can exist, then OK, but
I doubt your explanation will help anyone else to understand the proof.

<snip>
--
Ben.

[peteolcott]

On Sunday, March 12, 2017 at 6:25:55 AM UTC-5, Ben Bacarisse wrote:

The key thing to remember is that every instance of H-Hat must
have its own input H-Hat which it copies so that it can evaluate
the execution trace of its input H-Hat on this input H-Hat's
(copy of itself) input H-Hat. This creates an infinite sequence
of copies of H-Hat.

The above can be verified by an execution trace of the following
source code: q0 Wm |-* H-Hat q0 Wm Wm...

H-Hat begins at its start state q0 its with Wm (TMD of H-Hat)
input then |-* through a sequence of steps H-Hat copies its
input and and begins evaluating its input pair: Wm Wm at the
start state q0 of its input Wm (TMD of H-Hat) on its own input
the copied Wm (TMD of H-Hat).

The execution trace of the initial input Wm (TMD of H-Hat)
shows that it must proceed through the same steps listed
above with its input (the TMD of H-Hat copy of itself).
So it must make a copy of its own input so that the copy
of itself has input. This makes a new copy not shown above.

The execution trace of the initial input Wm (TMD of H-Hat)
copy of itself must also proceed through these same steps
on the copy of itself (copy of a copy) that the original
input Wm (TMD of H-Hat) had to perform. This adds one more
copy not shown above.

This goes on and one forever...

So the error of the Halting Problem, is identical in following cases:
(1) Truth Teller Paradox: x = "hasProperty(True(x))"
(2) Liar Paradox: x = "hasProperty(~True(x))"
(3) Incompleteness Theorem: G = "~(∃x) Dem(x, G)" // ** see below

The error is the because of the infinitely recursive structure
of the above problems the evaluation of the above finite strings
never completes.

The infinitely recursive structure of the above finite strings
can be unequivocally shown in my own Minimal Theory of Types (MToT).
This theory utterly eliminates all (Fred Brooks) inessential
complexity and it thus minimal in the absolute sense of the word.

** Derivation of simplified Incompleteness Theorem

Gödel's Proof by Nagel, Newman and Hofstadter 2001 edition

http://lipn.univ-paris13.fr/~duchamp/Books&more/Hofstadter/%5BErnest_Nagel,_James_R._Newman,_Douglas_R._Hofstad(BookFi.org).pdf

Pages 96 direct quote:
~(∃x) Dem(x, Sub(y, 17, y))

// Page 98 direct quote
we started with the formula having Gödel number
n; then we replaced all copies of ‘y’ in it by copies of
the numeral for n. And so, sub (n, 17, n) is the Gödel
number of G.

Pages 96-98 explained more clearly as:
n = Godel_Number("~(∃x) Dem(x, Sub(y, 17, y))") // Page 96
G = Sub(n, 17, n) // Page 98

After substitution
G is the Gödel number of this finite string: "~(∃x) Dem(x, G)"

Copyright Pete Olcott 2016, 2017

[Kaz Kylheku]

On 2017-03-12, peteolcott <peteo...@gmail.com> wrote:
> The key thing to remember is that every instance of H-Hat must
> have its own input H-Hat which it copies so that it can evaluate

The key thing is that Turing Machines do not have input. They have an
initial configuration, from which new states unfold according to the
machine rules.

What we understand as "input" is folded into the initial configuration.

If a computational function is modeled in terms of the Turing machine
concept, what happens is that for each possible input to the function,
we have a different Turing machine.

[Ben Bacarisse]

peteolcott <peteo...@gmail.com> writes:

I've cut everything I wrote because you decided not to address any of
the points.

> The key thing to remember is that every instance of H-Hat must
> have its own input H-Hat which it copies so that it can evaluate
> the execution trace of its input H-Hat on this input H-Hat's
> (copy of itself) input H-Hat. This creates an infinite sequence
> of copies of H-Hat.

No. You once understood this theorem. Why not go back to the proof
that you did understand?

> The above can be verified by an execution trace of the following
> source code: q0 Wm |-* H-Hat q0 Wm Wm...
>
> H-Hat begins at its start state q0 its with Wm (TMD of H-Hat)
> input then |-* through a sequence of steps H-Hat copies its
> input and and begins evaluating its input pair: Wm Wm at the
> start state q0 of its input Wm (TMD of H-Hat) on its own input
> the copied Wm (TMD of H-Hat).
>
> The execution trace of the initial input Wm (TMD of H-Hat)
> shows that it must proceed through the same steps listed
> above with its input (the TMD of H-Hat copy of itself).
> So it must make a copy of its own input so that the copy
> of itself has input. This makes a new copy not shown above.

You don't understand either the notion being used or the textual
explanation the Linz gives, because this description has nothing to do
with the H^ described in the book.

It seem you think H^ must execute its description, Wm, as if it were
some sort of universal TM. I don't know where you get that from but
it's not in Linz and it's not what's H^ does at all.

<snip the rest derived from this misunderstanding>
--
Ben.

[peteolcott]

On Sunday, March 12, 2017 at 10:14:09 PM UTC-5, Ben Bacarisse wrote:

I did have to make some corrections, yet the essential meaning remains unchanged.

H-Hat source code from quoted from page 319
q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞
q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2

Meaning of |-* quoted from page 237
The symbols |-* and |-+ will have the usual meaning of an arbitrary number of moves.

Page 319 quote
From H' we construct another Turing machine H^. This new machine
takes as input WM, copies it, and then behaves exactly like H'.

"0 Wm": H^ begins at its own q0 with Wm (TMD of itself) as its input

"|-*": H^ proceeds through a number of steps to copy its input

"H^ q0 Wm Wm |-*" and then behaves exactly like H'

After the corrections that I made it is clear that the infinitely
recursive aspect of H^ occurs in the second |-* of the source code
when H^ evaluates Wm Wm.

This would seem to be a mistake on the original author's part
because if H^ did begin again at its actual start state it would
then make another copy of its input.

So we will correct the Linz notational convention to say this:

// We changed the second q0 to qx
q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2

So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
the execution trace of Wm_1 indicates that it makes a copy of Wm_2
which for clarity we will call Wm_3.

The next step of the execution trace of Wm_1 indicates that it begins
its own evaluation execution trace of Wm_2 Wm_3.

The execution trace of Wm_2 indicates that it makes a copy of Wm_3
which for clarity we will call Wm_4.

> It seem you think H^ must execute its description, Wm, as if it were
> some sort of universal TM. I don't know where you get that from but
> it's not in Linz and it's not what's H^ does at all.
>

There is no need for H^ to be a universal Turing Machine
I have no idea how you misconstrued my words to mean that.

That the Linz example has H^ use its own description as its
input can be verified by this direct quote from page 320:

Now H^ is a Turing machine, so that it will have some
description in ∑*, say w^. This string, in addition to
being the description of H^ can also be used as input
string. We can therefore legitimately ask what would
happen if H^ is applied to w^.

[peteolcott]

On Sunday, March 12, 2017 at 2:34:55 PM UTC-5, Kaz Kylheku wrote:

> On 2017-03-12, peteolcott <peteolcott> wrote:
> > The key thing to remember is that every instance of H-Hat must
> > have its own input H-Hat which it copies so that it can evaluate
>
> The key thing is that Turing Machines do not have input. They have an
> initial configuration, from which new states unfold according to the
> machine rules.
>

http://LiarParadox.org/HP_Infinite_Recursion.pdf
Direct quote from Page 319
The input to H will be the description (encoded in some form) of M, say
WM, as well as the input w.

> What we understand as "input" is folded into the initial configuration.
>

In any case my execution trace of this source code: q0 Wm |-* H-Hat q0 Wm Wm... definitely shows that when H-Hat evaluates its input it gets stuck
in an infinite loop and thus never makes it to its altered final states.

Finite strings showing the infinitely recursive error of other self reference paradoxes:

(1) Truth Teller Paradox: x = "hasProperty(True(x))"
(2) Liar Paradox: x = "hasProperty(~True(x))"
(3) Incompleteness Theorem: G = "~(∃x) Dem(x, G)"

Copyright 2016, 2017 Pete Olcott

So now after decades of work it seems that I have finally shown exactly
how all of these self-reference paradoxes are merely erroneous.

[peteolcott]

Yes and following this theory that you just stated every instance of the Halting Problem specification has the same infinitely recursive evaluation sequence as the above list of three paradoxes.

So if the Halting Problem is a math problem this would unequivocally prove its erroneous nature. Any finite string that has an infinitely long evaluation sequence is not a truth bearer / logical proposition.

Thus when we evaluate the truth of the following:
- (1) Truth Teller Paradox: x = "hasProperty(True(x))"
- (2) Liar Paradox: x = "hasProperty(~True(x))"
- (3) Incompleteness Theorem: G = "~(∃x) Dem(x, G)"

Since none of them are finite strings representing truth bearers /
logical propositions we might have well have asked if the following
finite string is true or false: "jf58 dg5d sdf6d 6msd"

This becomes much more obvious when I translate predicate logic
into my Minimal Type Theory expressed as a Directed Acyclic Graph.

*** NOTE ***
I made the claim in this forum several years ago that the erroneous nature of these paradoxes could be seen when we attempt to translate them into their Directed Acyclic Graph representation.

It took me all of these years to sufficiently elaborate my Minimal Type Theory (MTT) so that this point could be proven.

When we represent predicates and their arguments as nodes in a DAG:

"Seven is greater than Five."
Integer-Greater-Than(Seven, Five)
(1) Integer-Greater-Than --->(2)(3) // binary tree, thus acyclic
(2) Seven
(3) Five

"This sentence is not true."
∃x ∈ finite strings
∃True ∈ Predicates
∃hasProperty ∈ Predicates |
x = "hasProperty(~True(x))"

(1) hasProperty ---> (2) // Alias for x
(2) Negation ---> (3)
(3) True ---> (1) // introduces a cycle, thus not acyclic

G = "~(∃x) Dem(x, G)"

(1) Negation ---> (2) // Alias for G
(2) There-Exists ---> (3)
(3) Dem ---> (4)(1) // introduces a cycle, thus not acyclic
(4) x

Copyright 2017 Pete Olcott

[Ben Bacarisse]

I'll cut to the chase...
peteolcott <peteo...@gmail.com> writes:
<snip>

> So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
> the execution trace of Wm_1 indicates that it makes a copy of Wm_2
> which for clarity we will call Wm_3.
>
> The next step of the execution trace of Wm_1 indicates that it begins
> its own evaluation execution trace of Wm_2 Wm_3.
>
> The execution trace of Wm_2 indicates that it makes a copy of Wm_3
> which for clarity we will call Wm_4.

None of the Wm have an execution trace. They are stings in the alphabet
of the TM H (and H^). The only thing that can have has any "execution
trace" is H^ and we have no idea what it does after copying the tape
other than it behaves like some other machine called H.

You don't understand Linz's notation, and you don't understand what H^
is. And, as usual, you a confusing machines with representations of
machines.

<snip>
--
Ben.

[peteolcott]

On Sunday, March 12, 2017 at 2:34:55 PM UTC-5, Kaz Kylheku wrote:

Yes, I agree. That means that we are asking H^ to evaluate whether or not an infinite string representing an infinite sequence of Turing Machines halts on each of their inputs.

This way of looking it precisely corresponds to the logical error of these:
-> (1) Truth Teller Paradox: x = "hasProperty(True(x))"
-> (2) Liar Paradox: x = "hasProperty(~True(x))"
-> (3) Incompleteness Theorem: G = "~(∃x) Dem(x, G)"

If the above strings were even syntactically correct WFF of predicate logic then they would be semantically incorrect on the basis that the evaluation of these strings is an infinite sequence.

A formula {A} is a syntactic consequence within some
formal system {FS} of a set {Gamma} of formulas if there
is a formal proof in {FS} of {A} from the set {Gamma}:
∃A ∈ FS, ∃Gamma ∈ FS | (Gamma ⊢ A)

Tarski's formal correctness of True formula: ∀x True(x) ↔ φ(x)
The following formula defines: φ(x) as (Gamma ⊢ A)
∀A ∈ finite strings, ∃Gamma ∈ FS | (Gamma ⊢ A) ↔ True(A)

// Corrected H^ source from page 319

q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2

// Just to minimize the complexity of the analysis
// and thus provide cognitive leverage ala Fred Brooks
// elimination of inessential complexity:
// We assume that H^ is a Turing Machine Description
// that is executed within a Universal Turing Machine.

H^(Wm) ↔ H^(H^)

Halts(H^, H^) = ∃x ∈ H^ | x ⊢ H^.((qn))
~Halts(H^, H^) = ∃x ∈ H^ | x ⊢ H^.((qy))

Halts(H^, H^) is defined as: There exists a sequence of steps in H^ such that H^(H^) halts in its final state ((qn)).

~Halts(H^, H^) is defined as: There exists a sequence of steps in H^ such that H^(H^) transitions to its state ((qy)).

[Ben Bacarisse]

peteolcott <peteo...@gmail.com> writes:
<snip>
> ... That means that we are asking H^ to evaluate whether or

> not an infinite string representing an infinite sequence of Turing
> Machines halts on each of their inputs.

No. The only thing asked of H^ is to copy its finite input tape and
then act as H' does (H' is a machine derived from the supposed halting
decider H).

<snip>

> // Corrected H^ source from page 319
> q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2

That's not a correction unless you explain what qx is. Here, I actually
agree with you -- his notation does not capture what the text says. You
should say what qx is and how that makes the argument watertight. Can
you do that?

<snip>
--
Ben.

[peteolcott]

On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote:
> I'll cut to the chase...

> peteolcott <peteolcott> writes:
> <snip>
> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2
> > which for clarity we will call Wm_3.
> >
> > The next step of the execution trace of Wm_1 indicates that it begins
> > its own evaluation execution trace of Wm_2 Wm_3.
> >
> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3
> > which for clarity we will call Wm_4.
>
> None of the Wm have an execution trace. They are stings in the alphabet
> of the TM H (and H^). The only thing that can have has any "execution
> trace" is H^ and we have no idea what it does after copying the tape
> other than it behaves like some other machine called H.

To provide cognitive leverage and thus eliminate (Fred Brooks)
inessential complexity we will assume that the Turing Machine
Description of H^ is executed inside of (an interpreter)
Universal Turing Machine.

The purpose for making this simplifying assumption is so
that we can assume H^, w^ and Wm are all names of the same
literal string.

To provide a little more insight into what a potential halt
decider PHD might do to decide halting we could hypothesize
that it might simulate the execution of its input TMD in its
own UTM (interpreter). Since it could simulate this execution
step-by-step there is no risk that this PHD would get stuck
in an infinite loop.

With the above assumptions we could imagine the following syntax:
Execute(H^, H^) executes H^ with H^ input inside a UTM.

The H^ could execute its own internal command:
Simulate-Execute(Wm, Wm)

This would occur immediately after the first |-* in its source code;
--> H-Hat source code from quoted from page 319
--> q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞
--> q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2

|> Direct quote from page 320:

|> Now H^ is a Turing machine, so that it will have some
|> description in ∑*, say w^. This string, in addition to
|> being the description of H^ can also be used as input
|> string. We can therefore legitimately ask what would
|> happen if H^ is applied to w^.

H^ has a Turing Machine Description of w^.

According to the Linz quotes:
H^ is invoked with w^ input which it receives as Wm.

According to the simplifying assumptions:
H^, w^ and Wm are merely different names for the same literal string.

[peteolcott]

On Wednesday, March 15, 2017 at 3:40:05 PM UTC-5, Ben Bacarisse wrote:

> peteolcott <peteolcott> writes:
> <snip>
> > ... That means that we are asking H^ to evaluate whether or
> > not an infinite string representing an infinite sequence of Turing
> > Machines halts on each of their inputs.
>
> No. The only thing asked of H^ is to copy its finite input tape and
> then act as H' does (H' is a machine derived from the supposed halting
> decider H).

I explain this very much more clearly in my prior post to you.

>
> <snip>
> > // Corrected H^ source from page 319
> > q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> > q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
>
> That's not a correction unless you explain what qx is. Here, I actually
> agree with you -- his notation does not capture what the text says. You
> should say what qx is and how that makes the argument watertight. Can
> you do that?

qx is merely an arbitrary state immediately after H^ has copied its input. The text says that H^ returns to its own start state q0 which would have H^ stuck in infinite loop of only copying its input.

>
> <snip>
> --
> Ben.

[Ben Bacarisse]

peteolcott <peteo...@gmail.com> writes:

> On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote:
>> I'll cut to the chase...
>> peteolcott <peteolcott> writes:
>> <snip>
>> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
>> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2
>> > which for clarity we will call Wm_3.
>> >
>> > The next step of the execution trace of Wm_1 indicates that it begins
>> > its own evaluation execution trace of Wm_2 Wm_3.
>> >
>> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3
>> > which for clarity we will call Wm_4.
>>
>> None of the Wm have an execution trace. They are stings in the alphabet
>> of the TM H (and H^). The only thing that can have has any "execution
>> trace" is H^ and we have no idea what it does after copying the tape
>> other than it behaves like some other machine called H.
>
> To provide cognitive leverage and thus eliminate (Fred Brooks)
> inessential complexity we will assume that the Turing Machine
> Description of H^ is executed inside of (an interpreter)
> Universal Turing Machine.

That complicates matters -- so much so that you've lost track of the
argument altogether. You find it hard enough to separate machine from
representations without adding another layer of description.

> The purpose for making this simplifying assumption is so
> that we can assume H^, w^ and Wm are all names of the same
> literal string.
>
> To provide a little more insight into what a potential halt
> decider PHD might do to decide halting we could hypothesize
> that it might simulate the execution of its input TMD in its
> own UTM (interpreter). Since it could simulate this execution
> step-by-step there is no risk that this PHD would get stuck
> in an infinite loop.

You *could* make that hypothesis but it would render any conclusion you
draw from it contingent on it. The simpler argument (the one in Linz)
assumes only that H is a halting decider.

<snip>
--
Ben.

[peteolcott]

On Wednesday, March 15, 2017 at 10:23:24 PM UTC-5, Ben Bacarisse wrote:

> peteolcott <peteolcott> writes:
>
> > On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote:
> >> I'll cut to the chase...
> >> peteolcott <peteolcott> writes:
> >> <snip>
> >> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
> >> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2
> >> > which for clarity we will call Wm_3.
> >> >
> >> > The next step of the execution trace of Wm_1 indicates that it begins
> >> > its own evaluation execution trace of Wm_2 Wm_3.
> >> >
> >> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3
> >> > which for clarity we will call Wm_4.
> >>
> >> None of the Wm have an execution trace. They are stings in the alphabet
> >> of the TM H (and H^). The only thing that can have has any "execution
> >> trace" is H^ and we have no idea what it does after copying the tape
> >> other than it behaves like some other machine called H.
> >
> > To provide cognitive leverage and thus eliminate (Fred Brooks)
> > inessential complexity we will assume that the Turing Machine
> > Description of H^ is executed inside of (an interpreter)
> > Universal Turing Machine.
>
> That complicates matters -- so much so that you've lost track of the
> argument altogether. You find it hard enough to separate machine from
> representations without adding another layer of description.
>

It reduces the names from three(H^, w^, Wm) to one: H^

> > The purpose for making this simplifying assumption is so
> > that we can assume H^, w^ and Wm are all names of the same
> > literal string.
> >
> > To provide a little more insight into what a potential halt
> > decider PHD might do to decide halting we could hypothesize
> > that it might simulate the execution of its input TMD in its
> > own UTM (interpreter). Since it could simulate this execution
> > step-by-step there is no risk that this PHD would get stuck
> > in an infinite loop.
>
> You *could* make that hypothesis but it would render any conclusion you
> draw from it contingent on it. The simpler argument (the one in Linz)
> assumes only that H is a halting decider.
>

When ^H1(^H2, ^H3) is invoked ^H1 is evaluating what ^H2 would
do on its input ^H3. This requires ^H2 to know what ^H3 would
do on its input, yet it has no input.

> <snip>
> --
> Ben.

[Ben Bacarisse]

That hides a distinction that you need to have made as explicit as
possible. Other people might cope with it being hidden but I don't
think you can. Furthermore, you now introduce a machine whose execution
you remove from the explanation. This will confuse you even more.

>> > The purpose for making this simplifying assumption is so
>> > that we can assume H^, w^ and Wm are all names of the same
>> > literal string.
>> >
>> > To provide a little more insight into what a potential halt
>> > decider PHD might do to decide halting we could hypothesize
>> > that it might simulate the execution of its input TMD in its
>> > own UTM (interpreter). Since it could simulate this execution
>> > step-by-step there is no risk that this PHD would get stuck
>> > in an infinite loop.
>>
>> You *could* make that hypothesis but it would render any conclusion you
>> draw from it contingent on it. The simpler argument (the one in Linz)
>> assumes only that H is a halting decider.
>
> When ^H1(^H2, ^H3) is invoked ^H1 is evaluating what ^H2 would
> do on its input ^H3. This requires ^H2 to know what ^H3 would
> do on its input, yet it has no input.

The simplest course of action (for me) is for you to continue to ignore
what I say. My main purpose is to keep the record straight and your
failure to address these points will be a clear signal to future
readers that you don't know what's going on.

--
Ben.

[Ben Bacarisse]

peteolcott <peteo...@gmail.com> writes:

> On Wednesday, March 15, 2017 at 3:40:05 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peteolcott> writes:
<snip>

>> > // Corrected H^ source from page 319
>> > q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
>> > q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
>>
>> That's not a correction unless you explain what qx is. Here, I actually
>> agree with you -- his notation does not capture what the text says. You
>> should say what qx is and how that makes the argument watertight. Can
>> you do that?
>
> qx is merely an arbitrary state immediately after H^ has copied its
> input. The text says that H^ returns to its own start state q0 which
> would have H^ stuck in infinite loop of only copying its input.

Yes, but qx is not at all arbitrary. For H^ to behave like H', qx must
be the initial sate of H' (which is the initial state of H).

Personally, I would define H^ to have an initial state q0^ (the first of
the few extra states needed for the copying TM). That way, q0 remains
the name of the initial state of H' and H enabling one to write

q0^ Wm |-*H^ q0 Wm Wm

Anyway, I am glad that you now see that H^ does not loop endlessly
copying its input.

--
Ben.

[peteolcott]

I did not hide it at all.

Logical Premise (1)
I explicitly stated as an official premise to the logical analysis that we are to assume that H^ is a Turing Machine Description that is executed in a Universal Turing Machine.

Logical Premise(2)
I further stated as an additional logical premise that H^ is itself a special kind of Universal Turing Machine. The only difference between a typical UTM and H^ is that H^ is capable of single-stepping though its TMD input.

The only purpose of these additional premises is to gain substantial cognitive leverage by eliminating (Fred Brooks) inessential complexity.

With the first premise we cease to have the need of separately paying attention to three different names and two different representations:
(1) H^ Turing Machine
(2) w^ Turing Machine Description
(3) Wm TMD input to H^
This is now simplified as a single name: H^ and a single representation TMD.

>
> >> > The purpose for making this simplifying assumption is so
> >> > that we can assume H^, w^ and Wm are all names of the same
> >> > literal string.
> >> >
> >> > To provide a little more insight into what a potential halt
> >> > decider PHD might do to decide halting we could hypothesize
> >> > that it might simulate the execution of its input TMD in its
> >> > own UTM (interpreter). Since it could simulate this execution
> >> > step-by-step there is no risk that this PHD would get stuck
> >> > in an infinite loop.
> >>
> >> You *could* make that hypothesis but it would render any conclusion you
> >> draw from it contingent on it. The simpler argument (the one in Linz)
> >> assumes only that H is a halting decider.
> >
> > When ^H1(^H2, ^H3) is invoked ^H1 is evaluating what ^H2 would
> > do on its input ^H3. This requires ^H2 to know what ^H3 would
> > do on its input, yet it has no input.
>
> The simplest course of action (for me) is for you to continue to ignore
> what I say. My main purpose is to keep the record straight and your
> failure to address these points will be a clear signal to future
> readers that you don't know what's going on.
>
> --
> Ben.

You are keeping the record straight that you continue to fail to understand what I am saying.

[peteolcott]

You did not notice that the author quit talking about H'

I only have to put |--- characters in front of every line because Google would automatically hide these quotes that I already said. If you did not keep ignoring what I say this would not be necessary.

|---Direct quote of page 319
|---From H' we construct another Turing machine H^. This new machine
|---takes as input WM, copies it, and then behaves exactly like H'.
|---Then the action of H^ is such that

|---q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞
|---q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2

|---Direct quote from page 320:
|---Now H^ is a Turing machine, so that it will have some
|---description in ∑*, say w^. This string, in addition to
|---being the description of H^ can also be used as input
|---string. We can therefore legitimately ask what would
|---happen if H^ is applied to w^.

Because of this mistake on your part you did not notice that
both references to the initial state q0 refer to the initial
state of H^. Thus you did not notice that the above source
code indicates that H^ is stuck in an infinite loop of copying
its input.

Since I have two patents on finite state machines I really do
understand how state transitions work:
US7046848B1
US9171207B1

This minor error on the Linz's part is easily corrected:
---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
Where qx is defined as the state immediately after the input has been copied.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Thursday, March 16, 2017 at 9:09:16 AM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peteolcott> writes:
>>
>> > On Wednesday, March 15, 2017 at 3:40:05 PM UTC-5, Ben Bacarisse wrote:
>> >> peteolcott <peteolcott> writes:
>> <snip>
>> >> > // Corrected H^ source from page 319
>> >> > q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
>> >> > q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
>> >>
>> >> That's not a correction unless you explain what qx is. Here, I actually
>> >> agree with you -- his notation does not capture what the text says. You
>> >> should say what qx is and how that makes the argument watertight. Can
>> >> you do that?
>> >
>> > qx is merely an arbitrary state immediately after H^ has copied its
>> > input. The text says that H^ returns to its own start state q0 which
>> > would have H^ stuck in infinite loop of only copying its input.
>>
>> Yes, but qx is not at all arbitrary. For H^ to behave like H', qx must
>> be the initial sate of H' (which is the initial state of H).
>>
>> Personally, I would define H^ to have an initial state q0^ (the first of
>> the few extra states needed for the copying TM). That way, q0 remains
>> the name of the initial state of H' and H enabling one to write
>>
>> q0^ Wm |-*H^ q0 Wm Wm
>>
>> Anyway, I am glad that you now see that H^ does not loop endlessly
>> copying its input.
>

> You did not notice that the author quit talking about H'

Who is "the author"? I (the author here) wanted to explain something to
you (well, anyone who might read the post) and that requires that I talk
about H'.

<snip>

> This minor error on the Linz's part is easily corrected:
> ---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> ---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
> Where qx is defined as the state immediately after the input has been
> copied.

Yes, specifically, the initial state of H (and H' since they can be seen
as having the same start state). As I explained above, it's simpler to
introduce a new name (q0^) for the initial state of H^ so you can write

q0^ Wm |-* H^ q0 Wm Wm |-* H^ ∞
q0^ Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2

It's obviously better to give new names to new states and keep the old
names for the old ones. Introducing a new name (qx) for an old state
(q0 of H) just complicates matters.

So, do you now understand Linz's proof? You can't think that H^ copies
the tape endlessly anymore, so is there any other point that you are
having trouble with?

--
Ben.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:
<snip>

> Logical Premise (1)
> I explicitly stated as an official premise to the logical analysis
> that we are to assume that H^ is a Turing Machine Description that is
> executed in a Universal Turing Machine.
>
> Logical Premise(2)
> I further stated as an additional logical premise that H^ is itself a
> special kind of Universal Turing Machine. The only difference between
> a typical UTM and H^ is that H^ is capable of single-stepping though
> its TMD input.
>
> The only purpose of these additional premises is to gain substantial
> cognitive leverage by eliminating (Fred Brooks) inessential
> complexity.

None the less, if you add premises, your conclusions will be contingent
on them. Linz's proof of the halting theorem does not require either of
these. If you think you can write out a proof that is simpler using
your, to my mind, more complex framework, please do so. Then it will be
obvious which way is better.

<snip>
--
Ben.

[peteolcott]

On Thursday, March 16, 2017 at 4:54:25 PM UTC-5, Ben Bacarisse wrote:

If I am talking about what Linz is saying about H^. H' changes the subject of my execution trace of H^.

An ordinary purely sequential execution trace of H^ on its input would never reach the H' infinite loop. If H^ was analyzing what its input does entirely on the basis of executing its input in sequential order, then H^ would be stuck in infinite recursion and never make it to its own ((y)) or ((n)) states.

You have to really pay very close attention to see this. I

> <snip>
> > This minor error on the Linz's part is easily corrected:
> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
> > Where qx is defined as the state immediately after the input has been
> > copied.
>
> Yes, specifically, the initial state of H (and H' since they can be seen
> as having the same start state). As I explained above, it's simpler to
> introduce a new name (q0^) for the initial state of H^ so you can write

No, No, No No. When H' is created from H its modifications create entirely new source-code.

That they have things in common with the original, source code is irrelevant.

The convention is that every finite state machine always begins in its own start state of 0. Zero is used because zero is an integer index into a state transition matrix.

Textbooks never ever use different naming conventions for the start state different finite state machines.

>
> q0^ Wm |-* H^ q0 Wm Wm |-* H^ ∞
> q0^ Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2
>
> It's obviously better to give new names to new states and keep the old
> names for the old ones. Introducing a new name (qx) for an old state
> (q0 of H) just complicates matters.

The first q0 is the start state of H^. the second q0 is also the start state of H^ yet H^ is not in its start state anymore because it has just copied its input. The second q0 refers to H^ and says that it has not copied its input yet.

The second q0 is the H^ state after it has copied its input, call it qc for copied input. Linz already has qy for Yes and qn for no.

>
> So, do you now understand Linz's proof? You can't think that H^ copies
> the tape endlessly anymore, so is there any other point that you are
> having trouble with?
>
> --
> Ben.

His source code does indicate the H^ does copy its own endlessly in an infinite loop. Since his intention was to show the Halting Problem then this aspect is a mistake on the part of Linz.

q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

Now with this corrected source code (unless H^ is smart) it is stuck in infinite recursion copying its input.

If we assume the simplest possible case where H^ attempts to be a halt decider by simply executing every step of its input we see that this creates an infinite sequence of copies that each never reach their own q((y)) or q((n)) states.

I know this is the case because of the 2000 hours that I spent since last June studying the Liar Paradox. Amazingly enough Gödel’s first Incompleteness Theorem makes this same mistake:

Only a single page of text here:
http://LiarParadox.org/Minimal_Type_Theory.pdf

[peteolcott]

On Thursday, March 16, 2017 at 5:00:11 PM UTC-5, Ben Bacarisse wrote:

> peteolcott <peterolcott> writes:
> <snip>
> > Logical Premise (1)
> > I explicitly stated as an official premise to the logical analysis
> > that we are to assume that H^ is a Turing Machine Description that is
> > executed in a Universal Turing Machine.
> >
> > Logical Premise(2)
> > I further stated as an additional logical premise that H^ is itself a
> > special kind of Universal Turing Machine. The only difference between
> > a typical UTM and H^ is that H^ is capable of single-stepping though
> > its TMD input.
> >
> > The only purpose of these additional premises is to gain substantial
> > cognitive leverage by eliminating (Fred Brooks) inessential
> > complexity.
>
> None the less, if you add premises, your conclusions will be contingent
> on them.

The first premise merely makes discussing the analysis very much less clumsy and does not change the underlying semantic meaning at all.

Instead of Talking about TM H^, TMD w^ and TMD Wm inputto TM H^ we gain significant cognitive leverage by focusing entirely on TMD H^.

> Linz's proof of the halting theorem does not require either of
> these. If you think you can write out a proof that is simpler using
> your, to my mind, more complex framework, please do so. Then it will be
> obvious which way is better.
>
> <snip>
> --
> Ben.

All the first premise did is eliminate the need for three different names talking about two kinds of things. We have a single TMD H^ that is executed with itself as input. We don't have to pay attention to how this is accomplished we only need to know that this simplification is possible and does not change a thing.

[Ben Bacarisse]

First not sentence. Second not answer my question.

> An ordinary purely sequential execution trace of H^ on its input would
> never reach the H' infinite loop. If H^ was analyzing what its input
> does entirely on the basis of executing its input in sequential order,
> then H^ would be stuck in infinite recursion and never make it to its
> own ((y)) or ((n)) states.
>
> You have to really pay very close attention to see this. I

So long as you know what you mean by all that, there's no need for me to
comment on it.

>> <snip>
>> > This minor error on the Linz's part is easily corrected:
>> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
>> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
>> > Where qx is defined as the state immediately after the input has been
>> > copied.
>>
>> Yes, specifically, the initial state of H (and H' since they can be seen
>> as having the same start state). As I explained above, it's simpler to
>> introduce a new name (q0^) for the initial state of H^ so you can write
>
> No, No, No No. When H' is created from H its modifications create
> entirely new source-code.

TMs have no source code. By all means think of each derived machine as
having new states but you still have to find some way to relate them.
You need to say that qx is the initial state of H or H' or your notation
means nothing.

> That they have things in common with the original, source code is
> irrelevant.

What an extraordinary remark. That the machines H, H' and H^ have
things in common is exactly the crux of the argument.

> The convention is that every finite state machine always begins in its
> own start state of 0. Zero is used because zero is an integer index
> into a state transition matrix.
>
> Textbooks never ever use different naming conventions for the start
> state different finite state machines.

You don't strike me as conventional, but one way or another you need to
explain what the states in your line are. You can't use q0 for the
start state of H^ and for the start state of what was H' but is now
incorporated into H^. I've offered my clarification but you have not
given your alternative.

>> q0^ Wm |-* H^ q0 Wm Wm |-* H^ ∞
>> q0^ Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2
>>
>> It's obviously better to give new names to new states and keep the old
>> names for the old ones. Introducing a new name (qx) for an old state
>> (q0 of H) just complicates matters.
>
> The first q0 is the start state of H^. the second q0 is also the start
> state of H^ yet H^ is not in its start state anymore because it has
> just copied its input. The second q0 refers to H^ and says that it has
> not copied its input yet.
>
> The second q0 is the H^ state after it has copied its input, call it
> qc for copied input. Linz already has qy for Yes and qn for no.

I think you see the problem but you are not offering any better
solution. If you don't like mine, you need to come up with your own.

>> So, do you now understand Linz's proof? You can't think that H^ copies
>> the tape endlessly anymore, so is there any other point that you are
>> having trouble with?
>>
>> --
>> Ben.
>
> His source code does indicate the H^ does copy its own endlessly in an
> infinite loop. Since his intention was to show the Halting Problem
> then this aspect is a mistake on the part of Linz.

Yes, it is but are you able to understand the proof now? The text makes
it clear so you might have been able to follow the proof despite this
detail. I can always have another go at explaining it if you like.

> q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
> q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
>
> Now with this corrected source code (unless H^ is smart) it is stuck
> in infinite recursion copying its input.

That's neither source code nor a correction. I'm wondering if you even
know what this notation that Linz uses means. I explained how to
correct it, but since you've rejected my correction, you need to come up
with your own.

> If we assume the simplest possible case where H^ attempts to be a halt
> decider by simply executing every step of its input we see that this
> creates an infinite sequence of copies that each never reach their own
> q((y)) or q((n)) states.

Yes, because there is an error in the notation. You should know enough
by now to be able to correct the error, but I don't think you know what
the notation means.

An error in a proof does not make the theorem incorrect. In this case
it's trivial to correct this error -- you just need to make the notation
reflect the what text describes. Can you do that?

<snip>
--
Ben.

[peteolcott]

The author is Linz and he totally redefined H' which became H^, then he stopped talking about H' and only talked about H^.

> > If I am talking about what Linz is saying about H^. H' changes the
> > subject of my execution trace of H^.
>
> First not sentence. Second not answer my question.

I am only elaborating everything that Linz is saying about how H^ is defined and how Linz described its state transition matrix. The key part is exactly what happens when H^ is applied to w^.

>
> > An ordinary purely sequential execution trace of H^ on its input would
> > never reach the H' infinite loop. If H^ was analyzing what its input
> > does entirely on the basis of executing its input in sequential order,
> > then H^ would be stuck in infinite recursion and never make it to its
> > own ((y)) or ((n)) states.
> >
> > You have to really pay very close attention to see this. I
>
> So long as you know what you mean by all that, there's no need for me to
> comment on it.
>

I need for you to understand what I am saying. The only reason that I am talking to you is so that I can find words that are clear enough that others can understand exactly what I am saying. For many years my ideas were only stored in my mind as intuitions. Now through my Minimal Type Theory and Predicate Logic I can finally formalize these ideas.

> >> <snip>
> >> > This minor error on the Linz's part is easily corrected:
> >> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> >> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2
> >> > Where qx is defined as the state immediately after the input has been
> >> > copied.
> >>
> >> Yes, specifically, the initial state of H (and H' since they can be seen
> >> as having the same start state). As I explained above, it's simpler to
> >> introduce a new name (q0^) for the initial state of H^ so you can write
> >
> > No, No, No No. When H' is created from H its modifications create
> > entirely new source-code.
>

I am calling Linz's description of H^ state transition matrix source code, this would be obvious to anyone that understood state transition matrices.
+++ q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
+++ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

The last time that I told you this I did it by direct quotes that you must have ignored or I would not have to say this all again.

I will describe it step by (I think I already did this once)
q0 // H^ start state
Wm // Input to H^
|-* // an arbitrary number of state transitions that copy Wm
H^ qc Wm Wm // H^ has copied its input and is beginning to analyze WmWm
|-* // H^ make an arbitrary number of state transitions
H^ // transitions to Infinity or qn with final tape position y2

> TMs have no source code.

You have never heard of a Turing Machine Description TMD that is executed within a Universal Turing Machine UTM ?
(Well now you have, and thus know what TM source code is called).

> By all means think of each derived machine as
> having new states but you still have to find some way to relate them.
> You need to say that qx is the initial state of H or H' or your notation
> means nothing.

The whole sequence above is talking about the state transitions of H^.
The description already made that perfectly clear

> >> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ ∞
> >> > ---q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2

Do you see the little H^ that comes before the qx ? What do you think that means?

>
> > That they have things in common with the original, source code is
> > irrelevant.
>
> What an extraordinary remark. That the machines H, H' and H^ have
> things in common is exactly the crux of the argument.
>
> > The convention is that every finite state machine always begins in its
> > own start state of 0. Zero is used because zero is an integer index
> > into a state transition matrix.
> >
> > Textbooks never ever use different naming conventions for the start
> > state different finite state machines.
>
> You don't strike me as conventional, but one way or another you need to
> explain what the states in your line are. You can't use q0 for the
> start state of H^ and for the start state of what was H' but is now
> incorporated into H^. I've offered my clarification but you have not
> given your alternative.

From the bottom of the page 319 to to the top of the page 310 Linz is only talking about H^.

Bottom of page 319

From H' we construct another Turing machine H^.

>

> >> q0^ Wm |-* H^ q0 Wm Wm |-* H^ ∞
> >> q0^ Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2
> >>
> >> It's obviously better to give new names to new states and keep the old
> >> names for the old ones. Introducing a new name (qx) for an old state
> >> (q0 of H) just complicates matters.
> >
> > The first q0 is the start state of H^. the second q0 is also the start
> > state of H^ yet H^ is not in its start state anymore because it has
> > just copied its input. The second q0 refers to H^ and says that it has
> > not copied its input yet.
> >
> > The second q0 is the H^ state after it has copied its input, call it
> > qc for copied input. Linz already has qy for Yes and qn for no.
>
> I think you see the problem but you are not offering any better
> solution. If you don't like mine, you need to come up with your own.
>
> >> So, do you now understand Linz's proof? You can't think that H^ copies
> >> the tape endlessly anymore, so is there any other point that you are
> >> having trouble with?
> >>
> >> --
> >> Ben.
> >
> > His source code does indicate the H^ does copy its own endlessly in an
> > infinite loop. Since his intention was to show the Halting Problem
> > then this aspect is a mistake on the part of Linz.
>
> Yes, it is but are you able to understand the proof now? The text makes
> it clear so you might have been able to follow the proof despite this
> detail. I can always have another go at explaining it if you like.

Because I literally spent 2000 hours since June mathematically formalizing the notion of pathological self-reference using my own Minimal Theory of Types I understand the that this proof necessarily specified infinite recursion.

I can now mathematically formalize the term [pathological self reference] that I brought up here years ago.

Here it is in plain English:
Pathological self reference is self-reference such that the evaluation of an expression derives a cycle in its otherwise acyclic directed graph. I said this much years ago too. Now I actually have the Minmal Type Theory math to show it:

http://LiarParadox.org/

Finite string x asserts that it has the property of the negation of the Boolean value result of evaluating predicate True with itself as the only argument to True.

“This sentence is not true.”

∃x ∈ finite strings
∃True ∈ Predicates
∃hasProperty ∈ Predicates |

x = “hasProperty(~True(x))”

Minimal Type Theory expressed as Directed Graph
(1) hasProperty —> (2) // x is an alias for this node
(2) Not —> (3)
(3) True —> (1) // cycle indicates evaluation infinite loop

A formula z is a syntactic consequence within some formal system L
of a set Γ of formulas if there is a formal proof in L of z from the set Γ:
∃z ∈ L, ∃Γ ∈ L | (Γ ⊢ z)

// This formula defines the unary predicate: True(x)
True(x) ↔ ∀x ∈ finite strings, ∃Γ ∈ L | (Γ ⊢ x)

Here are the key details of Minimal Type Theory
http://LiarParadox.org/Minimal_Type_Theory.pdf

>
> > q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
> > q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
> >
> > Now with this corrected source code (unless H^ is smart) it is stuck
> > in infinite recursion copying its input.
>
> That's neither source code nor a correction.

The Turing Machine Description of a TM that is executed within a Universal Turing Machine IS THE SOURCE CODE OF TM.

> I'm wondering if you even
> know what this notation that Linz uses means. I explained how to
> correct it, but since you've rejected my correction, you need to come up
> with your own.
>
> > If we assume the simplest possible case where H^ attempts to be a halt
> > decider by simply executing every step of its input we see that this
> > creates an infinite sequence of copies that each never reach their own
> > q((y)) or q((n)) states.
>
> Yes, because there is an error in the notation. You should know enough
> by now to be able to correct the error, but I don't think you know what
> the notation means.
>

I totally explained it twice now. If you really think that I do not understand it and you really do understand it you would be able to point out any errors.

> An error in a proof does not make the theorem incorrect. In this case
> it's trivial to correct this error -- you just need to make the notation
> reflect the what text describes. Can you do that?
>
> <snip>
> --
> Ben.

I already did that twice and explained every detail. Even though I explained every detail you continue to make vague statements that you think that I do not understand.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Friday, March 17, 2017 at 8:39:09 PM UTC-5, Ben Bacarisse wrote:

<snip>

> I am calling Linz's description of H^ state transition matrix source
> code, this would be obvious to anyone that understood state transition
> matrices.

Of course it's obvious -- it's just wrong. Source code is not the right
way to refer to states and state transitions. It's not even the right
way to refer to an encoded TM. If you want to be understood, use the
right words.

> +++ q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> +++ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
>
> The last time that I told you this I did it by direct quotes that you
> must have ignored or I would not have to say this all again.
>
> I will describe it step by (I think I already did this once)
> q0 // H^ start state
> Wm // Input to H^
> |-* // an arbitrary number of state transitions that copy Wm
> H^ qc Wm Wm // H^ has copied its input and is beginning to analyze WmWm

That's saying more than you know. All you know is that H^ now "behaves
exactly like H'". The best way to explain that is to state that qc is
the name you've given to what was the initial state of H' (and H) but
even if you don't like this formal notation, the text says it
explicitly: "After that it [H^] behaves exactly like H'".

> |-* // H^ make an arbitrary number of state transitions
> H^ // transitions to Infinity or qn with final tape position y2
>

I don't know why you keep saying this. You've renamed a state (a good
idea as I've said several times) so you should be able understand
Lintz's proof now.

It's a remarkably simple proof and it has very few steps. I really
don't know what your problem is with it. I can' help unless you say
what it is that is confusing you.

If you were a student of mine, I'd make it very concrete. I'd give you
an actual machine H and ask you do write down H' and then H^. Then I'd
ask you to run through the execution of H^. Have you done that? Do
think you could do that?

<snip>

>> Yes, it is but are you able to understand the proof now? The text makes
>> it clear so you might have been able to follow the proof despite this
>> detail. I can always have another go at explaining it if you like.
>
> Because I literally spent 2000 hours since June mathematically
> formalizing the notion of pathological self-reference using my own
> Minimal Theory of Types I understand the that this proof necessarily
> specified infinite recursion.
>
> I can now mathematically formalize the term [pathological self
> reference] that I brought up here years ago.

But I don't care about that sort of waffle. My concern is whether you
understand Linz's proof. If not, would you like some help in
understanding it?

<snip>
--
Ben.

[peteolcott]

On Saturday, March 18, 2017 at 10:35:57 AM UTC-5, Ben Bacarisse wrote:

> peteolcott <peterolcott> writes:
>
> > On Friday, March 17, 2017 at 8:39:09 PM UTC-5, Ben Bacarisse wrote:
> <snip>
> > I am calling Linz's description of H^ state transition matrix source
> > code, this would be obvious to anyone that understood state transition
> > matrices.
>
> Of course it's obvious -- it's just wrong. Source code is not the right
> way to refer to states and state transitions. It's not even the right
> way to refer to an encoded TM. If you want to be understood, use the
> right words.

A Turing Machine Description IS the source code of a Turing Machine.
(as George Greene of sci.logic would say: you idiot).

>
> > +++ q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> > +++ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
> >
> > The last time that I told you this I did it by direct quotes that you
> > must have ignored or I would not have to say this all again.
> >
> > I will describe it step by (I think I already did this once)
> > q0 // H^ start state
> > Wm // Input to H^
> > |-* // an arbitrary number of state transitions that copy Wm
> > H^ qc Wm Wm // H^ has copied its input and is beginning to analyze WmWm
>
> That's saying more than you know. All you know is that H^ now "behaves
> exactly like H'".

I call bullshit. If H^ behaved EXACTLY like H' then it would not copy its input. Try and use your words with (as much as possible) 100% perfect precision. I already called you on this before when you referred to a true opinion, (contradiction in terms).

If you were not so sloppy in your interpretations you would have understood me years ago.

> The best way to explain that is to state that qc is
> the name you've given to what was the initial state of H' (and H) but
> even if you don't like this formal notation, the text says it
> explicitly: "After that it [H^] behaves exactly like H'".
>
> > |-* // H^ make an arbitrary number of state transitions
> > H^ // transitions to Infinity or qn with final tape position y2
> >
>
> I don't know why you keep saying this. You've renamed a state (a good
> idea as I've said several times) so you should be able understand
> Lintz's proof now.
>
> It's a remarkably simple proof and it has very few steps. I really
> don't know what your problem is with it. I can' help unless you say
> what it is that is confusing you.

Spend 2000 carefully going over this material again and again and NOT presuming that you already fully understand it. The biggest mistake of woefully fallible humans is that they are too damn sure of themselves.

>
> If you were a student of mine, I'd make it very concrete. I'd give you
> an actual machine H and ask you do write down H' and then H^. Then I'd
> ask you to run through the execution of H^. Have you done that? Do
> think you could do that?

I have two patents as sole inventor of two finite state machines what would you guess?
US7046848B1
US9171207B1

I was able to express their state transition matrix in a million-fold less space than is conventionally required.

>
> <snip>
> >> Yes, it is but are you able to understand the proof now? The text makes
> >> it clear so you might have been able to follow the proof despite this
> >> detail. I can always have another go at explaining it if you like.
> >
> > Because I literally spent 2000 hours since June mathematically
> > formalizing the notion of pathological self-reference using my own
> > Minimal Theory of Types I understand the that this proof necessarily
> > specified infinite recursion.
> >
> > I can now mathematically formalize the term [pathological self
> > reference] that I brought up here years ago.
>
> But I don't care about that sort of waffle.

That formalized waffle just proved that the first Incompleteness Theorem is incorrect.

G = "~(∃x) | (x ⊢ G)" // Gödel’s first Incompleteness Theorem
(1) Negation ---> (2) // G is an alias for this node
(2) Exists ---> (3)(4)
(3) x
(4) Such-That ---> (5)
(5) Syntactic-Logical-Consequence ---> (3)(1) // cycle indicates evaluation infinite loop

[Ben Bacarisse]

I call not understanding.

> If H^ behaved EXACTLY like H' then it would not copy its input.

Did you miss the word "now"?

> Try
> and use your words with (as much as possible) 100% perfect
> precision. I already called you on this before when you referred to a
> true opinion, (contradiction in terms).

They are Linz's words not mine; that's why I put them in quotes. H^
copies it's input an *then* behaves exactly like H'. It's not hard to
understand.

Unfortunately you rejected my formal explanation using state names but
you offered not better alternative. I see no option but to quote Linz's
words and hope that the penny drops. You are obviously averse to asking
for help, but if you don't say what part of his proof is confusing you,
I can't help much more than that.

You can't criticise the proof until you've understood it, and you seemed
genuinely surprised ("I call bullshit") by my direct quote of Linz words
about H^ copying its input and then behaving like H'. That suggests to
me that you don't know what Linz is saying.

<snip>

>> If you were a student of mine, I'd make it very concrete. I'd give you
>> an actual machine H and ask you do write down H' and then H^. Then I'd
>> ask you to run through the execution of H^. Have you done that? Do
>> think you could do that?
>
> I have two patents as sole inventor of two finite state machines what
> would you guess?

Since you are avoiding the question, I would guess that you think you
can't do it, but it's not hard and I'm pretty sure you could. I'll
start you off. Here's an example H.

H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})

with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
H' and H^?

(For convenience I'm using Linz's formalism here so Q={a,b}, Sigma={1,0}
and so on. If it's not clear, just ask.)

<snip>
--
Ben.

[peteolcott]

On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:

You and Linz are both incorrect on this. If either you or Linz would have studied Linz's clearest possible specification until you grokked it you would both have the same new insight that I have.

It is, however, so very much easier to simply understand these things in the conventional way. Also what would be your basis for even suspecting that the conventional understanding is incorrect?

All of these years I have only had an intuition that the conventional understanding of the halting problem and the incompleteness problem are incorrect.

My basis for this intuition it that the 2000 year old Liar Paradox
continued to lack any conventional understanding what-so-ever. Everyone knew that something was wrong yet no one knew exactly what was wrong.

I also knew intuitively that all three of these HP, IT, and LP had pathological self reference as the source of their error. I said that here in this forum several years ago.

It was not until about a year ago that I could state this intuition in a way that could be eventually mathematically verified. If the Incompleteness Theorem is correct then it proves that sometimes logical entailment either fails to complete or derives contradictory results. I have known that this is not possible because logical entailment is entirely based on logical tautology.

You probably don't understand the mathematical meaning of those words and won't bother to look them up.

This link anchors the concept of logical entailment:
https://en.wikipedia.org/wiki/Logical_consequence#Proofs_and_models

>
> Unfortunately you rejected my formal explanation using state names but
> you offered not better alternative. I see no option but to quote Linz's
> words and hope that the penny drops. You are obviously averse to asking
> for help, but if you don't say what part of his proof is confusing you,
> I can't help much more than that.

I did not reject state names. I said that Linz goofed when he resumed the execution of H^ back to its start state after it copied its input.

>
> You can't criticise the proof until you've understood it, and you seemed
> genuinely surprised ("I call bullshit") by my direct quote of Linz words
> about H^ copying its input and then behaving like H'. That suggests to
> me that you don't know what Linz is saying.

No it means that I ignore some of his mistakes and correct others. Because H^ has an infinitely recursive structure and H' does not have infinitely recursive structure there is not point where H^ behaves like H'.

If we go back to the TMD of the original Turing Machine H the problem becomes simpler thus clearer:

Page 318
Wm is a Turing Machine Description input to H
W is input to this Turing Machine Description

This is the Turing machine Desciption of H

q0 Wm W |-* H x1 qy x2
q0 Wm W |-* H y1 qn y2

If we run H with itself as input specified in conventional computer science functional notion we get this: H(H, H). There is no infinitely recursive structure here. Instead of infinitely recursive structure we have a third H that need an input yet has no input.

So even the initial configuration of the hypothetical halt decider has a gap in its reasoning. Linz never specifies what a TM that requires input yet has no input does.

For H^ he fixed this problem and has H^ copy its input before it begins its analysis. He and everyone else never pointed out that this results in an infinitely recursive problem specification.

This may be extremely difficult for you to see, it took me 2000 hours of concentrated effort since last June to see this. Once I saw the complete formalization of this last week in the Liar Paradox and the Incompleteness Theorem, then it was easy to look for and find the same issue with the Halting Problem.

>
> <snip>
> >> If you were a student of mine, I'd make it very concrete. I'd give you
> >> an actual machine H and ask you do write down H' and then H^. Then I'd
> >> ask you to run through the execution of H^. Have you done that? Do
> >> think you could do that?
> >
> > I have two patents as sole inventor of two finite state machines what
> > would you guess?
>
> Since you are avoiding the question, I would guess that you think you
> can't do it, but it's not hard and I'm pretty sure you could. I'll
> start you off. Here's an example H.
>
> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
>
> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
> H' and H^?
>

Since you changed the Linz notational conventions and and did not define your differing notational conventions I have no idea what you are saying.

> (For convenience I'm using Linz's formalism here so Q={a,b}, Sigma={1,0}
> and so on. If it's not clear, just ask.)

That differs too much from Linz, stick with the convention of preceding every state with a q such as q0.

This is better notation because it explicitly:
(a) Names every state in state transition order.
(b) Shows how many inputs
(c) Shows the final tape configuration (this is not very useful)
(d) Indicates an arbitrary number of unspecified state transitions thus abstracts out unnecessary details.

q0 Wm W |-* H x1 qy x2
q0 Wm W |-* H y1 qn y2

https://en.wikipedia.org/wiki/Formalism_(philosophy_of_mathematics)

In foundations of mathematics, philosophy of mathematics, and philosophy of logic, formalism is a theory that holds that statements of mathematics and logic can be considered to be statements about the consequences of certain string manipulation rules.

If we assume that the input to every Turing Machine is a finite string, then we avoid any presuppositions about the nature of this finite string. Linz is assuming that some of these finite strings specify a Turing Machine Description.

Because the Incompleteness Theorem presumes that G is a correct logical proposition it incorrectly concludes that mathematics must be either incomplete or inconsistent. It turns out that G is simply not a correct logical proposition.

You probably won't understand any of this because it comes from mathematics and not computer science. That is OK, just don't disparage it on the basis of your lack of understanding (ignorance).

http://lipn.univ-paris13.fr/~duchamp/Books&more/Hofstadter/%5BErnest_Nagel,_James_R._Newman,_Douglas_R._Hofstad(BookFi.org).pdf

Pages 96-97 simplified notation
n = Gödel_Number( "~(∃x) Dem (x, Sub (y, 17, y))" )

// page 98
sub (n, 17, n) is the Gödel number of G.
G = Sub (n, 17, n)

// Thus after substitution
G = Gödel_Number( "~(∃x) Dem (x, G)" )

// Converting to modern symbolic notation
G = Gödel_Number( "~(∃x) | (x ⊢ G)" )

// Discarding arithmetization

G = "~(∃x) | (x ⊢ G)"

Minimal Type Theory (for G) expressed as Directed Graph

(1) Negation ---> (2) // G is an alias for this node
(2) Exists ---> (3)(4)
(3) x
(4) Such-That ---> (5)
(5) Syntactic-Logical-Consequence ---> (3)(1) // cycle indicates evaluation infinite loop

>

> <snip>
> --
> Ben.

[Ben Bacarisse]

Not so. It is so by definition.

> If either you or Linz would have studied Linz's clearest possible
> specification until you grokked it you would both have the same new
> insight that I have.

There is no point in drawing silly conclusions form an error in the
text. If you can't see past it, try any of a hundred other proofs of
this theorem. They all use the same definition that you are denying to
Linz -- a machine copies its input and then behaves as the machine it is
derived from.

>
> It is, however, so very much easier to simply understand these things in the conventional way. Also what would be your basis for even suspecting that the conventional understanding is incorrect?
>
> All of these years I have only had an intuition that the conventional understanding of the halting problem and the incompleteness problem are incorrect.
>
> My basis for this intuition it that the 2000 year old Liar Paradox
> continued to lack any conventional understanding what-so-ever. Everyone knew that something was wrong yet no one knew exactly what was wrong.
>
> I also knew intuitively that all three of these HP, IT, and LP had pathological self reference as the source of their error. I said that here in this forum several years ago.
>
> It was not until about a year ago that I could state this intuition in a way that could be eventually mathematically verified. If the Incompleteness Theorem is correct then it proves that sometimes logical entailment either fails to complete or derives contradictory results. I have known that this is not possible because logical entailment is entirely based on logical tautology.
>
> You probably don't understand the mathematical meaning of those words and won't bother to look them up.
>
> This link anchors the concept of logical entailment:
> https://en.wikipedia.org/wiki/Logical_consequence#Proofs_and_models
>
>>
>> Unfortunately you rejected my formal explanation using state names but
>> you offered not better alternative. I see no option but to quote Linz's
>> words and hope that the penny drops. You are obviously averse to asking
>> for help, but if you don't say what part of his proof is confusing you,
>> I can't help much more than that.
>
> I did not reject state names. I said that Linz goofed when he resumed
> the execution of H^ back to its start state after it copied its
> input.

So fix it and more on. None of your re-writes have been clear in how
the problem should be fixed because, of course, you don't want to fix
it. You thought that H^ machine endlessly copied it's input and you
don't like that fact that that error is trivial to correct. You'd be
stuck having to accept the theorem again as you did for so many years.

>
>>
>> You can't criticise the proof until you've understood it, and you seemed
>> genuinely surprised ("I call bullshit") by my direct quote of Linz words
>> about H^ copying its input and then behaving like H'. That suggests to
>> me that you don't know what Linz is saying.
>
> No it means that I ignore some of his mistakes and correct
> others. Because H^ has an infinitely recursive structure and H' does
> not have infinitely recursive structure there is not point where H^
> behaves like H'.

Of course you don't want to correct the poof so you pick and choose what
you call the error. That shows only a lack of intellectual backbone.
Fix the error in the proof so the proof is correct. Anything else is
just burying your head in the sand.

<snip>
>> >> If you were a student of mine, I'd make it very concrete. I'd give you
>> >> an actual machine H and ask you do write down H' and then H^. Then I'd
>> >> ask you to run through the execution of H^. Have you done that? Do
>> >> think you could do that?
>> >
>> > I have two patents as sole inventor of two finite state machines what
>> > would you guess?
>>
>> Since you are avoiding the question, I would guess that you think you
>> can't do it, but it's not hard and I'm pretty sure you could. I'll
>> start you off. Here's an example H.
>>
>> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
>>
>> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
>> H' and H^?
>>
>
> Since you changed the Linz notational conventions and and did not
> define your differing notational conventions I have no idea what you
> are saying.

This is Linz's notation. You are confusing how he write execution
configurations with how he defines machines. The explanation of the
notation for a machine is a few chapter earlier on (you have read the
book, yes?).

He defines a Turing machine an ordered 7-tuple so there can be no doubt
what H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b}) means. All the sets and
functions are clearly specified. Only the details of the d function
remain to written out (it would be unreadable if it were specified as a
set in the tuple) and I did that.

Anyway, as I said, I am sure that you can do this so just ask if
something is confusing you. Which part of this machine description is
bothering you?

>> (For convenience I'm using Linz's formalism here so Q={a,b}, Sigma={1,0}
>> and so on. If it's not clear, just ask.)
>
> That differs too much from Linz, stick with the convention of
> preceding every state with a q such as q0.

No, if you can't cope with a two-state machine with names of my choosing
you need to go back to square one. Especially as the crucial problem
involves exactly the problem of confusing that start state of two
machines one derived from the other. Using q0 for both is exactly the
problem you need to get round.

You sell yourself short if you think you can't cope with a machine with
two states called a and b. I'm sure you can.

(I'm discounting the possibility that your deliberately want to use q0
for every start state so that you can try avoid correcting Linz's
mistake. That would be disingenuous in the extreme so I will reject
that explanation for now.)

> This is better notation because it explicitly:

<re-ordered a bit: here's the notation:>

> q0 Wm W |-* H x1 qy x2
> q0 Wm W |-* H y1 qn y2
>

> (a) Names every state in state transition order.

No it doesn't. Do you really not know what the notation means? It's
about machine configurations.

> (b) Shows how many inputs

No it does not. All TM's have a possibly blank tape to start with.
There is no number of inputs -- only some set of input symbols. Again,
you seem not to know what qx a b c |-* H ... means.

> (c) Shows the final tape configuration (this is not very useful)

Actually it's crucial to the proof, but since this notation is not about
defining a machine, it does not apply here.

> (d) Indicates an arbitrary number of unspecified state transitions
> thus abstracts out unnecessary details.

Ah, yes, that would indeed help you. What I asked for was an actual H'
and H^ derived from an actual H. This would show that you are wrong, so
you must at all costs never do anything that clear and concrete. Keep
it as abstract and as far away from a counterexample as possible!

Anyway, if you really think you can't write out H' and H^ from my
example H, just say so, and I'll do it for you.

<snip>
--
Ben.

[peteolcott]

I both you and Linz agreed that all of the square circles are blue in color you would be wrong. You and Linz said that H^ and H' behave the same way and they don't behave the same way.

> > If either you or Linz would have studied Linz's clearest possible
> > specification until you grokked it you would both have the same new
> > insight that I have.
>
> There is no point in drawing silly conclusions form an error in the
> text. If you can't see past it, try any of a hundred other proofs of
> this theorem. They all use the same definition that you are denying to
> Linz -- a machine copies its input and then behaves as the machine it is
> derived from.
>

All of these proof overlook the same problem.
My other post show this same problem.
Rejecting semantically ill-formed input to a Halt Decider.

The infinitely recursive nature of Kurt Gödel's first incompleteness theorem simply proves that his conclusion is incorrect.

The first incompleteness theorem states that no consistent system of axioms whose theorems can be listed by an effective procedure (i.e., an algorithm) is capable of proving all truths about the arithmetic of the natural numbers. For any such formal system, there will always be statements about the natural numbers that are true, but that are unprovable within the system.

Instead of finding G that is true but unprovable in PM he simply found G that is neither true nor false, thus not in PM. Alfred Tarski made similar mistakes.

> >
> > It is, however, so very much easier to simply understand these things in the conventional way. Also what would be your basis for even suspecting that the conventional understanding is incorrect?
> >
> > All of these years I have only had an intuition that the conventional understanding of the halting problem and the incompleteness problem are incorrect.
> >
> > My basis for this intuition it that the 2000 year old Liar Paradox
> > continued to lack any conventional understanding what-so-ever. Everyone knew that something was wrong yet no one knew exactly what was wrong.
> >
> > I also knew intuitively that all three of these HP, IT, and LP had pathological self reference as the source of their error. I said that here in this forum several years ago.
> >
> > It was not until about a year ago that I could state this intuition in a way that could be eventually mathematically verified. If the Incompleteness Theorem is correct then it proves that sometimes logical entailment either fails to complete or derives contradictory results. I have known that this is not possible because logical entailment is entirely based on logical tautology.
> >
> > You probably don't understand the mathematical meaning of those words and won't bother to look them up.
> >
> > This link anchors the concept of logical entailment:
> > https://en.wikipedia.org/wiki/Logical_consequence#Proofs_and_models
> >
> >>
> >> Unfortunately you rejected my formal explanation using state names but
> >> you offered not better alternative. I see no option but to quote Linz's
> >> words and hope that the penny drops. You are obviously averse to asking
> >> for help, but if you don't say what part of his proof is confusing you,
> >> I can't help much more than that.
> >
> > I did not reject state names. I said that Linz goofed when he resumed
> > the execution of H^ back to its start state after it copied its
> > input.
>
> So fix it and more on. None of your re-writes have been clear in how
> the problem should be fixed because, of course, you don't want to fix
> it. You thought that H^ machine endlessly copied it's input and you
> don't like that fact that that error is trivial to correct. You'd be
> stuck having to accept the theorem again as you did for so many years.

I already fixed it in this post.
Rejecting semantically ill-formed input to a Halt Decider.
It detects that it is stuck in infinite recursion and detects
that one of its its final states has been altered, and thus
rejects the input as semantically invalid.
It does this with a single-step execution trace from chosen
points in the execution sequence.

> >
> >>
> >> You can't criticise the proof until you've understood it, and you seemed
> >> genuinely surprised ("I call bullshit") by my direct quote of Linz words
> >> about H^ copying its input and then behaving like H'. That suggests to
> >> me that you don't know what Linz is saying.
> >
> > No it means that I ignore some of his mistakes and correct
> > others. Because H^ has an infinitely recursive structure and H' does
> > not have infinitely recursive structure there is not point where H^
> > behaves like H'.
>
> Of course you don't want to correct the poof so you pick and choose what
> you call the error. That shows only a lack of intellectual backbone.
> Fix the error in the proof so the proof is correct. Anything else is
> just burying your head in the sand.
>

I already fixed it here.
Rejecting semantically ill-formed input to a Halt Decider

> <snip>
> >> >> If you were a student of mine, I'd make it very concrete. I'd give you
> >> >> an actual machine H and ask you do write down H' and then H^. Then I'd
> >> >> ask you to run through the execution of H^. Have you done that? Do
> >> >> think you could do that?
> >> >
> >> > I have two patents as sole inventor of two finite state machines what
> >> > would you guess?
> >>
> >> Since you are avoiding the question, I would guess that you think you
> >> can't do it, but it's not hard and I'm pretty sure you could. I'll
> >> start you off. Here's an example H.
> >>
> >> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
> >>
> >> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
> >> H' and H^?
> >>
> >
> > Since you changed the Linz notational conventions and and did not
> > define your differing notational conventions I have no idea what you
> > are saying.
>
> This is Linz's notation. You are confusing how he write execution
> configurations with how he defines machines. The explanation of the
> notation for a machine is a few chapter earlier on (you have read the
> book, yes?).
>

I have never read the whole book, I only read what I need for the HP.

> He defines a Turing machine an ordered 7-tuple so there can be no doubt

Figure 9.1

> what H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b}) means.

He always puts a q in front of all of his states, even on page 235.

> All the sets and
> functions are clearly specified. Only the details of the d function
> remain to written out (it would be unreadable if it were specified as a
> set in the tuple) and I did that.
>
> Anyway, as I said, I am sure that you can do this so just ask if
> something is confusing you. Which part of this machine description is
> bothering you?
>

Just quit changing his conventions.

> >> (For convenience I'm using Linz's formalism here so Q={a,b}, Sigma={1,0}
> >> and so on. If it's not clear, just ask.)
> >
> > That differs too much from Linz, stick with the convention of
> > preceding every state with a q such as q0.
>
> No, if you can't cope with a two-state machine with names

Then I will quit talking to you. I will simply consider you a disingenuous person playing head games.

> of my choosing
> you need to go back to square one. Especially as the crucial problem
> involves exactly the problem of confusing that start state of two
> machines one derived from the other. Using q0 for both is exactly the
> problem you need to get round.
>
> You sell yourself short if you think you can't cope with a machine with
> two states called a and b. I'm sure you can.

I have patents on two different finite state machine you nitwit.

>
> (I'm discounting the possibility that your deliberately want to use q0
> for every start state so that you can try avoid correcting Linz's
> mistake. That would be disingenuous in the extreme so I will reject
> that explanation for now.)

0 is the universal start state for all finite state machines because they are stored in a state transition matrix and 0 is the first element. If you are using an integer besides 0 you are doing it wrong.

>
> > This is better notation because it explicitly:
>
> <re-ordered a bit: here's the notation:>
>
> > q0 Wm W |-* H x1 qy x2
> > q0 Wm W |-* H y1 qn y2
> >
> > (a) Names every state in state transition order.
>
> No it doesn't. Do you really not know what the notation means? It's
> about machine configurations.
>
> > (b) Shows how many inputs
>
> No it does not. All TM's have a possibly blank tape to start with.
> There is no number of inputs -- only some set of input symbols. Again,
> you seem not to know what qx a b c |-* H ... means.

There are levels of evaluation. Ever since 1950 it has been the convention to talk about algorithms using the abstraction of some human readable language instead of raw machine language integers. The abstraction of H is specified with two inputs Wm, Wm. Linz explains this view on page 318.

H is defined to have Wm as its TMD input and W as the input to its TMD input.
If you continue to avoid the key points I will write you off as a disingenuous fool playing head games.

>
> > (c) Shows the final tape configuration (this is not very useful)
>
> Actually it's crucial to the proof, but since this notation is not about
> defining a machine, it does not apply here.
>
> > (d) Indicates an arbitrary number of unspecified state transitions
> > thus abstracts out unnecessary details.
>
> Ah, yes, that would indeed help you. What I asked for was an actual H'
> and H^ derived from an actual H. This would show that you are wrong, so
> you must at all costs never do anything that clear and concrete. Keep
> it as abstract and as far away from a counterexample as possible!

// State transitions of H
|--q0 Wm W |-* H x1 qy x2
|--q0 Wm W |-* H y1 qn y2


// State transitions of H'
|--q0 Wm W |-* H' qy ∞
|--q0 Wm W |-* H' y1 qn y2


// State transitions of H^
|--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
|--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2


It of course shows that you are wrong, yet like the Donald you will never admit it. My current assessment is that you are a disingenuous fool playing head games. Additional information may change this assessment.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>>
>> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:

<snip>

>> >> They are Linz's words not mine; that's why I put them in quotes. H^
>> >> copies it's input an *then* behaves exactly like H'. It's not hard to
>> >> understand.
>> >
>> > You and Linz are both incorrect on this.
>>
>> Not so. It is so by definition.
>
> I both you and Linz agreed that all of the square circles are blue in
> color you would be wrong. You and Linz said that H^ and H' behave the
> same way and they don't behave the same way.

Neither of us say that. I know you have some trouble with this
material, but do you really not understand how H^ is defined? Lots of
other proofs use the same definition so even if you simply can't get
past the error in Linz's notation, you must know what the words are
supposed to mean. For your convenience, I've corrected the text below.

<snip>

>> There is no point in drawing silly conclusions form an error in the
>> text. If you can't see past it, try any of a hundred other proofs of
>> this theorem. They all use the same definition that you are denying to
>> Linz -- a machine copies its input and then behaves as the machine it is
>> derived from.
>
> All of these proof overlook the same problem.
> My other post show this same problem.
> Rejecting semantically ill-formed input to a Halt Decider.

No. If you bit the bullet and did the exercise I suggested you would
see exactly how H, H' and H^ relate to each other.

Anyway, if you can't correct the proof (it's a tiny detail in notation)
I can fix it for you. Linz meant to say

"From H' we construct another Turing machine H^. This new machine
takes as input wM and copies it, ending in what was the initial state
of H' qx. After that it behaves like H'. Then the action of H^ is
such that

q0 wM |-*H^ qx wM wM |-*H^ oo

if M applied to wM halts, and

q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2

if M applied to wM does not halt."

See? Fixed. The proof is fine.

<snip>

>> >> Since you are avoiding the question, I would guess that you think you
>> >> can't do it, but it's not hard and I'm pretty sure you could. I'll
>> >> start you off. Here's an example H.
>> >>
>> >> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
>> >>
>> >> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
>> >> H' and H^?
>> >>
>> >
>> > Since you changed the Linz notational conventions and and did not
>> > define your differing notational conventions I have no idea what you
>> > are saying.
>>
>> This is Linz's notation. You are confusing how he write execution
>> configurations with how he defines machines. The explanation of the
>> notation for a machine is a few chapter earlier on (you have read the
>> book, yes?).
>
> I have never read the whole book, I only read what I need for the HP.

Ah, no wonder you are at sea. I would suggest you read it, but you
probably consider that dangerous since it's possible you'd understand
it.

>> He defines a Turing machine an ordered 7-tuple so there can be no doubt
> Figure 9.1
>
>> what H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b}) means.
> He always puts a q in front of all of his states, even on page 235.

No he does not always do that, but you've not read the book so you
wouldn't know.

But lets call them q1 and q1 if it makes you happy. Here's the machine
with the state names that don't give you the hives:

H = ({q0,q1}, {1,0}, {1,0,_}, d, q0, _, {q1})

with d(q0,1) = (q0,1,R), d(q0,0) = (q0,0,R) and d(q0,_) = (q1,_,L).

Now you need to find some other excuse to avoid withing out H' and H^.

<snip>

>> No, if you can't cope with a two-state machine with names
>
> Then I will quit talking to you. I will simply consider you a
> disingenuous person playing head games.

That's fine. I was simply correcting a detailed error in the proof that
might have confused other people.

<snip>

>> (I'm discounting the possibility that your deliberately want to use q0
>> for every start state so that you can try avoid correcting Linz's
>> mistake. That would be disingenuous in the extreme so I will reject
>> that explanation for now.)
>
> 0 is the universal start state for all finite state machines because
> they are stored in a state transition matrix and 0 is the first
> element. If you are using an integer besides 0 you are doing it wrong.

Nonsense. No lesser authority the Turing himself uses the letters a, b,
c and so on for actual states. And if you'd read Linz you would see
that he does always use q0, q1, ... either. But it's a good distraction
from actually writing out an example H' and H^.

<snip>
>> ... What I asked for was an actual H'

>> and H^ derived from an actual H. This would show that you are wrong, so
>> you must at all costs never do anything that clear and concrete. Keep
>> it as abstract and as far away from a counterexample as possible!
>
> // State transitions of H
> |--q0 Wm W |-* H x1 qy x2
> |--q0 Wm W |-* H y1 qn y2
>
>
> // State transitions of H'
> |--q0 Wm W |-* H' qy ∞
> |--q0 Wm W |-* H' y1 qn y2
>
>
> // State transitions of H^
> |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

No, you are still confusing the notation for machine configurations and
the notation for the actual Turing machine. You can write a TM using
the |- notation (note: without the star) so feel free to do it that way
if you like.

Shall I do H' for you and then you can try H^? If you want me to do
that, what state names should I use so you won't pretend to not
understand?

<snip>
--
Ben.

[peteolcott]

On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote:
> peteolcott <peterolcott> writes:
>
> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
> >> peteolcott <peterolcott> writes:
> >>
> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
> <snip>
> >> >> They are Linz's words not mine; that's why I put them in quotes. H^
> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to
> >> >> understand.
> >> >
> >> > You and Linz are both incorrect on this.
> >>
> >> Not so. It is so by definition.
> >
> > I both you and Linz agreed that all of the square circles are blue in
> > color you would be wrong. You and Linz said that H^ and H' behave the
> > same way and they don't behave the same way.
>
> Neither of us say that. I know you have some trouble with this
> material, but do you really not understand how H^ is defined?

There you are not being precise enough with words again. Although
H^ is defined to have a superset of the states of H' this does not
logically entail that H^ ever actually behaves like H'. A simple
linear execution trace shows that H^ would never reach the H' states.
Because of this H^ and H" never have the same behavior.

Linz did not see this and you are not seeing this and it is very
likely that no one has ever seen this before. Seeing this requires
understanding how my Minimal Theory of Types applies to the
Liar Paradox and the Incompleteness Theorem.

Minimal Theory of Types copyright 2016 and 2017 Pete Olcott
https://philpapers.org/archive/PETMTT-4.pdf

> Lots of
> other proofs use the same definition so even if you simply can't get
> past the error in Linz's notation, you must know what the words are
> supposed to mean. For your convenience, I've corrected the text below.
>
> <snip>
> >> There is no point in drawing silly conclusions form an error in the
> >> text. If you can't see past it, try any of a hundred other proofs of
> >> this theorem. They all use the same definition that you are denying to
> >> Linz -- a machine copies its input and then behaves as the machine it is
> >> derived from.
> >
> > All of these proof overlook the same problem.
> > My other post show this same problem.
> > Rejecting semantically ill-formed input to a Halt Decider.
>
> No. If you bit the bullet and did the exercise I suggested you would
> see exactly how H, H' and H^ relate to each other.
>

See my 1.5 page correct refutation of the Incompleteness Theorem and
maybe you will begin to understand.

> Anyway, if you can't correct the proof (it's a tiny detail in notation)
> I can fix it for you. Linz meant to say
>
> "From H' we construct another Turing machine H^. This new machine
> takes as input wM and copies it, ending in what was the initial state
> of H' qx. After that it behaves like H'. Then the action of H^ is
> such that
>

Yet H^ does not actually behave like H' because H^ has an infinitely
recursive structure that H' does not have.

> q0 wM |-*H^ qx wM wM |-*H^ oo
>
> if M applied to wM halts, and
>
> q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2
>
> if M applied to wM does not halt."
>
> See? Fixed. The proof is fine.

The bug is fixed so that H^ does not copy its input in an infinite loop.
Now like every other definition of the Halting Problem counter-example
it is stuck copying its input in infinite recursion.

The Incompleteness Theorem and the Liar Paradox make this same mistake.
Both the GIT and the LP are stuck in infinite recursion never completing
their evaluation of their own expression.

Because of this neither the GIT nor the LP are truth bearers. I gave a
name to this error year ago in this forum: Pathological self-reference.
Now I have mathematically formalized this error in my own Minimal Theory
of Types.

When-so-ever the formalization of the semantic meaning of any logical
expression within an otherwise directed acyclic graph requires the
insertion of cycles this expression derives pathological self-reference.

<snip>

> > // State transitions of H^
> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
>
> No, you are still confusing the notation for machine configurations and
> the notation for the actual Turing machine. You can write a TM using
> the |- notation (note: without the star) so feel free to do it that way
> if you like.
>

regular expression syntax:
|- exactly one state transition
|-+ one or more state transitions
|-* zero or more (an arbitrary number) of state transitions

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>>
>> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
>> >> peteolcott <peterolcott> writes:
>> >>
>> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
>> <snip>
>> >> >> They are Linz's words not mine; that's why I put them in quotes. H^
>> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to
>> >> >> understand.
>> >> >
>> >> > You and Linz are both incorrect on this.
>> >>
>> >> Not so. It is so by definition.
>> >
>> > I both you and Linz agreed that all of the square circles are blue in
>> > color you would be wrong. You and Linz said that H^ and H' behave the
>> > same way and they don't behave the same way.
>>
>> Neither of us say that. I know you have some trouble with this
>> material, but do you really not understand how H^ is defined?
>
> There you are not being precise enough with words again. Although
> H^ is defined to have a superset of the states of H' this does not
> logically entail that H^ ever actually behaves like H'. A simple
> linear execution trace shows that H^ would never reach the H' states.
> Because of this H^ and H" never have the same behavior.

Since you don't yet know what H^ is (and you are steadfastly refusing to
write out an example so you can see) you can't have a trace of H^. You
need to know what the machine is first. It's probably significant that
you never read that chapter of the book.

Anyway, you feel free to correct my wording below to make it as precise
as you need it. Don't however, invent your own flawed H^. That shows
nothing. There are lots of ways to fail to prove the halting theorem
and you are currently fixated on just one of them -- your current
misunderstanding of how H^ is defined.

<snip>

>> Anyway, if you can't correct the proof (it's a tiny detail in notation)
>> I can fix it for you. Linz meant to say
>>
>> "From H' we construct another Turing machine H^. This new machine
>> takes as input wM and copies it, ending in what was the initial state
>> of H' qx. After that it behaves like H'. Then the action of H^ is
>> such that
>
> Yet H^ does not actually behave like H' because H^ has an infinitely
> recursive structure that H' does not have.

Why don't you do the exercise I suggested? Are you worried that you'll
see that H^ is not at all what you want to think it is? I don't think
you'll understand until you do this exercise.

>> q0 wM |-*H^ qx wM wM |-*H^ oo
>>
>> if M applied to wM halts, and
>>
>> q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2
>>
>> if M applied to wM does not halt."
>>
>> See? Fixed. The proof is fine.
>
> The bug is fixed so that H^ does not copy its input in an infinite
> loop.

Exactly. That was the error in Linz notation (though the text made it
clear).

> Now like every other definition of the Halting Problem counter-example
> it is stuck copying its input in infinite recursion.

Nope. If you did the exercise you would see that it does not. I am
beginning to think you are are too frightened to do it because you might
suddenly see that the H^ construction is trivial and not at all what you
think it is. Go on, do it! It should take only a few minutes, though
you might have to read a few pages of chapter 9 to see what a Turing
machine actually is.

<snip>
>> > // State transitions of H^
>> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
>> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
>>
>> No, you are still confusing the notation for machine configurations and
>> the notation for the actual Turing machine. You can write a TM using
>> the |- notation (note: without the star) so feel free to do it that way
>> if you like.
>
> regular expression syntax:
> |- exactly one state transition
> |-+ one or more state transitions
> |-* zero or more (an arbitrary number) of state transitions

That is correct. But explaining to me something I know won't help you
understand how to define a Turing machine. As I said, you could define
H' and H^ from my example H using the |- notation. Do it that way if
you find it easier.

>> Shall I do H' for you and then you can try H^? If you want me to do
>> that, what state names should I use so you won't pretend to not
>> understand?

Are you sure you don't need some help? I'll write out H' using the |-
notation is that would make you happier. It's much more involved than
simple defining H' (because the notation has to name the parts of the
tape that are not involved in the transition) but it can be done that
way.

--
Ben.

[peteolcott]

Every Halting Problem counter-example instance that copies its input has the same infinitely recursive process of copying its input, I showed this step by step in my other post.

// Corrected H^ source (second q0 changed to qc) from page 319
// H^ is created from H’ by prepending steps that copy its input
=>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
=>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn

Every state transition above is an H^ state transition. I removed the tape configuration and inserted the qy state back in.

Here is the common prefix of state transtions:
=>>> q0 Wm |-* H^ qc Wm Wm |-* H^

(1) H^ begins at state q0 with Wm (a TMD of itself) as input.
(2) H^ copies its input and transitions to qc.
(3) H^ begins processing Wm Wm a pair of TMD copies of itself.
(4) H^ does whatever it does to decide halting for Wm Wm.

H^ might flip a coin or pray to its creator. The algorithmic thing to do is to determine that actual execution trace of its input.

The simplest possible execution trace is to simply execute all of the steps of H^ Wm Wm acting as an interpreter for its first Wm.

If H^ simply acts as an interpreter for its input then:

(1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
(2) Wm copies its own input and transitions to its own qc.
(3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
(4) Wm does whatever it does to decide halting for Wm2 Wm2.

Since H^ is acting simply as an interpreter of its input Wm Wm (TMD copies of itself) then H^ would begin interpreting Wm2 Wm2 on and on as infinite recursion.

https://philpapers.org/archive/PETMTT-4.pdf

(1) Liar Paradox
(2) Truth Teller Paradox
(3) Kurt Gödel’s (1931) first incompleteness theorem

For the above three we are simply done. The Minimal Theory of Types formalizes the underlying semantic meaning of their propositional variables using Rudolf Carnap (1952) Meaning Postulates proving that these propositional variables are not truth bearers. Carnap formalized some of the semantics of natural language.

I formalized the semantics of formal language. The Minimal Theory of Types provided the means to formalize the semantic meaning of formal language variables representing formal language abstractions.

This formalization shows the precise error of the Liar Paradox, Truth Teller, Gödel’s incompleteness theorem. When a math formula gets stuck in an infinite evaluation loop, the this math formula is simply incorrect.

A Turing Machine has more intelligence. A TM could possibly detect that its input specifies and infinitely recursive evaluation. A TM would not necessarily be required to fully process this infinite set of inputs.

I just did it. I am pretty sure that this is several times now that I did it.
I tried to make this one more clear.

[Ben Bacarisse]

If you did the exercise you'd see this is not the case. Is that why you
won't do it? If you wrote out an actual H^ you could see what it does.
It would be clear there is no "infinitely recursive process of copying
its input".

> I showed this step by step in my other post.
>
> // Corrected H^ source (second q0 changed to qc) from page 319
> // H^ is created from H’ by prepending steps that copy its input
> =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn
>
> Every state transition above is an H^ state transition. I removed the
> tape configuration and inserted the qy state back in.

You don't understand this notation. The wrong above right like is not.
That's how your garbled use of the notation reads to me. You can't see
it because you use mathematical symbols in a sort of poetic way -- your
string them together in the hope of conveying some meaning.

Hand-waving is all very well in English, but the halting theorem is an
exact statement about precisely defined entities. It's ludicrous to try
to refute it when you don't even know the being nation used. Just go
back to waffling about ill-formed questions and you can be wrong in way
that no one will ever care about.

> Here is the common prefix of state transtions:
> =>>> q0 Wm |-* H^ qc Wm Wm |-* H^
>
> (1) H^ begins at state q0 with Wm (a TMD of itself) as input.
> (2) H^ copies its input and transitions to qc.
> (3) H^ begins processing Wm Wm a pair of TMD copies of itself.
> (4) H^ does whatever it does to decide halting for Wm Wm.

Kind of. From step 3, H^ behaves as H', and H' starts by behaving like
H so what happens form step three is best described in terms of what H'
and H do. None of the extra states added when making H^ play any role
after step 2. You'd know this if came clean and said what qc actually
is. And you'd know it if you did the exercise I suggested.

> H^ might flip a coin or pray to its creator.

No, a TM can't do either of these things.

> The algorithmic thing to
> do is to determine that actual execution trace of its input.
>
> The simplest possible execution trace is to simply execute all of the
> steps of H^ Wm Wm acting as an interpreter for its first Wm.

No, if you did the exercise you'd see a much simpler possible execution
trace. Why won't you do it?

> If H^ simply acts as an interpreter for its input then:
>
> (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
> (2) Wm copies its own input and transitions to its own qc.
> (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
> (4) Wm does whatever it does to decide halting for Wm2 Wm2.

For some H, H^ will do this. But the construction of H^ lets one deduce
something about H' and then about H from this behaviour. That's a
crucial part of the argument. I don't think you know how to do that,
because you've got stuck in a loop of your own.

<snip>

>> > Now like every other definition of the Halting Problem counter-example
>> > it is stuck copying its input in infinite recursion.
>>
>> Nope. If you did the exercise you would see that it does not. I am
>> beginning to think you are are too frightened to do it
>
> I just did it. I am pretty sure that this is several times now that I did it.
> I tried to make this one more clear.

Please, that just makes you look silly. You didn't even know what
Linz's notation for a TM meant, so you could not even understand the
machine I wrote much less construct two others form it. Doing this
exercise would involve writing down a TM and that would mean reading at
least a bit of Chapter 9.

<snip>
--
Ben.

[peteolcott]

Because H^ contains unspecified sequences of state transitions |-*
an infinite number of different configurations of H^ are specified.

Within the single element of this infinite set where H^ acts as and interpreter (UTM) and simply executes its input state by state, H^ and its input unequivocally specify infinitely recursive input.

I will probably have to formalize this with my brand new (as of March 10, 2017) Minimal Type Theory or it will be too difficult for you to see this.

>
> > I showed this step by step in my other post.
> >
> > // Corrected H^ source (second q0 changed to qc) from page 319
> > // H^ is created from H’ by prepending steps that copy its input
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn
> >
> > Every state transition above is an H^ state transition. I removed the
> > tape configuration and inserted the qy state back in.
>
> You don't understand this notation.

> The wrong above right like is not.

Have no idea what you are saying here.
Give me a quote of what you mean by: {above right}.
The {above right} is not what?

> That's how your garbled use of the notation reads to me. You can't see
> it because you use mathematical symbols in a sort of poetic way -- your
> string them together in the hope of conveying some meaning.

You did not notice that the above is a direct quote from Linz?
(I did remove the tape symbols y1, y2 from this direct quote)
(I also added back in the qy state shown it the diagram).

>
> Hand-waving is all very well in English, but the halting theorem is an
> exact statement about precisely defined entities. It's ludicrous to try
> to refute it when you don't even know the being nation used. Just go
> back to waffling about ill-formed questions and you can be wrong in way
> that no one will ever care about.
>
> > Here is the common prefix of state transtions:
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^
> >
> > (1) H^ begins at state q0 with Wm (a TMD of itself) as input.
> > (2) H^ copies its input and transitions to qc.
> > (3) H^ begins processing Wm Wm a pair of TMD copies of itself.
> > (4) H^ does whatever it does to decide halting for Wm Wm.
>
> Kind of. From step 3, H^ behaves as H', and H' starts by behaving like
> H

Yes at the exact point of step (3) we are at the start state of both H' and H.

> so what happens from step three is best described in terms of what H'
> and H do.

No. Neither H' nor H are exactly H^ and neither H' nor H have (H^, H^) as their input. When H^ begins to analyze its input, its input has an entirely different start state than either H' or H. (All three machines name their start state q0).

> None of the extra states added when making H^ play any role
> after step 2. You'd know this if came clean and said what qc actually
> is. And you'd know it if you did the exercise I suggested.
>
> > H^ might flip a coin or pray to its creator.
>
> No, a TM can't do either of these things.
>
> > The algorithmic thing to
> > do is to determine that actual execution trace of its input.
> >
> > The simplest possible execution trace is to simply execute all of the
> > steps of H^ Wm Wm acting as an interpreter for its first Wm.
>
> No, if you did the exercise you'd see a much simpler possible execution
> trace. Why won't you do it?
>
> > If H^ simply acts as an interpreter for its input then:
> >
> > (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
> > (2) Wm copies its own input and transitions to its own qc.
> > (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
> > (4) Wm does whatever it does to decide halting for Wm2 Wm2.
>
> For some H, H^ will do this.

I have only been talking about the single instance of H^ being executed with a TMD of itself as its input, thus there is no H' nor H, only H^.

> But the construction of H^ lets one deduce
> something about H' and then about H from this behaviour. That's a
> crucial part of the argument. I don't think you know how to do that,
> because you've got stuck in a loop of your own.

I cannot understand why you keep jumping around and changing the subject away from H^ to either H' or H. I am only talking about H^ being executed with a TMD of itself as its input.

>
> <snip>
> >> > Now like every other definition of the Halting Problem counter-example
> >> > it is stuck copying its input in infinite recursion.
> >>
> >> Nope. If you did the exercise you would see that it does not. I am
> >> beginning to think you are are too frightened to do it
> >
> > I just did it. I am pretty sure that this is several times now that I did it.
> > I tried to make this one more clear.
>
> Please, that just makes you look silly. You didn't even know what
> Linz's notation for a TM meant,

Bullshit.

<snip>

[Ben Bacarisse]

The only way you will be able to stop believing this is to do the
exercise I suggested. You'll then see, clear as day, an H^ with no
unspecified sequences of state transitions and only a finite number of
configurations (for any given tape, of course -- even the degenerate 1
state TM has infinite configurations if you include all the possible
tapes it can be started with).

> Within the single element of this infinite set where H^ acts as and
> interpreter (UTM) and simply executes its input state by state, H^ and
> its input unequivocally specify infinitely recursive input.

Pure fantasy. H^ can behave in many ways -- most of which you have
never even imagined.

> I will probably have to formalize this with my brand new (as of March
> 10, 2017) Minimal Type Theory or it will be too difficult for you to
> see this.

Note that if you succeed in proving what you say it will immediately
show your Minimal Type Theory to be faulty.

>> > I showed this step by step in my other post.
>> >
>> > // Corrected H^ source (second q0 changed to qc) from page 319
>> > // H^ is created from H’ by prepending steps that copy its input
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn
>> >
>> > Every state transition above is an H^ state transition. I removed the
>> > tape configuration and inserted the qy state back in.
>>
>> You don't understand this notation.
>
>> The wrong above right like is not.
> Have no idea what you are saying here.
> Give me a quote of what you mean by: {above right}.
> The {above right} is not what?

Exactly. It's garbled isn't it? Exactly like your garbled use of
Linz's notation. I just wanted to show you what

q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞

looks like to someone who understand the language it's written in.

>> That's how your garbled use of the notation reads to me. You can't see
>> it because you use mathematical symbols in a sort of poetic way -- your
>> string them together in the hope of conveying some meaning.
>
> You did not notice that the above is a direct quote from Linz?

It isn't.

> (I did remove the tape symbols y1, y2 from this direct quote)
> (I also added back in the qy state shown it the diagram).

Ah. Here, then, is a direct quote from you:

"See my 1.5 page incorrect refutation of the Incompleteness Theorem and
maybe you will begin to understand how silly I am."

(I did change a couple of things but I don't think they matter.)

<snip>

>> > Here is the common prefix of state transtions:
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^
>> >
>> > (1) H^ begins at state q0 with Wm (a TMD of itself) as input.
>> > (2) H^ copies its input and transitions to qc.
>> > (3) H^ begins processing Wm Wm a pair of TMD copies of itself.
>> > (4) H^ does whatever it does to decide halting for Wm Wm.
>>
>> Kind of. From step 3, H^ behaves as H', and H' starts by behaving like
>> H
>
> Yes at the exact point of step (3) we are at the start state of both
> H' and H.

Odd, then, that you rejected all my attempts to make that clear. You
flat-out refused to state that qc is the start state of H and H'. I
think you just say things based on the immediate context without any
memory of what you've said or claimed before.

Anyway, I'm, glad we now agree on what qc stands for (though I think you
contradict yourself below).

>> so what happens from step three is best described in terms of what H'
>> and H do.
>
> No. Neither H' nor H are exactly H^ and neither H' nor H have (H^, H^)
> as their input. When H^ begins to analyze its input, its input has an
> entirely different start state than either H' or H. (All three
> machines name their start state q0).

Nonsense (literally and figuratively). Do the exercise and you'll see.
You simply don't know how to use Linz's notation. I don't see any value
in my explaining it again and I'm sure you won't ever do the simple
exercise so I think you are doomed to stay in this loop indefinitely.

<snip>

>> > If H^ simply acts as an interpreter for its input then:
>> >
>> > (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
>> > (2) Wm copies its own input and transitions to its own qc.
>> > (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
>> > (4) Wm does whatever it does to decide halting for Wm2 Wm2.
>>
>> For some H, H^ will do this.
>
> I have only been talking about the single instance of H^ being
> executed with a TMD of itself as its input, thus there is no H' nor H,
> only H^.

You need to find someone locally who can read what you write and help
you out. I'm sure you wouldn't believe me if I told you what you've
just said, and I doubt that re-reading it will make you see how absurd
it is.

>> But the construction of H^ lets one deduce
>> something about H' and then about H from this behaviour. That's a
>> crucial part of the argument. I don't think you know how to do that,
>> because you've got stuck in a loop of your own.
>
> I cannot understand why you keep jumping around and changing the
> subject away from H^ to either H' or H. I am only talking about H^
> being executed with a TMD of itself as its input.

Because it's what H^ does -- it copies its input and then behaves like
H'. You can't get anywhere until you stop jumping around and grasp that
basic definition. If you did the exercise, you might see.

>> <snip>
>> >> > Now like every other definition of the Halting Problem counter-example
>> >> > it is stuck copying its input in infinite recursion.
>> >>
>> >> Nope. If you did the exercise you would see that it does not. I am
>> >> beginning to think you are are too frightened to do it
>> >
>> > I just did it. I am pretty sure that this is several times now that I did it.
>> > I tried to make this one more clear.
>>
>> Please, that just makes you look silly. You didn't even know what
>> Linz's notation for a TM meant,
>
> Bullshit.

Great! So you do understand his notation for a TM? There is nothing
stopping you from doing the exercise then. If you don't want to use my
H, write out your own.

--
Ben.

[peteolcott]

<snip>

.....q0 Wm |-* H^ qc Wm Wm |-* H^

Maybe this make make what I am saying clearer:
.....H^ qc Wm Wm |-*

I am trying to show one possible execution trace for the |-*
wildcard unspecified set of state transitions shown beginning
at state qc listed above.

It is not that I do not understand what Linz is saying.
It is that I am extending my analysis well beyond anything
that he said.

I will respond to your other message on Monday.
I only respond to the prior days messages once a
day, and I always take Sunday off to keep the Sabbath Holy.

These two rules keep my working on this stuff below 50
hours per week. I spent 1/2 day responding to messages
and 1/2 day doing additional analysis and research.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:
<snip>
> .....q0 Wm |-* H^ qc Wm Wm |-* H^
>
> Maybe this make make what I am saying clearer:
> .....H^ qc Wm Wm |-*

No, but that's fine. Provided you are saying nothing intelligible there
is nothing to correct.

> I am trying to show one possible execution trace for the |-*
> wildcard unspecified set of state transitions shown beginning
> at state qc listed above.

If all you want to say now is what H^ *might* do, go ahead. What you
said before about what H^ actually did was wrong and that needed
correcting. What's certain is that you will never say anything
interesting about H^.

<snip>
--
Ben.

[peteolcott]

I do not stop believing verifiable facts. That you propose that I
should seems to show very sloppy reasoning on your part. The |-*
symbols specifies an infinite set different different state
transitions.

> is to do the
> exercise I suggested. You'll then see, clear as day, an H^ with no
> unspecified sequences of state transitions and only a finite number of
> configurations (for any given tape, of course -- even the degenerate 1
> state TM has infinite configurations if you include all the possible
> tapes it can be started with).

The single state tape may have an infinite number of different states
yet only a single execution trace.

>
> > Within the single element of this infinite set where H^ acts as and
> > interpreter (UTM) and simply executes its input state by state, H^ and
> > its input unequivocally specify infinitely recursive input.
>
> Pure fantasy. H^ can behave in many ways -- most of which you have
> never even imagined.

It looks like you cannot imagine it simply as an (UTM) interpreter.
If you could then the execution trace that I propose would be a syntactic
logical consequence from this premise.

>
> > I will probably have to formalize this with my brand new (as of March
> > 10, 2017) Minimal Type Theory or it will be too difficult for you to
> > see this.
>
> Note that if you succeed in proving what you say it will immediately
> show your Minimal Type Theory to be faulty.

You lack the imagination to follow the execution trace of H^ where the
|-* wildcard states cause H^ to only be a UTM interpreter of its input.

We cannot proceed until you understand the execution trace of H^
in the context that its |-* specify H^ as only a UTM interpreter
of its input. This is a mandatory prerequisite.
<snip>

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

<snip>

> I do not stop believing verifiable facts. That you propose that I
> should seems to show very sloppy reasoning on your part. The |-*
> symbols specifies an infinite set different different state
> transitions.

Nope. There's no point in my trying to explain it because it's just the
simplest matter of nation. Linz explains it as clearly as I could and
you don't yet know what it means so I don't think there's much hope.

Here's a fact you might like to ponder. If I write

q0 |-*M qx

(the M is a subscript, of course) I am *always* describing a finite
sequence of transitions. I wonder if you agree.

When you are inclined to deepen your understanding, you could try to
write out a few simple machines as I suggested. Building H' and H^ from
the H I gave would be a good start.

> On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote:

>> is to do the
>> exercise I suggested. You'll then see, clear as day, an H^ with no
>> unspecified sequences of state transitions and only a finite number of
>> configurations (for any given tape, of course -- even the degenerate 1
>> state TM has infinite configurations if you include all the possible
>> tapes it can be started with).
>
> The single state tape may have an infinite number of different states
> yet only a single execution trace.

Nonsense. Do you really expect to be taken seriously when you write
such things? Am I supposed to try to tease out your meaning from this
abuse of technical terms? I've ploughed though a lot of mediocre exam
answers so I can guess what you might mean, but why should I bother?

>> peteolcott <peterolcott> writes:

>> > Within the single element of this infinite set where H^ acts as and
>> > interpreter (UTM) and simply executes its input state by state, H^ and
>> > its input unequivocally specify infinitely recursive input.
>>
>> Pure fantasy. H^ can behave in many ways -- most of which you have
>> never even imagined.
>
> It looks like you cannot imagine it simply as an (UTM) interpreter.
> If you could then the execution trace that I propose would be a syntactic
> logical consequence from this premise.

This displays a serious flaw in your reasoning. Since you obviously
don't follow yet, here's the gist of the exchange:

you: ...where H^ acts like a UTM ...
me: H^ can act in many ways.
you: You obviously can't imagine H^ acting like a UTM.

Do you see the problem?

<snip>

> We cannot proceed until you understand the execution trace of H^
> in the context that its |-* specify H^ as only a UTM interpreter
> of its input. This is a mandatory prerequisite.

I think it would be better to start with you showing me you know how to
write out a TM. Try, for example constructing H' from the H I gave
you. I don't think you can do H^ yet, but you might get there
eventually once you know how to write a TM.

Then I might try to explain why the behaviour of H^ in the one case you
have become obsessed with is of no consequence to a theorem about a
general and unspecified H.

--
Ben.

[peteolcott]

On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote:
> I'll cut to the chase...
> peteolcott <peteolcott> writes:
> <snip>
> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2
> > which for clarity we will call Wm_3.
> >
> > The next step of the execution trace of Wm_1 indicates that it begins
> > its own evaluation execution trace of Wm_2 Wm_3.
> >
> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3
> > which for clarity we will call Wm_4.
>
> None of the Wm have an execution trace. They are stings in the alphabet
> of the TM H (and H^). The only thing that can have has any "execution
> trace" is H^ and we have no idea what it does after copying the tape
> other than it behaves like some other machine called H.
>

Updated with all three pages and YELLOW highlighting.
http://liarparadox.org/HP_Infinite_Recursion.pdf

H quoted from page 318

q0 Wm W |-* H x1 qy x2

q0 Wm W |-* H y1 qn y2

H^ quoted from page 319
q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞
q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2

Corrected H^ from above quote
q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

(1) As shown on page 320 Wm would have the same execution trace as H^.

(2) Since we agreed that H^ does not pray to its creator, nor flip a coin in its second |-* sequence of unspecified state transitions it must process its input to determine the last states in its state transition sequence.

(3) There exists a finite set of categories of the types of processing that can occur second |-* sequence of unspecified state transitions.

(4) One of the elements of this finite set of types categories of processing is for H^ to act as a UTM interpreter of Wm Wm beginning at its corrected state qc.

[peteolcott]

On Monday, March 27, 2017 at 4:20:51 PM UTC-5, Ben Bacarisse wrote:

A said that incorrectly. A single state tape can have an infinite number of different configurations because the tape is an aspect of its configuration.

> Am I supposed to try to tease out your meaning from this
> abuse of technical terms? I've ploughed though a lot of mediocre exam
> answers so I can guess what you might mean, but why should I bother?
>
> >> peteolcott <peterolcott> writes:
>
> >> > Within the single element of this infinite set where H^ acts as and
> >> > interpreter (UTM) and simply executes its input state by state, H^ and
> >> > its input unequivocally specify infinitely recursive input.
> >>
> >> Pure fantasy. H^ can behave in many ways -- most of which you have
> >> never even imagined.
> >
> > It looks like you cannot imagine it simply as an (UTM) interpreter.
> > If you could then the execution trace that I propose would be a syntactic
> > logical consequence from this premise.
>
> This displays a serious flaw in your reasoning. Since you obviously
> don't follow yet, here's the gist of the exchange:
>
> you: ...where H^ acts like a UTM ...
> me: H^ can act in many ways.
> you: You obviously can't imagine H^ acting like a UTM.
>
> Do you see the problem?

If we begin with the single premise (of an infinite set of premises) that H^ acts as a UTM and simply executes its input, then (within this single premise) H^ has an infinitely recursive specification.

>
> <snip>
> > We cannot proceed until you understand the execution trace of H^
> > in the context that its |-* specify H^ as only a UTM interpreter
> > of its input. This is a mandatory prerequisite.
>
> I think it would be better to start with you showing me you know how to
> write out a TM. Try, for example constructing H' from the H I gave
> you. I don't think you can do H^ yet, but you might get there
> eventually once you know how to write a TM.
>

~~ Corrected H^ abbreviated state transitions from quoted from page 319
~~ q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
~~ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

[Tape Location]---[Machine State]---[Linz notation]---[Action]
Tape01--State00 q0 Wm goto 001 // Wm is at Tape09
Tape02--State01 |-* copy input goto 002
Tape03--State02 qc Wm Wm goto 003
Tape04--State03 |-* process copied input then goto 004 or 007
Tape05--State04 qy goto 005
Tape06--State05 qa goto 006
Tape07--State06 qb goto 005
Tape08--State07 qn
Tape09--State00 q0 Wm goto 001
Tape10--State01 |-* copy input goto 002
Tape11--State02 qc Wm Wm goto 003
Tape12--State03 |-* process copied input then goto 004 or 007
Tape13--State04 qy goto 005
Tape14--State05 qa goto 006
Tape15--State06 qb goto 005
Tape16--State07 qn

The above is a pseudo Turing Machine Description of H^ configured with a copy of itself as its own input beginning at Tape location Tape09.

> Then I might try to explain why the behaviour of H^ in the one case you
> have become obsessed with is of no consequence to a theorem about a
> general and unspecified H.
>
> --
> Ben.

The behavior of the one case that I am focusing on is the reason why Kurt Gödel's first incompleteness theorem is incorrect, as I have proven in my paper.

Three online sources of my paper:
https://philpapers.org/archive/PETMTT-4.pdf
https://www.researchgate.net/publication/315367846_Minimal_Type_Theory_MTT
http://liarparadox.org/Minimal_Type_Theory.pdf

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote:
>> I'll cut to the chase...
>> peteolcott <peteolcott> writes:
>> <snip>
>> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
>> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2
>> > which for clarity we will call Wm_3.
>> >
>> > The next step of the execution trace of Wm_1 indicates that it begins
>> > its own evaluation execution trace of Wm_2 Wm_3.
>> >
>> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3
>> > which for clarity we will call Wm_4.
>>
>> None of the Wm have an execution trace. They are stings in the alphabet
>> of the TM H (and H^). The only thing that can have has any "execution
>> trace" is H^ and we have no idea what it does after copying the tape
>> other than it behaves like some other machine called H.
>
> Updated with all three pages and YELLOW highlighting.
> http://liarparadox.org/HP_Infinite_Recursion.pdf
>
> H quoted from page 318
> q0 Wm W |-* H x1 qy x2
> q0 Wm W |-* H y1 qn y2

With some very important text about which of these two applies.

> H^ quoted from page 319
> q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞
> q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2
>
> Corrected H^ from above quote
> q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
> q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

With some very important wording about which of these two applies. You
really should care about that which of these two lines applies (and why
have you missed off H'?).

> (1) As shown on page 320 Wm would have the same execution trace as H^.

No. Nothing on page 320 says anything like that. Certainly none of
your quotes do. Do you still now know what this notation means?

> (2) Since we agreed that H^ does not pray to its creator, nor flip a
> coin in its second |-* sequence of unspecified state transitions it
> must process its input to determine the last states in its state
> transition sequence.

It processes its input by copying it. Other than that you have no idea
what it does. It might halt at the very next step. If you did the
exercise I suggested some of this might become clearer.

> (3) There exists a finite set of categories of the types of processing
> that can occur second |-* sequence of unspecified state transitions.

Yes! None of these include H^ being derived from an H that is a halting
decider. You are a hair's breadth way from understanding the proof.

> (4) One of the elements of this finite set of types categories of
> processing is for H^ to act as a UTM interpreter of Wm Wm beginning at
> its corrected state qc.

Yes. You need to stop obsessing about one case that is not a halting
decider and see if you can make any general arguments about any
conceivable H.

--
Ben.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Monday, March 27, 2017 at 4:20:51 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>> > On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote:

<snip>

>> >> is to do the
>> >> exercise I suggested. You'll then see, clear as day, an H^ with no
>> >> unspecified sequences of state transitions and only a finite number of
>> >> configurations (for any given tape, of course -- even the degenerate 1
>> >> state TM has infinite configurations if you include all the possible
>> >> tapes it can be started with).
>> >
>> > The single state tape may have an infinite number of different states
>> > yet only a single execution trace.
>>
>> Nonsense. Do you really expect to be taken seriously when you write
>> such things?
>
> A said that incorrectly. A single state tape can have an infinite
> number of different configurations because the tape is an aspect of
> its configuration.

Still nonsense. Do you mean "a single state TM"? If so you are just
saying what I said. If not, what is a "single state tape"?

<snip>

>> > It looks like you cannot imagine it simply as an (UTM) interpreter.
>> > If you could then the execution trace that I propose would be a syntactic
>> > logical consequence from this premise.
>>
>> This displays a serious flaw in your reasoning. Since you obviously
>> don't follow yet, here's the gist of the exchange:
>>
>> you: ...where H^ acts like a UTM ...
>> me: H^ can act in many ways.
>> you: You obviously can't imagine H^ acting like a UTM.
>>
>> Do you see the problem?
>
> If we begin with the single premise (of an infinite set of premises)
> that H^ acts as a UTM and simply executes its input, then (within this
> single premise) H^ has an infinitely recursive specification.

So what? If you start with this premise your conclusions will be
contingent on it. No one doubts that *some* H^ behave like this. Linz
shows that *no* H^ behaves as if were derived from a halting decider.

<snip>
--
Ben.

[peteolcott]

On Tuesday, March 28, 2017 at 7:18:12 PM UTC-5, Ben Bacarisse wrote:

I call bullshit you are either being disingenuous or not paying enough attention. Page 320 says that w^ is a TMD of H^, thus would have (if it was executed) and identical execution trace as H^ because w^ is a TMD of H^.

>
> > (2) Since we agreed that H^ does not pray to its creator, nor flip a
> > coin in its second |-* sequence of unspecified state transitions it
> > must process its input to determine the last states in its state
> > transition sequence.
>
> It processes its input by copying it. Other than that you have no idea
> what it does. It might halt at the very next step. If you did the
> exercise I suggested some of this might become clearer.

At q0 is processed its input by copying it. At qc it processes its input by analyzing it.

>
> > (3) There exists a finite set of categories of the types of processing
> > that can occur second |-* sequence of unspecified state transitions.
>
> Yes! None of these include H^ being derived from an H that is a halting
> decider. You are a hair's breadth way from understanding the proof.
>
> > (4) One of the elements of this finite set of types categories of
> > processing is for H^ to act as a UTM interpreter of Wm Wm beginning at
> > its corrected state qc.
>
> Yes. You need to stop obsessing about one case that is not a halting
> decider and see if you can make any general arguments about any
> conceivable H.
>

I really did correctly refute Kurt Gödel’s (1931) first incompleteness theorem which was Alan Turing's basis for his Halting Problem. Pity you don't have the math to check this other proof.

The error of the GIT is that G specifies an infinitely recursive evaluation sequence such that G is not a Truth Bearer and therefore not in F.

The GIT really only proved that some logical expressions that are not in F cannot be proved in F.

[Ben Bacarisse]

Nothing on that page (and certainly none of your quote from it) make the
same assumption that you do. You are assuming that H^ is UTM. Linz
can't make that assumption because he needs to prove properties that
apply to *any* H^ whatsoever.

You are free to prove the Olcott theorem -- that *some* machines,
constructed as Linz construct H^, loop indefinitely copying their input.
It's a trivial and uninteresting theorem. Linz is not interested in
what would happen in only those cases since the they are just particular
cases of the general result.

>> > (2) Since we agreed that H^ does not pray to its creator, nor flip a
>> > coin in its second |-* sequence of unspecified state transitions it
>> > must process its input to determine the last states in its state
>> > transition sequence.
>>
>> It processes its input by copying it. Other than that you have no idea
>> what it does. It might halt at the very next step. If you did the
>> exercise I suggested some of this might become clearer.
>
> At q0 is processed its input by copying it. At qc it processes its
> input by analyzing it.

No. You won't ever know what H^ really does until you do the exercise I
suggested. If you dared to so it (I can see now that, since you haven't
read the book, you will find it harder than I thought) you would find an
immediate counter-example to what you've just said here.

Why won't you do it? I'll help.

<snip>
> The error of the GIT...

You can't even write a correct sentence in FOPL (I've been watching your
attempts to do so over in sci.logic). Your errors here are nothing in
comparison.

<snip>
--
Ben.

[peteolcott]

My categorically exhaustive mathematical system of infallible reasoning considers broad categories of possible premises such that every category of a possible premise can be fully analyzed. Because this system is categorically exhaustive it totally eliminates what could otherwise possibly be gaps in reasoning.

The first category that I am analyzing here is the case where H^ is a UTM that simply executes its input. In this case it can be seen that H^ never terminates because its input specification is infinitely recursive. H^ would never even reach the H' states.

<snip>

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:
<snip>

> The first category that I am analyzing here is the case where H^ is a
> UTM that simply executes its input.

Yes I know. When you are ready to engage with the argument in Linz (or,
indeed, any of the other dozens of proofs of the theorem or of others
from which it follows) just say so. If you don't follow anything, ask a
question. A first step would be to try the exercise I suggested --
writing an actual H' and H^.

<snip>
--
Ben.

[peteolcott]

On Saturday, April 1, 2017 at 6:50:10 PM UTC-5, Ben Bacarisse wrote:

Been there, done that. You snipped it and ignored it.

If one begins one's deductive logical inference on the basis of an exhaustive set of every possible category of mutually exclusive premise, one knows that exactly one of these chains of inference is certainly correct.

You probably won't accept this even though it is self-evidently correct only because you never read it in a textbook before.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Saturday, April 1, 2017 at 6:50:10 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>> <snip>
>> > The first category that I am analyzing here is the case where H^ is a
>> > UTM that simply executes its input.
>>
>> Yes I know. When you are ready to engage with the argument in Linz (or,
>> indeed, any of the other dozens of proofs of the theorem or of others
>> from which it follows) just say so. If you don't follow anything, ask a
>> question. A first step would be to try the exercise I suggested --
>> writing an actual H' and H^.
>>
>> <snip>
>> --
>> Ben.
>
> Been there, done that. You snipped it and ignored it.

Of course. This is what I snipped:

| My categorically exhaustive mathematical system of infallible reasoning
| considers broad categories of possible premises such that every category
| of a possible premise can be fully analyzed. Because this system is
| categorically exhaustive it totally eliminates what could otherwise
| possibly be gaps in reasoning.

No kind person would comment on this sort of grandiose waffle (but do
keep a copy in case a doctor ever asks about it).

Best just to skip to the part what you say you are talking about *some*
H^ and not (as Linz is doing) all possible H^.

> If one begins one's deductive logical inference on the basis of an
> exhaustive set of every possible category of mutually exclusive
> premise, one knows that exactly one of these chains of inference is
> certainly correct.
>
> You probably won't accept this even though it is self-evidently
> correct only because you never read it in a textbook before.

What part of "yes" are you taking to mean I don't accept it?

--
Ben.

[peteolcott]

On Saturday, April 1, 2017 at 9:19:37 PM UTC-5, Ben Bacarisse wrote:
> peteolcott <peterolcott> writes:
>
> > On Saturday, April 1, 2017 at 6:50:10 PM UTC-5, Ben Bacarisse wrote:
> >> peteolcott <peterolcott> writes:
> >> <snip>
> >> > The first category that I am analyzing here is the case where H^ is a
> >> > UTM that simply executes its input.
> >>
> >> Yes I know. When you are ready to engage with the argument in Linz (or,
> >> indeed, any of the other dozens of proofs of the theorem or of others
> >> from which it follows) just say so. If you don't follow anything, ask a
> >> question. A first step would be to try the exercise I suggested --
> >> writing an actual H' and H^.
> >>
> >> <snip>
> >> --
> >> Ben.
> >
> > Been there, done that. You snipped it and ignored it.
>
> Of course. This is what I snipped:
>
> | My categorically exhaustive mathematical system of infallible reasoning
> | considers broad categories of possible premises such that every category
> | of a possible premise can be fully analyzed. Because this system is
> | categorically exhaustive it totally eliminates what could otherwise
> | possibly be gaps in reasoning.

And of course you thought that the above is my version of H^ and the below is not. Because my religion is to love others I will not stoop the level of disrespect that you are showing me. I won't assume what could possibly be dishonesty is indeed dishonesty, I will give you the benefit of the doubt and call it an honest mistake.

http://LiarParadox.org/HP_Infinite_Recursion.pdf

Corrected H^ abbreviated state transitions from quoted from page 319

q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2

[Tape Location]---[Machine State]---[Linz notation]---[Action]
Tape01--State00 q0 Wm goto 001 // Wm is at Tape09
Tape02--State01 |-* copy input goto 002
Tape03--State02 qc Wm Wm goto 003
Tape04--State03 |-* process copied input then goto 004 or 007
Tape05--State04 qy goto 005
Tape06--State05 qa goto 006
Tape07--State06 qb goto 005
Tape08--State07 qn
Tape09--State00 q0 Wm goto 001
Tape10--State01 |-* copy input goto 002
Tape11--State02 qc Wm Wm goto 003
Tape12--State03 |-* process copied input then goto 004 or 007
Tape13--State04 qy goto 005
Tape14--State05 qa goto 006
Tape15--State06 qb goto 005
Tape16--State07 qn

The above is a pseudo Turing Machine Description of H^ configured with a copy of itself as its own input at Tape location Tape09.
<snip>

[Ben Bacarisse]

The material you quote again below has nothing to with the exercise I
suggest you try. How am I supposed to know which bit of random junk the
"been there, done that" refers to?

> Because my religion is to love others I will not stoop the level of
> disrespect that you are showing me.

Why now? You've called a liar and accused me of dishonesty several
times in the past. Is your religious conversion a recent one? If you
think I'm lying or being dishonest I'd much rather you said so. I'd
like everyone reading the exchange to know that it was you think.

> I won't assume what could possibly
> be dishonesty is indeed dishonesty, I will give you the benefit of the
> doubt and call it an honest mistake.

I'm not really bothered, but I had no idea what you though I should not
have cut and ignored. Your main objective it to get people to talk to
you, so posting yards of junk helps you because it increases the chance
that someone may see something they feel should to commented on, but I
don't have time to talk about all the rubbish you write. I usually
simply correct a few obvious errors in case anyone coming along later
might be taken in by your posts.

This:

> q0 Wm |-* H^ qc Wm Wm |-* H^ ∞
> q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
>
> [Tape Location]---[Machine State]---[Linz notation]---[Action]
> Tape01--State00 q0 Wm goto 001 // Wm is at Tape09
> Tape02--State01 |-* copy input goto 002
> Tape03--State02 qc Wm Wm goto 003
> Tape04--State03 |-* process copied input then goto 004 or 007
> Tape05--State04 qy goto 005
> Tape06--State05 qa goto 006
> Tape07--State06 qb goto 005
> Tape08--State07 qn
> Tape09--State00 q0 Wm goto 001
> Tape10--State01 |-* copy input goto 002
> Tape11--State02 qc Wm Wm goto 003
> Tape12--State03 |-* process copied input then goto 004 or 007
> Tape13--State04 qy goto 005
> Tape14--State05 qa goto 006
> Tape15--State06 qb goto 005
> Tape16--State07 qn
>
> The above is a pseudo Turing Machine Description of H^ configured with
> a copy of itself as its own input at Tape location Tape09.

shows me several things, but nothing very new. It show me that you
don't know how to write a Turning machine. It shows me that you don't
know what a tape location is. It shows me that you don't know what
Linz's notation means (interstingly in a new way -- I thought you where
a bit confused about it, but "Tape05--State04" to "Tape08--State07"
shows a very specific misunderstanding that I had no idea you held until
now).

It is also not the exercise I suggested you try. That would involve
*actually writing a Turning machine*. Have you ever done that?

--
Ben.

[peteolcott]

http://www2.lns.mit.edu/~dsw/turing/turing.html

http://www2.lns.mit.edu/~dsw/turing/doc/tm_manual.txt
The machine is adopted from Prather, page 481.
Do you know which Prather he is referring to?

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Monday, April 3, 2017 at 7:27:12 PM UTC-5, Ben Bacarisse wrote:

<snip>

>> It is also not the exercise I suggested you try. That would involve
>> *actually writing a Turning machine*. Have you ever done that?
>>

> http://www2.lns.mit.edu/~dsw/turing/turing.html
>
> http://www2.lns.mit.edu/~dsw/turing/doc/tm_manual.txt
> The machine is adopted from Prather, page 481.
> Do you know which Prather he is referring to?

No, but "Discrete mathematical structures for computer science" would be
my fist guess. Does this mean you are actually going to write a TM?
Are you going to try the exercise I suggested?

--
Ben.

[peteolcott]

On Monday, April 10, 2017 at 8:35:11 AM UTC-5, Ben Bacarisse wrote:

The above is an actual TM interpreter. It looks like it actually runs conventional TM descriptions. It seems that the author only documented his TM description language by referring to ancient textbooks.

My initial goal is to define a Turing Machine that specifies the semantics of the "<" operator (as an axiom) as this operator applies to the set of Natural numbers expressed as finite strings of ASCII digits.

There is a joker in the other forum that just can't seem to accept that "7 < 3" is false. The concrete example of my formal schema for Boolean-True uses the "<" Less-Than operator to concretely demonstrate exactly how this formula template decides: True, False, and Neither for each finite string.

By the way, I will repeat again, whatever newsgroup server you are using is sharing private email addresses with the world.

[Ben Bacarisse]

peteolcott <petero...@gmail.com> writes:

> On Monday, April 10, 2017 at 8:35:11 AM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>>
>> > On Monday, April 3, 2017 at 7:27:12 PM UTC-5, Ben Bacarisse wrote:
>> <snip>
>> >> It is also not the exercise I suggested you try. That would involve
>> >> *actually writing a Turning machine*. Have you ever done that?
>> >>
>> > http://www2.lns.mit.edu/~dsw/turing/turing.html
>> >
>> > http://www2.lns.mit.edu/~dsw/turing/doc/tm_manual.txt
>> > The machine is adopted from Prather, page 481.
>> > Do you know which Prather he is referring to?
>>
>> No, but "Discrete mathematical structures for computer science" would be
>> my fist guess. Does this mean you are actually going to write a TM?
>> Are you going to try the exercise I suggested?
>>
>

> The above is an actual TM interpreter. It looks like it actually runs
> conventional TM descriptions.

I know.

> It seems that the author only documented
> his TM description language by referring to ancient textbooks.

The input language is trivial. Don't you see how it works? Just look
at any of the examples.

> My initial goal is to define a Turing Machine that specifies the
> semantics of the "<" operator (as an axiom) as this operator applies
> to the set of Natural numbers expressed as finite strings of ASCII
> digits.

Again, trivial. Why do such simple things take you so long? It's not
surprising that you haven't done the exercise I suggested. I thought it
would be a matter a few minutes, but I think you probably couldn't do it
yet and you will never ask for help.

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

No. There is someone who knows far more about logic than you do who is
trying to get you to:

(a) Define the WFF of your MTT.
(b) Show a proof using your supposed Truth(x) predicate.
(c) Get you to understand that Godel's "Gen" is a function from NxN to N.

It's sad to watch you trying hard to avoid the first, refusing to do the
second and completely losing your rag because you don't understand the
third.

<snip>

> By the way, I will repeat again, whatever newsgroup server you are
> using is sharing private email addresses with the world.

Of course. It correctly implements NTTP, unlike Google Groups. You
should never post anything (addresses included) to Usenet that you do
not want to be made public.

--
Ben.

[Pete Olcott]

You are a total jackass !!!

[Peter Percival]

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

[peteolcott]

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>Logical Equivalence between → and ⊢</TITLE>
<STYLE TYPE="text/css">
<!--
@page { margin: 0.79in }
P { margin-bottom: 0.08in }
-->
</STYLE>
</HEAD>
<BODY LANG="en-US" DIR="LTR">

<P STYLE="margin-bottom: 0in"><FONT FACE="Lucida Console, monospace"><B><FONT SIZE=3>

(P → ((P → Q) ∧ (Q → R))) ↔ {P, P → Q, Q → R} ⊢ R <br>
(1) P & P → Q [rewritten as] Q<br>
(2) Q & Q → R [rewritten as] R<br>
(3) ∴ {P, P → Q, Q → R} ⊢ R<br><br>

The above example provides the logical equivalence of the LHS to the RHS.<br>
The LHS is a set of premises from which the RHS conclusion is derived.<br><br>
Truth Table of the above formal proof:<br><br>

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

</P>

</BODY>
</HTML>

[peteolcott]

(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

[peteolcott]

[peteolcott]

On 4/29/2017 2:35 PM, peteolcott wrote:
> Logical Equivalence between → and ⊢

I was testing the formatting of HTML

[peteolcott]

[peteolcott]

[peteolcott]

[Ben Bacarisse]

peteolcott <Pe...@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.

[peteolcott]

On 4/30/2017 5:05 PM, Ben Bacarisse wrote:
> peteolcott <Pe...@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.

[Ben Bacarisse]

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

--
Ben.

[Pete Olcott]

On 3/15/2017 12:12 PM, Ben Bacarisse wrote:

I'll cut to the chase...
peteolcott <peteo...@gmail.com> writes:
<snip>

So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
the execution trace of Wm_1 indicates that it makes a copy of Wm_2
which for clarity we will call Wm_3. 

The next step of the execution trace of Wm_1 indicates that it begins 
its own evaluation execution trace of Wm_2 Wm_3. 

The execution trace of Wm_2 indicates that it makes a copy of Wm_3
which for clarity we will call Wm_4.

None of the Wm have an execution trace.  They are stings in the alphabet
of the TM H (and H^).  The only thing that can have has any "execution
trace" is H^ and we have no idea what it does after copying the tape
other than it behaves like some other machine called H.

You don't understand Linz's notation, and you don't understand what H^
is.  And, as usual, you a confusing machines with representations of
machines.

<snip>

Maybe this much more precise wording will answer your prior objections.

http://liarparadox.org/HP_Infinite_Recursion.pdf // zoom in to see high resolution detail
Ĥ is being applied to its own TM description ŵ. // See top of page 320

// Definition of Ĥ (page 319) with detail added from Figure 12.2
// and Correction (no finite state machine can have two start states):
// q0 changed to qx

Final Definition of Ĥ after correction and added detail
q0 Wm ⊢* Ĥ qx Wm Wm ⊢* Ĥ qy qa ∞ // Correction and Detail
q0 Wm ⊢* Ĥ qx Wm Wm ⊢* Ĥ y1 qn y2 // Correction

regular expression syntax: (explantion of ⊢* symbol)
⊢ exactly one state transition
⊢+ one or more state transitions
⊢* zero or more (an arbitrary number) of state transitions

Would Ĥ transition to its state (qy) or ((qn)) on ŵ (a TM description of itself) ?

Up here here we are simply facts with no interpretation added
--------------------------------------------------------------------------------------
This is my analysis of these facts:

To answer this question we perform an execution trace on Ĥ.
The first thing that Ĥ does is make a copy of its input, for clarity we will call this copy ŵ2.
The next thing that Ĥ does begin to evaluate what ŵ would do on its input ŵ2, at state qx.
The execution trace of the above definition proves this result to this point .

The first thing that ŵ would do is make a copy of its input, for clarity we will call this copy ŵ3.
The next thing that ŵ would do begin to evaluate what ŵ2 would do on its input ŵ3 at state qx.
Can you see where this is going?

Copyright 2016, 2017, 2018 Pete Olcott

--
        Γ ⊢_FS A ≡ ∃Γ ⊆ FS Provable(Γ, A) // MTT notational conventions
∀X True(X) ≡ ∃Γ ⊆ MTT ∧ Axioms(Γ) Provable(Γ, X) // MTT Truth Predicate

[Pete Olcott]

On 1/16/2018 11:21 AM, Newberry wrote:

On Monday, January 15, 2018 at 10:13:42 PM UTC-8, Pete Olcott wrote:

On 3/15/2017 12:12 PM, Ben Bacarisse
      wrote:

    
    
      I'll cut to the chase...
peteolcott <pete...@gmail.com> writes:
<snip>

      
        So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2)
the execution trace of Wm_1 indicates that it makes a copy of Wm_2
which for clarity we will call Wm_3. 

The next step of the execution trace of Wm_1 indicates that it begins 
its own evaluation execution trace of Wm_2 Wm_3. 

The execution trace of Wm_2 indicates that it makes a copy of Wm_3
which for clarity we will call Wm_4.

      
      None of the Wm have an execution trace.  They are stings in the alphabet
of the TM H (and H^).  The only thing that can have has any "execution
trace" is H^ and we have no idea what it does after copying the tape
other than it behaves like some other machine called H.

You don't understand Linz's notation, and you don't understand what H^
is.  And, as usual, you a confusing machines with representations of
machines.

<snip>

    
    

    
    Maybe this much more
        precise wording will answer your prior objections.

      

    http://liarparadox.org/HP_Infinite_Recursion.pdf

Yes, Ĥ never halts, which means that it cannot say that it never halts.. 
  

Ĥ never halts because it never gets done evaluating its infinite input in
exactly the same way that the Liar Paradox never evaluates to True or False
because it is also stuck in exactly the same kind of infinite evaluation:
Pathological Self-Reference.

The PSR occurs when-so-ever any formal expression is translated into a
directed acyclic graph (DAG) and cycles must be inserted in this graph.
The algorithm for doing this is fully operational, thus formally defined.

http://liarparadox.org/index.php/2017/12/08/concise-formalization-of-the-liar-paradox/

Pay very close attention the following is entirely different than anything you have ever seen:
I had to enhance the way that predicate logic works. I had to create an {assign alias name} operator.
LHS is assigned as an alias name for the RHS
LHS ≡ RHS
The LHS is logically equivalent to the RHS Because the LHS is merely an alias name for the RHS
(An alias name in Minimal Type Theory works the same way as an alias name in computer science see above link)

"This sentence is not true."
LiarParadox ≡ ~True(LiarParadox)

// ⌈Ĥ⌉ Turing Machine description of Ĥ
Ĥ ≡ Halts(⌈Ĥ⌉)  //   Exactly the same as the Liar Paradox

Copyright 2017, 2018 Pete Olcott

[Pete Olcott]

On 1/16/2018 7:09 PM, Ben Bacarisse wrote:

George Greene <gre...@email.unc.edu> writes:
<snip>

The ACTUAL correction would read something like
      qx  Wm Wm ⊢* Ĥ y1 qn y2 ,
since Linz's notation ALWAYS starts with the state where you are beginning.
You are just assuming continuation from the previous/last state,
which is correct, but again, the question is HOW TO WRITE it clearly,
and Linz just fails massively.

Linz has a notation that could have been used to clear this up but it's
even more cumbersome: q_(A,0) for state 0 of machine A.  And while it
makes it clear what states belong to which machine that also obscures
the fact the all the machines in the construction share a lot of states
and transitions.  Do you say that q_(H,i) = q_(H',i) for all n states of
H, or do you allow them to be distinct provided the state transitions
are preserved by the correspondence between them?

It makes no odds, of course, since all that matters is the behaviour,
but when talking about states and transitions and traces you have to say
one way or the other.  Basically, the description is at the wrong level.
The level that matters is of computations and compositions of
computations.

What matters in an execution trace is the precise sequence of state transitions.
If you are not aware that all of the analysis pertains to Ĥ, you cannot possibly
correctly specify the sequence of state transitions that Ĥ makes.

http://liarparadox.org/HP_Infinite_Recursion.pdf // zoom in to see high resolution detail
Ĥ is being applied to its own TM description ŵ. // See top of page 320

// Definition of Ĥ (page 319) with detail added from Figure 12.2
// and Correction (no finite state machine can have two start states):
// q0 changed to qx

Final Definition of Ĥ after correction and added detail

q0 Wm ⊢* Ĥ qx Wm Wm ⊢* Ĥ qy ∞      // Correction and Detail

q0 Wm ⊢* Ĥ qx Wm Wm ⊢* Ĥ y1 qn y2 // Correction

Would Ĥ transition to its state (qy) or ((qn)) on ŵ (a TM description of itself) ?

If we ignore everything else that Linz said and focus on the above specified machine 
we can untangle the actual execution trace of Ĥ.

The lambda calculus works at the right level for this, but there is so
much more technical material to cover before students feel that a lambda
form really encapsulates the idea of an effective procedure that any
advantage this presentation may have is undone.

TM's are so simple to explain and so obviously capture the basic idea of
doing something mechanically that they are the natural choice.  What is
needed is a presentation that uses TMs but that works at a level higher
than the states and the transitions.  You can make it formal, but you do
that when explaining general constructs like

Then crucially important semantic meaning slips through the cracks of imprecision.
I call the Peter Linz presentation simple because his presentation is the simplest
possible way to present the exact nature of the actual problem with nothing
what-so-ever slipping through the cracks of higher level abstractions.

Since I have two patents on finite state machines I understand them far better than
you ever gave me credit for.
<snip>

[Pete Olcott]

So when the Halting Problem Proof is converted to HOL with self-reference
(assign alias operator ≡) it becomes obvious that any predicate: {Halts, True, Provable}
cannot be evaluated to resolve to either True or False because the
Pathological Self-Reference error causes it becomes stuck in an infinite evaluation loop.

Thus the Liar Paradox, 1931 Incompleteness Theorem, and the Halting Problem proof can
all be shown to have Pathological Self-Reference error. 

LP ≡ ~True(LP)        // Liar Paradox
G  ≡ ~Provable(G)  // 1931 Incompleteness Theorem
H  ≡ Halts(H)           // Halting Problem proof

When-so-ever any logic expression is translated into its equivalent directed acyclic graph
(DAG) and this translation requires the insertion of cycles into this otherwise acyclic graph
the Pathological Self-Reference error has occurred.

LP ≡ ~True(LP)        // Liar Paradox has PSR error
Translation into directed acyclic graph
01 LP   (02)
02 Not  (03)
03 True (01) // infinite evaluation loop

7 > 5  // Expression without PSR error Translation into directed acyclic graph
01 > (02)(3)
02 7
03 5

Copyright 2004, 2017, 2018 Pete Olcott

[Pete Olcott]

On 1/19/2018 6:00 PM, Ben Bacarisse wrote:

peteolcott <petero...@gmail.com> writes:

On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote:

peteolcott writes:

On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:

George Greene writes:
<snip>

The ACTUAL correction would read something like
      qx  Wm Wm ⊢* Ĥ y1 qn y2 ,
since Linz's notation ALWAYS starts with the state where you are beginning.
You are just assuming continuation from the previous/last state,
which is correct, but again, the question is HOW TO WRITE it clearly,
and Linz just fails massively.

Linz has a notation that could have been used to clear this up but it's
even more cumbersome: q_(A,0) for state 0 of machine A.  And while it
makes it clear what states belong to which machine that also obscures
the fact the all the machines in the construction share a lot of states
and transitions.  Do you say that q_(H,i) = q_(H',i) for all n states of
H, 

That would be a neat trick since H and H' have mutually exclusive
states.

No, H and H' may have non-intersecting state sets or they may not have.

If a cat is defined to be an animal you are no longer free to define
a cat as a pile of bricks. H is defined with two final states, H' is and 
adapted form of H where one of these final states has been converted
into an infinite loop. 

You can define H' either way.  The fact that you can't see this is very
telling.

That is analogous to defining a cat as a pile of bricks, thus 
positing this absurdity you are showing your lack of integrity.

No.  You analogy reveals you don't understand either what I wrote or
what a TM is.  Important facts about cats (such as they are not dogs) do
not depend on the names given to their hairs.

The states themselves have almost no significance for TMs.  What matters
is the state transition function.

state ((qy)) that was converted to (qy) ∞, both transitions 
having a defined semantics, equivalent to Boolean True.

No again.  The sates have no semantics of any significance.  We can call
them the green and the purple states.  The theorem then tells us of the
non-existence of a TM that can decide which strings encode those TMs
that enter a purple state (or, for that matter, a green state).

So all your hem-hawing to be disagreeable makes you disingenuous. You 
could understand and confirm what I say you prefer to be disagreeable
even a the cost of truth.

No.  You are completely at sea.  Mainly because you started with a false
conclusion as your premise -- halt deciding *must* be "wrong" in some
way -- and you have wasted more than a decade trying to find some way of
saying that that makes sense.

I will explain the essence of my reasoning using terms of the art as it applies
to the 1931 GIT,  because it is most clear when applied to the 1931 GIT.

Gödel's incompleteness theorems
The theorems are widely, but not universally, interpreted as showing that Hilbert's program to find a complete and consistent set of axioms for all mathematics is impossible.

Mathematics is a body of necessary truth thus necessarily always provable.

∀P ∈ Mathematics → ◻P
∀P ◻P ↔ Provable(P)

◇P ↔ ~◻~P Possibly(P) <--> Not(Necessarily) Not(P)
◻P ↔ ~◇~P Necessarily(P) <--> Not(Possibly) Not(P)

Now my three decade long intuition has a formal foundation that only requires further elaboration to be understood.
http://liarparadox.org/index.php/2018/01/17/terminology-of-minimal-type-theory/

[Pete Olcott]

On 1/24/2018 10:07 PM, Ben Bacarisse wrote:

peteolcott <petero...@gmail.com> writes:

On Wednesday, January 24, 2018 at 8:38:12 PM UTC-6, Ben Bacarisse wrote:

peteolcott writes:
<snip>

So how would be formalize the semantics of Halts when we are
going fully David Hilbert? 

∃x ∈ Finite_Strings & x ∈ Turing_Machine_Descriptions 
∀y ∈ Finite Strings & y ∈ Turing_Machine_Descriptions 
∀z ∈ Finite_Strings Halts(x, y, z)

or perhaps this 

∃x ∈ Turing_Machine_Descriptions 
∀y ∈ Turing_Machine_Descriptions 
∀z ∈ Finite_Strings Halts(x, y, z)

There is not much to choose between them.  Both speak volumes.

So you are back to simply being disrespectful again?

You have repeatedly called me a liar.  What makes you think you deserve
any respect from me (or from anyone else for that matter)?

Linz page Bottom of page 319
q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ ∞
q0 Wm ⊢* Ĥ q0 Wm Wm ⊢* Ĥ y1 qn y2

My correction

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

If you continued to say that I don't know that a TM cannot have two
start states after seeing the above that would have made you a liar.

Now I am willing to concede that you may have never seen this post since I can't find it.
In any case I clarified my blog based on your feedback.

--
“≡” is the <assign alias> operator
Provable(Γ, X)   ≡   ∃Γ ⊆ WFF ∧ (Γ ⊢ X)
True(X)   ≡   ∃Γ ⊆ Axioms ∧ Provable(Γ, X)

[Pete Olcott]

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) *

[Pete Olcott]

On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
> peteolcott <petero...@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


--

[Ben Bacarisse]

Pete Olcott <Pe...@NoEmail.address> writes:

> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>> peteolcott <petero...@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.

[Pete Olcott]

(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.

[Pete Olcott]

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.

[Ben Bacarisse]

Pete Olcott <Pe...@NoEmail.address> writes:

> On 1/31/2018 3:57 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pe...@NoEmail.address> writes:
>>
>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote:
>>>> peteolcott <petero...@gmail.com> writes:
<snip>

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.

[Ben Bacarisse]

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.

[Pete Olcott]

Formalized as: SentenceF(G) ∧ ~ProvableF(G) ∧ ~RefutableF(G)
Proving that the above sentence is false refutes the 1931 GIT.

You claiming that I do not know what the notation means is a grossly disrespectful lie
within the context that I have demonstrated that I do know that the notation means
countless times.

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 does not say this the definition of the problem that is specified
outside of the notation says this.

In any case that is all moot
http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/

By simply removing the infinitely recursive part such that Ĥ only has to decide whether or
not a single TM/input pair halts  Ĥ  ŵ  ŵ2  Becomes Decidable

[Pete Olcott]

On 2/1/2018 7:54 PM, Ben Bacarisse wrote:
> Pete Olcott <Pe...@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

[Ben Bacarisse]

Pete Olcott <Pe...@NoEmail.address> writes:

> On 2/1/2018 7:54 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pe...@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.

[Peter Percival]

Pete Olcott wrote:

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

Why not look it up? It might save you from such silliness. From a
well-known website:

the halting problem is the problem of determining, from a
description of an arbitrary computer program and an input,
whether the program will finish running or continue to run
forever

Do you see the difference between "a single" and "an arbitrary"?

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

[Pete Olcott]

On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
> Pete Olcott <Pe...@NoEmail.address> writes:
>

>> On 2/2/2018 3:38 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pe...@NoEmail.address> writes:
>>>
>>>> On 2/1/2018 8:04 PM, Ben Bacarisse wrote:
>>>>> Pete Olcott <Pe...@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.

[Ben Bacarisse]

Pete Olcott <Pe...@NoEmail.address> writes:

> On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
>> Pete Olcott <Pe...@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.

[Andy Walker]

On 02/02/18 21:30, Peter Percival wrote:
> Pete Olcott wrote:
>> The Halting Problem is about whether or not a TM exists that can decide
>> halting for a single TM input pair.
> Why not look it up?  It might save you from such silliness.  From a well-known website:
>     the halting problem is the problem of determining, from a
>     description of an arbitrary computer program and an input,
>     whether the program will finish running or continue to run
>     forever
> Do you see the difference between "a single" and "an arbitrary"?

Much as I sympathise with the attempts, no doubt doomed, to
educate Mr Olcott, the use of "arbitrary" in this context has its
own problems. Almost everyone here knows that we would like to find
*one* single TM that correctly determines *every* instance of the HP,
and that there is a well-known proof that no such TM exists. But
there are several related problems with which that can be confused,
because "arbitrary" could here also mean "pick one" [and don't bother
with all the others], or "pick *this* but not *that*, because *that*
is not arbitrary but has been carefully chosen" [to defeat a proposed
halt decider, or to be recursive, or whatever].

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

Two mini-anecdotes:

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

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

--
Andy Walker,
Nottingham.

[Andy Walker]

On 03/02/18 18:17, I wrote:
> This sort of problem is not well-understood by mpm-mathematicians.

Nor, for that matter, by non-mathematicians.

--
Andy Walker,
Nottingham.

[Pete Olcott]

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

[Ben Bacarisse]

Pete Olcott <Pe...@NoEmail.address> writes:

> On 2/3/2018 7:37 AM, Ben Bacarisse wrote:
>> Pete Olcott <Pe...@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.

[Pete Olcott]

On 2/6/2018 9:31 PM, Ben Bacarisse wrote:

peteolcott <petero...@gmail.com> writes:

On Tuesday, February 6, 2018 at 9:34:06 AM UTC-6, Ben Bacarisse wrote:

peteolcott writes:
<snip>

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

There is a theorem that proves this is not possible.  Inputs with what
you call PSR are not a decidable set.  No TM can spot them all.

Try and provide a single counter-example that meets this spec:

An expression of language (formal or otherwise) has the property 
of Pathological Self-Reference(Olcott 2004) when-so-ever the 
self-reference of this expression prevents this expression 
from being evaluated as True or False.

That's a definition (albeit not a very good one).  Do you even know what
a counter example is?  How can there be a counter example to a
definition?

You claim that it has been proven to be undecidable so it should not
be very hard for someone understanding this proof to come up with a
single valid counter-example that refutes my claim to be able to
always detect and report PSR.

Oh dear.  Of course I can't.

I wrote, and re-wrote, and then re-wrote again several answers to this
but in the end I lost heart and I've just deleted the text.  You don't
know what a counter example is, or what a decidable set is, and I don't
think I have the ability (and certainly not the inclination) to teach
you what they are.

I've told you why your objection to the classic halting theorem proof is
wrong.  I don't think I can do more.

I will however, retract my claim about PSR not being decidable.  I fear
it is a movable feast and it seems likely to me (from the current rather
vague wording) that there are no examples of it relating to halting.
That would make TMD/input pairs with PSR trivially decidable.  Then
again, maybe it means something else when applied to halting problems
and it really isn't decidable.  I can't tell and I don't care.

I will say only this: if Rice's theorem would apply to it then it is not
decidable.

<snip>

Definition of Turing Machine Ĥx    (Ĥ - loop)
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qy
q0 Wm ⊢* Ĥx qx Wm Wm ⊢* Ĥx qn

H [Ĥx][Ĥx] Specifies Pathological self-reference

You must realize that every halt decider must examine every state transition of its TMD until:
(1) It can be determined that the TMD would not halt.
(2) The TMD would transition to a specific final state.
It seems that you are in psychological denial of this key point.

--

[Pete Olcott]

On 2/8/2018 3:05 PM, Ben Bacarisse wrote:
> Pete Olcott <Pe...@NoEmail.address> writes:
>

>> On 2/7/2018 10:27 AM, Ben Bacarisse wrote:
>>> Pete Olcott <Pe...@NoEmail.address> writes:
>>>

>>>> On 2/6/2018 9:49 PM, Ben Bacarisse wrote:
>>>>> peteolcott <petero...@gmail.com> writes:

>>>>> <snip>
>>>>>> Sure this is Rice's claim:
>>>>>> Rice's theorem states that all non-trivial, semantic properties of
>>>>>> programs are undecidable.
>>>>>>
>>>>>> Since it can be reduced to the HP then:
>>>>>>
>>>>>> It becomes a false claim when the key semantic property that prevents
>>>>>> all other semantic properties from being evaluated is itself correctly
>>>>>> evaluated.
>>>>>
>>>>> What? The validity of a theorem is not contingent on random words you
>>>>> post on Usenet. It's validity depends on the published proofs. They
>>>>> are correct.
>>>>
>>>> The validity of any theorem is ultimately dependent upon all of the
>>>> details of the underlying semantics.
>>>
>>> No.
>>
>> So for example if the semantic consequence of a famous theorem
>> is contradictory, then you are saying that all is well because
>> it is only the syntax that counts?
>
> For the theorem to be a theorem, yes.
>
> That's not to say the semantics don't count for other reasons. For
> example, there are "machines" (models of computation, TM variations and
> so on) for which halting is decidable. These crop up in textbooks and
> are of theoretical interest but they don't "model" the sort of program
> we write. Turing machines (and all the other equivalent models) are so
> extensively studied because the semantics match the semantics of the
> program we actually write (except when a program runs out of storage, of
> course).
>
> All of this nonsense could end right here if you said that you now see
> that a proof is an essentially syntactic construct and that, therefore,
> you accept the proof. You can then "reformulate the essential nature of
> truth" so that these (syntactic) facts about TMs not longer trouble you.
>

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

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

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

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

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

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

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

The Nature of Analytic Truth in Plain English

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

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

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

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

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

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

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

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

Copyright 2017, 2018 Pete Olcott

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

[Ben Bacarisse]

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

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

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

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

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

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

--
Ben.

[Pete Olcott]

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

This is the formalized gist of the intuition that has kept me focused
on refuting the Incompleteness Theorem and the Halting Problem
for more than two decades.

The ultimate foundation of all analytical Truth.
For all (formal or natural language) L There exists a set T of finite strings
of language L that have been defined to have the semantic property of True.

Verifying that an expression X of language L is True or False in L only occurs
through a syntactic logical inference chain (formal proof) from X or ~X to one
or more elements of T.

Unless an expression X of language L has been proven to be True or False
by this syntactic inference chain it is not a statement of language L because
all statements must be True or False.

Copyright 2018 Pete Olcott
--

[Pete Olcott]

On 3/11/2017 3:13 PM, peteolcott wrote:

http://LiarParadox.org/HP_Infinite_Recursion.pdf 

As this page 319 of An Introduction to Formal Languages and Automata
by Peter Linz 1990 indicates

From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'.
 
q0 Wm |-* H-Hat q0 Wm Wm...

Page 320 indicates that we apply H-Hat to itself as input.

The problem is that every H-Hat needs a pair of inputs.

H-Hat takes an H-Hat as input and copies it so that it 
can analyze how its input H-hat would analyze the copy
of H-Hat that it just made. 

The input H-Hat would have to copy its own input H-Hat 
so that it can analyze what its own input H-Hat would 
do on its own input, on and on forever...

Copyright 2016 and 2017 Pete Olcott. 

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

Refutation of Halting Problem Proof

Decidability of the Halting Problem as a David Hilbert formalism
∃a ∈ Turing_Machines_Descriptions
∀b ∈ Finite_Strings  // some of these specify Turing Machine Descriptions
∀c ∈ Finite_Strings
Halts(a, b, c) ∨ ~Halts(a, b, c)

Halt Decider definition
A Halt Decider (HD) determines whether or not a finite string represents a correct
Turing Machine Description that would halt on its input. It does this by performing
a mathematical proof on a pair of finite strings as a David Hilbert formalism in the
language of Turing Machine Descriptions.

The syntactic logical consequence of this proof is two finite strings:
(1) “Y”  input pair (b,c) is a correct TMD that would halt on its input.
(2) “N” indicating the else branch of (1).

If the first element of the input finite string pair is a correct TMD then this proof
must necessarily proceed from the specified TMD start state through all of the
state transitions of this TMD to the halting or non halting behavior of this TMD.

The proof would essentially be a hypothetical execution trace** of the state
transition sequences of the input TMD. It cannot be an actual execution trace
or the halt decider could have non-halting behavior.
** Like step-by-step mode in a debugger.

http://liarparadox.org/HP_Infinite_Recursion.pdf
The following has been adapted from material from the above link:
We begin our analysis by constructing a hypothetical halt decider: H.

Figure 12.1 Turing Machine H


The dashed lines proceeding from state (q0) are represented in the text
definition as the asterisk ⊢* wildcard character. These conventions are
used to encode unspecified state transition sequences.

Definition of Turing Machine H (state transition sequence)
H.q0 Wm W ⊢* H.qy  // Wm W corresponds to (b,c) shown above
H.q0 Wm W ⊢* H.qn  // Wm W corresponds to (b,c) shown above

The diagram and the state transition sequence indicate that H begins at
its own start state H.q0 and is applied to finite string pair (Wm, W).

H.qy is the final state of H indicating that Wm is a correct TM that would
halt on input W.  Syntactic logical consequence : “Y” (shown above).

H.qn is the final state of H indicating that Wm is not a correct TM that would
halt on input W.  Syntactic logical consequence: “N” (shown above).

We create Turing Machine Ĥx by making the following changes to H:
(1) Ĥx copies its input Wm a its Ĥx.q0 state and transitions to its Ĥx.qx state.

(2) Ĥx would begin to evaluate Wm Wm at its Ĥx.qx state in exactly
the same way that H would begin to evaluate its Wm W input at its H.q0 state.

Since Turing Machine Ĥx is created by adapting H, it would have exactly the
same behavior at its Ĥx.qx state as H would have at its H.q0 state.

Figure 12.4 Turing Machine Ĥx


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

If Turing Machine H is applied to Turing Machine description [Ĥx] [Ĥx] 
 would it transition to H.y or H.n ? 

We append a “2” to the input to [Ĥx] for clarity [Ĥx2] is a copy of [Ĥx].

To answer this question we perform an execution trace on H
(1) H begins at its start state H.q0.
(2) H begins to evaluate what [Ĥx] would do on its input [Ĥx2].

Hypothetical Execution trace of what [Ĥ] would do if it was executed
(3) [Ĥx] would begin at its start state [Ĥx].q0
(4) [Ĥx] would make a copy of its input [Ĥx2], we will call this [Ĥx3].
(5) [Ĥx] would transition to its state [Ĥx].qx.
(6) [Ĥx] would begin to evaluate what [Ĥx2] would do on its input [Ĥx3].
Can you see the infinite recursion?

H [Ĥx] [Ĥx] specifies an infinitely recursive evaluation sequence.
Every HP proof by contradiction depends this same infinite recursion.

Because of this every TMD in the infinitely recursive sequence is defined in
terms of H each would reject the whole sequence as semantically incorrect
before even beginning any halting evaluation.

https://groups.google.com/forum/#!original/comp.theory/RO9Z9eCabeE/Ka8-xS2rdEEJ
Therefore H would correctly transition to its H.qn state rejecting the
infinitely recursive evaluation sequence specified by [Ĥx] [Ĥx] as the
semantic error of Pathological self-reference(Olcott 2004).

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

[Peter Percival]

Pete Olcott wrote:


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

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