Refuting the Tarski Undefinability Theorem

[olcott]

An analytic expression x is any expression of language verified as
completely true (or false) entirely on the basis that x (or ~x) is
derived by applying truth preserving operations to other expressions
of language that are stipulated to be true thus providing the semantic
meaning of terms.

...14 Every epistemological antinomy can likewise be used for a similar
undecidability proof...(Gödel 1931:43)

When we understand that a True(L, x) predicate only applies to analytic
expressions then Tarski's proof utterly fails because epistemological
antinomies are rejected as not analytic.

It would then be possible to reconstruct the antinomy of the liar
in the metalanguage, by forming in the language itself a sentence
x such that the sentence of the metalanguage which is correlated
with x asserts that x is not a true sentence.
https://liarparadox.org/Tarski_247_248.pdf
https://liarparadox.org/Tarski_275_276.pdf


The proof of Tarski's undefinability theorem in this form is again
by reductio ad absurdum. Suppose that an L-formula True(n)

as above existed, i.e., if A is a sentence of arithmetic, then
True(g(A)) holds in N if and only if A holds in N. Hence for all

A, the formula True(g(A)) ⟺ A holds in N. But the diagonal
lemma yields a counterexample to this equivalence, by

giving a "liar" formula S such that S ⟺ ¬True(g(A)) holds
in N. This is a contradiction QED.
https://en.wikipedia.org/wiki/Tarski%27s_undefinability_theorem


--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[Richard Damon]

On 2/4/24 10:53 AM, olcott wrote:
> An analytic expression x is any expression of language verified as
> completely true (or false) entirely on the basis that x (or ~x) is
> derived by applying truth preserving operations to other expressions
> of language that are stipulated to be true thus providing the semantic
> meaning of terms.

Right

>
> ...14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof...(Gödel 1931:43)
>

WHich you just don't understand what they did.

> When we understand that a True(L, x) predicate only applies to analytic
> expressions then Tarski's proof utterly fails because epistemological
> antinomies are rejected as not analytic.

So, the fact that the EXISTANCE of a computabe True(L, x), allows the
proving of that an epistemological antinomy must say that such a thing
can not exist doesn't matter to you?

>
> It would then be possible to reconstruct the antinomy of the liar
> in the metalanguage, by forming in the language itself a sentence
> x such that the sentence of the metalanguage which is correlated
> with x asserts that x is not a true sentence.
> https://liarparadox.org/Tarski_247_248.pdf
> https://liarparadox.org/Tarski_275_276.pdf

Yes, GIVEN the existance of a computable True(L, x), it is LOGICALLY
POSSIBLE to do this. Thus it is allowed.

The only way to stop it is to not assume the existance of a computable
True(L,x).

>
>
> The proof of Tarski's undefinability theorem in this form is again
> by reductio ad absurdum. Suppose that an L-formula True(n)
>
> as above existed, i.e., if A is a sentence of arithmetic, then
> True(g(A)) holds in N if and only if A holds in N. Hence for all
>
> A, the formula True(g(A)) ⟺ A holds in N. But the diagonal
> lemma yields a counterexample to this equivalence, by
>
> giving a "liar" formula S such that S ⟺ ¬True(g(A)) holds
> in N. This is a contradiction QED.
> https://en.wikipedia.org/wiki/Tarski%27s_undefinability_theorem
>
>

Yes, and if the system logically allows the construction, it allows the
construction.

You can't arbitrarily limit statements that are actually constructable
in the system from the system.

Your problem is that you just don't understand how meta-system logic works.

[olcott]

On 2/4/2024 11:45 AM, Richard Damon wrote:
> On 2/4/24 10:53 AM, olcott wrote:
>> An analytic expression x is any expression of language verified as
>> completely true (or false) entirely on the basis that x (or ~x) is
>> derived by applying truth preserving operations to other expressions
>> of language that are stipulated to be true thus providing the semantic
>> meaning of terms.
>
> Right
>
>>
>> ...14 Every epistemological antinomy can likewise be used for a
>> similar undecidability proof...(Gödel 1931:43)
>>
>
> WHich you just don't understand what they did.
>
>> When we understand that a True(L, x) predicate only applies to analytic
>> expressions then Tarski's proof utterly fails because epistemological
>> antinomies are rejected as not analytic.
>
> So, the fact that the EXISTANCE of a computabe True(L, x), allows the
> proving of that an epistemological antinomy must say that such a thing
> can not exist doesn't matter to you?
>

A truth predicate only deals with analytic expressions, everything
else is out-of-scope. A truth predicate rejects expressions that
are not analytic.

>>
>> It would then be possible to reconstruct the antinomy of the liar
>> in the metalanguage, by forming in the language itself a sentence
>> x such that the sentence of the metalanguage which is correlated
>> with x asserts that x is not a true sentence.
>> https://liarparadox.org/Tarski_247_248.pdf
>> https://liarparadox.org/Tarski_275_276.pdf
>
> Yes, GIVEN the existance of a computable True(L, x), it is LOGICALLY
> POSSIBLE to do this. Thus it is allowed.
>
> The only way to stop it is to not assume the existance of a computable
> True(L,x).
>

In the same way that formalized natural language rejects this sentence:
https://en.wikipedia.org/wiki/Colorless_green_ideas_sleep_furiously

You (ahead of most others) already know that the Liar Paradox is
not a truth bearer. This means that any correct and consistent
truth predicate must reject epistemological antinomies as out-of-scope.

[Richard Damon]

On 2/4/24 1:02 PM, olcott wrote:
> On 2/4/2024 11:45 AM, Richard Damon wrote:
>> On 2/4/24 10:53 AM, olcott wrote:
>>> An analytic expression x is any expression of language verified as
>>> completely true (or false) entirely on the basis that x (or ~x) is
>>> derived by applying truth preserving operations to other expressions
>>> of language that are stipulated to be true thus providing the semantic
>>> meaning of terms.
>>
>> Right
>>
>>>
>>> ...14 Every epistemological antinomy can likewise be used for a
>>> similar undecidability proof...(Gödel 1931:43)
>>>
>>
>> WHich you just don't understand what they did.
>>
>>> When we understand that a True(L, x) predicate only applies to analytic
>>> expressions then Tarski's proof utterly fails because epistemological
>>> antinomies are rejected as not analytic.
>>
>> So, the fact that the EXISTANCE of a computabe True(L, x), allows the
>> proving of that an epistemological antinomy must say that such a thing
>> can not exist doesn't matter to you?
>>
>
> A truth predicate only deals with analytic expressions, everything
> else is out-of-scope. A truth predicate rejects expressions that
> are not analytic.
>

A Truth Predicate needs to deal with ALL expressions in the Language.

Just like a Halt Decider must handle all programs definable in the system.

>>>
>>> It would then be possible to reconstruct the antinomy of the liar
>>> in the metalanguage, by forming in the language itself a sentence
>>> x such that the sentence of the metalanguage which is correlated
>>> with x asserts that x is not a true sentence.
>>> https://liarparadox.org/Tarski_247_248.pdf
>>> https://liarparadox.org/Tarski_275_276.pdf
>>
>> Yes, GIVEN the existance of a computable True(L, x), it is LOGICALLY
>> POSSIBLE to do this. Thus it is allowed.
>>
>> The only way to stop it is to not assume the existance of a computable
>> True(L,x).
>>
>
> In the same way that formalized natural language rejects this sentence:
> https://en.wikipedia.org/wiki/Colorless_green_ideas_sleep_furiously
>
> You (ahead of most others) already know that the Liar Paradox is
> not a truth bearer. This means that any correct and consistent
> truth predicate must reject epistemological antinomies as out-of-scope.
>
>

It can say they are not true, and neither is there complement.

[olcott]

On 2/4/2024 12:16 PM, Richard Damon wrote:
> On 2/4/24 1:02 PM, olcott wrote:
>> On 2/4/2024 11:45 AM, Richard Damon wrote:
>>> On 2/4/24 10:53 AM, olcott wrote:
>>>> An analytic expression x is any expression of language verified as
>>>> completely true (or false) entirely on the basis that x (or ~x) is
>>>> derived by applying truth preserving operations to other expressions
>>>> of language that are stipulated to be true thus providing the semantic
>>>> meaning of terms.
>>>
>>> Right
>>>
>>>>
>>>> ...14 Every epistemological antinomy can likewise be used for a
>>>> similar undecidability proof...(Gödel 1931:43)
>>>>
>>>
>>> WHich you just don't understand what they did.
>>>
>>>> When we understand that a True(L, x) predicate only applies to analytic
>>>> expressions then Tarski's proof utterly fails because
>>>> epistemological antinomies are rejected as not analytic.
>>>
>>> So, the fact that the EXISTANCE of a computabe True(L, x), allows the
>>> proving of that an epistemological antinomy must say that such a
>>> thing can not exist doesn't matter to you?
>>>
>>
>> A truth predicate only deals with analytic expressions, everything
>> else is out-of-scope. A truth predicate rejects expressions that
>> are not analytic.
>>
>
> A Truth Predicate needs to deal with ALL expressions in the Language.

IT MUST REJECT epistemological antinomies
IT MUST REJECT epistemological antinomies
IT MUST REJECT epistemological antinomies
IT MUST REJECT epistemological antinomies
IT MUST REJECT epistemological antinomies

> Just like a Halt Decider must handle all programs definable in the system.

This is not the same because D correctly simulated by H cannot possibly
reach the self-contradiction.

*Alternatively S1 is rejected by H1 similar to above*
Implementation of H1 requires it to determine whether
it is being invoked from within S1.
The Halting Paradox Bill Stoddart
https://arxiv.org/pdf/1906.05340.pdf

Not as robust as my alternative solution, yet still in the same vein.
With my alternative solution H1 would reject S1 as invalid input
and then H1 would halt.

>> You (ahead of most others) already know that the Liar Paradox is
>> not a truth bearer. This means that any correct and consistent
>> truth predicate must reject epistemological antinomies as out-of-scope.
>>
>>
>
> It can say they are not true, and neither is there complement.
>

AKA reject them as not truth bearers.

[Richard Damon]

It must say they are not true, (and not false).

>
>> Just like a Halt Decider must handle all programs definable in the
>> system.
> This is not the same because D correctly simulated by H cannot possibly
> reach the self-contradiction.

No, because the only H that "Correctly Simulates" its input is the one
that never aborts it.

ALL you

>
> *Alternatively S1 is rejected by H1 similar to above*
>   Implementation of H1 requires it to determine whether
>   it is being invoked from within S1.

Which violates the requirement that H1 is a computation, so NOT POSSIBLE.

> The Halting Paradox Bill Stoddart
> https://arxiv.org/pdf/1906.05340.pdf

Yep, he makes silly mistakes not understand what Computaiton theory is
about.

Just like you.

>
> Not as robust as my alternative solution, yet still in the same vein.
> With my alternative solution H1 would reject S1 as invalid input
> and then H1 would halt.
>

Except there is no "invalid program", unless you are admitting that your
decider isn't actually a Halt Decider.

>>> You (ahead of most others) already know that the Liar Paradox is
>>> not a truth bearer. This means that any correct and consistent
>>> truth predicate must reject epistemological antinomies as out-of-scope.
>>>
>>>
>>
>> It can say they are not true, and neither is there complement.
>>
>
> AKA reject them as not truth bearers.
>

But still give an answer.

if you define the Truth Predicate to accept all True Statements, then
the Truth Predicate will accept all True statements, and reject all
false statements, and non-truthbearers.

[olcott]

That would also work, yet we construe not true and not false
as not truth bearer thus out-of-scope of a truth predicate.

>>
>>> Just like a Halt Decider must handle all programs definable in the
>>> system.
>> This is not the same because D correctly simulated by H cannot possibly
>> reach the self-contradiction.
>
> No, because the only H that "Correctly Simulates" its input is the one
> that never aborts it.
>

You continue to fail to understand that correctly simulating N steps
<IS> a correct simulation of these N steps.

Also it only takes N steps to correctly determine that ∞ steps cannot
possibly terminate normally.

> ALL you
>
>>
>> *Alternatively S1 is rejected by H1 similar to above*
>>    Implementation of H1 requires it to determine whether
>>    it is being invoked from within S1.
>
> Which violates the requirement that H1 is a computation, so NOT POSSIBLE.

When S1 is not a computation then H1 is correct to reject S1.

>
>> The Halting Paradox Bill Stoddart
>> https://arxiv.org/pdf/1906.05340.pdf
>
> Yep, he makes silly mistakes not understand what Computaiton theory is
> about.
>
> Just like you.
>
>>
>> Not as robust as my alternative solution, yet still in the same vein.
>> With my alternative solution H1 would reject S1 as invalid input
>> and then H1 would halt.
>>
>
> Except there is no "invalid program", unless you are admitting that your
> decider isn't actually a Halt Decider.
>
>>>> You (ahead of most others) already know that the Liar Paradox is
>>>> not a truth bearer. This means that any correct and consistent
>>>> truth predicate must reject epistemological antinomies as out-of-scope.
>>>>
>>>>
>>>
>>> It can say they are not true, and neither is there complement.
>>>
>>
>> AKA reject them as not truth bearers.
>>
>
> But still give an answer.
>
> if you define the Truth Predicate to accept all True Statements, then
> the Truth Predicate will accept all True statements, and reject all
> false statements, and non-truthbearers.

[Richard Damon]

But they are answer of different predicates.

>
>>>
>>>> Just like a Halt Decider must handle all programs definable in the
>>>> system.
>>> This is not the same because D correctly simulated by H cannot possibly
>>> reach the self-contradiction.
>>
>> No, because the only H that "Correctly Simulates" its input is the one
>> that never aborts it.
>>
>
> You continue to fail to understand that correctly simulating N steps
> <IS> a correct simulation of these N steps.

But NOT a "Correct Simulation" that allows the use of a the simulation
to replace the behavior of the machine described.

Thus, since D(D) Halts, H is proven incorrect as a Halt Decider.

You are just admitting that you aren't working on Halting in Computation
Theory, but just on POOP in PO-whatever theory.

>
> Also it only takes N steps to correctly determine that ∞ steps cannot
> possibly terminate normally.

SOMETIMES.

Not here.

PROVEN

So, you are proven to be an idiot.

>
>> ALL you
>>
>>>
>>> *Alternatively S1 is rejected by H1 similar to above*
>>>    Implementation of H1 requires it to determine whether
>>>    it is being invoked from within S1.
>>
>> Which violates the requirement that H1 is a computation, so NOT POSSIBLE.
>
> When S1 is not a computation then H1 is correct to reject S1.

IF H1 isn't a computation, then it doesn't matter about S1, H1 just
isn't a computation, so can't be a decider.

You are again, just proving you are just talking about POOP.

And that you are nothing but an ignorant hypocritical pathological lying
idiot.

[olcott]

We only need to Truth predicate and this must reject
epistemological antinomies. Neither Tarski nor Gödel
understood this.

*That is the key essence of their huge mistake*
*That is the key essence of their huge mistake*
*That is the key essence of their huge mistake*

>>
>>>>
>>>>> Just like a Halt Decider must handle all programs definable in the
>>>>> system.
>>>> This is not the same because D correctly simulated by H cannot possibly
>>>> reach the self-contradiction.
>>>
>>> No, because the only H that "Correctly Simulates" its input is the
>>> one that never aborts it.
>>>
>>
>> You continue to fail to understand that correctly simulating N steps
>> <IS> a correct simulation of these N steps.
>
> But NOT a "Correct Simulation" that allows the use of a the simulation
> to replace the behavior of the machine described.
>

Both Hehner and Stoddart agree that:
D does specify non terminating behavior to H.

Stoddart refers to H1 and S1, and Hehner refers to this
same thing:

<Hehner>
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with that
same text as argument, then we have an infinite loop. A halting program
has some of the same character as an interpreter: it applies to texts
through abstract interpretation. Unsurprisingly, if we apply a halting
program to a program text that includes a call to that same halting
program with that same text as argument, then we have an infinite loop.
A mathematical version of it cannot escape the corresponding problem:
</Hehner>

Problems with the Halting Problem
https://www.cs.toronto.edu/~hehner/PHP.pdf

The Halting Paradox Bill Stoddart
https://arxiv.org/pdf/1906.05340.pdf

[Richard Damon]

But you don't understand what he is doing,

>>>
>>>>>
>>>>>> Just like a Halt Decider must handle all programs definable in the
>>>>>> system.
>>>>> This is not the same because D correctly simulated by H cannot
>>>>> possibly
>>>>> reach the self-contradiction.
>>>>
>>>> No, because the only H that "Correctly Simulates" its input is the
>>>> one that never aborts it.
>>>>
>>>
>>> You continue to fail to understand that correctly simulating N steps
>>> <IS> a correct simulation of these N steps.
>>
>> But NOT a "Correct Simulation" that allows the use of a the simulation
>> to replace the behavior of the machine described.
>>
>
> Both Hehner and Stoddart agree that:
> D does specify non terminating behavior to H.

Nope, because if H(D,D) returns 0, then the behavior of the input, TO
EVERYTHING, is halting.

The behavior of the COMPUTATION D(D) is always the same, and D is a
computation if H was. And if H wasn't, then it fails to meet the
requirements to be a Halt Decider.

>
> Stoddart refers to H1 and S1, and Hehner refers to this
> same thing:
>
> <Hehner>
> From a programmer's point of view, if we apply an interpreter to a
> program text that includes a call to that same interpreter with that
> same text as argument, then we have an infinite loop. A halting program
> has some of the same character as an interpreter: it applies to texts
> through abstract interpretation. Unsurprisingly, if we apply a halting
> program to a program text that includes a call to that same halting
> program with that same text as argument, then we have an infinite loop.
> A mathematical version of it cannot escape the corresponding problem:
> </Hehner>
>
> Problems with the Halting Problem
> https://www.cs.toronto.edu/~hehner/PHP.pdf
>
> The Halting Paradox Bill Stoddart
> https://arxiv.org/pdf/1906.05340.pdf
>
>

The fact that a particular implementation gets stuck in an infinite loop
doesn't make the problem incorrect, just the particular implementation
wrong.

Note, they seem to be making the same error you do, and confusing the
idea of a pure interpreter with a Halt Decider.

If the decider aborts, then when it is looking that the program and sees
a call to itself, it can't assume the call is to a pure interpreter,
since it isn't one.

So, either the decider doesn't abort, and then doesn't answer (and thus
is wrong) or it aborts its interprestation (and thus doesn't have actual
evidence of the final behavior of the program given to it) and what ever
it decides to answer, will be wrong when we look at the ACTUAL behavior
of the input.

[olcott]

*Maybe these are finally the right words*
D specifies that N to ∞ steps of D correctly simulated
by H cannot possibly reach the final state of D.

It *is* the case that a halt decider must compute
the mapping from the behavior that its finite string
specifies...

[olcott]

Tarski did not understand that non-truth bearers are
out-of-scope of any truth predicate.

*You understand these things better than he did*

[Fred. Zwarts]

Op 05.feb.2024 om 05:19 schreef olcott:

Lets call the H that aborts after N steps HaN.
For each of these we can create a DaN based on this HaN.

>
> It *is* the case that a halt decider must compute
> the mapping from the behavior that its finite string
> specifies...
>

HaN(DaN,DaN) must judge in input, which contains HaN, which aborts after
N steps and therefore DaN halts. It should not judge its non-input the
DaM, which aborts after M steps. (With M ≠ N.) There is no N for which
HaH gets a correct result for HaN(DaN,DaN).

[Fred. Zwarts]

In 1979 our lab got a PDP-11 computer. The engineer who installed the
system gave us a copy of the game Eliza, probably a descendant of the
famous Eliza. <https://en.wikipedia.org/wiki/ELIZA>
It was a simple chat program with a limited set of responses, but clever
enough to respond with sentences containing fragments from messages
typed in on the keyboard. For some people so realistic, that they only
wanted to chat with the program in private.
But after some time, it was easily seen that it was not a human being at
the other side. The many repetitions. The answers that sometimes did not
touch the point of the message. The sudden return to an much earlier
phase of the chat.
When I see the discussion with olcott, I get the same feelings. The
first impression is that there is a human being at the other side, but
here again, after some time I see the same symptoms: Many repetitions;
often the answer does not address the point of the message; suddenly the
discussion goes back to a point of which everybody thought it had been
passed definitively already.
So I come to the conclusion that someone is playing a game. He is using
an AI and tries to see how long he can get responses. His game evidently
has an AI somewhat better than that of Eliza. Once in a while it seems
to be updated with a few new responses. When it looks as if the
discussion is going to halt, it starts a new thread (sometimes in a new
newsgroup). Maybe every now and then the maker of the game adds a few
responses himself.
I will not be surprised when olcott sooner or later tells us that his
goal was not the discussion of the proofs of the theorems Gödel an
Tarski, but the proof that it is possible to fool people on Internet
with useless discussions for many years.

[Richard Damon]

So, you are just agreeing that your H is just a POOP decider, not a Halt
Decider.

If your criteria is not the actual Halting Question, your results aren't
a Halt Decider,

For a Halt Decider, it must compute the mapping from the finite input
string to the behavior that string specifies, and that string specifies
a Compuation, and the FULL sequnece of states that running it will
generate, and we ask if the sequence has an end.

It is NOT about can H simulate that input to the end, but does it have one.

And, for this case, the input is built on a copy of the EXACT
computation that is deciding on it.

You don't get to change the criteria to something that creates a
different map.

You clearly don't understand the nature of requirements, and thus the
meaning of "Correct" or "True"

[Richard Damon]

In other words, YOU don't understand what requirements mean.

[olcott]

D specifies that N to ∞ steps of D *correctly* simulated

by H cannot possibly reach the final state of D.

D specifies that N to ∞ steps of D *correctly* simulated

by H cannot possibly reach the final state of D.

D specifies that N to ∞ steps of D *correctly* simulated

by H cannot possibly reach the final state of D.

> It is NOT about can H simulate that input to the end, but does it have one.
>
> And, for this case, the input is built on a copy of the EXACT
> computation that is deciding on it.
>
> You don't get to change the criteria to something that creates a
> different map.
>

Innovation DOES CHANGE THINGS.
No one ever thought of a simulating halt decider before.
Everyone that thought of simulation rejected it as a basis.

> You clearly don't understand the nature of requirements, and thus the
> meaning of "Correct" or "True"

D specifies that N to ∞ steps of D *correctly* simulated

by H cannot possibly reach the final state of D.

[olcott]

When H correctly reports on the behavior of every H that can
possibly exist we need no other H.

>>
>> It *is* the case that a halt decider must compute
>> the mapping from the behavior that its finite string
>> specifies...
>>
>
> HaN(DaN,DaN) must judge in input, which contains HaN, which aborts after
> N steps and therefore DaN halts. It should not judge its non-input the
> DaM, which aborts after M steps. (With M ≠ N.) There is no N for which
> HaH gets a correct result for HaN(DaN,DaN).
>

D specifies that N to ∞ steps of D correctly simulated
by H cannot possibly reach the final state of D.

As soon as H correctly determines that the above is
true in N steps of correct simulation then H correctly
aborts its simulated and rejects D as non-halting.

[olcott]

When Tarski used an epistemological antinomy to test the validity
of his Truth predicate Tarski was dead wrong.

Epistemological antinomies are not truth-bearers thus out-of-scope
for any truth predicate. It is like trying to find the square root
of an actual orange peal, type mismatch error.

[olcott]

Since a Truth predicate is required to return True or False then
non-truth-bearers are out-of-scope because they are neither true or
false.

True(L, "what time is it?") is ERROR-INVALID-INPUT

[Fred. Zwarts]

Op 05.feb.2024 om 15:28 schreef olcott:

Each of the DaN specify that it reaches the final state, so, if H
aborts, there is no D that does not reach the final state.

> As soon as H correctly determines that the above is
> true in N steps of correct simulation then H correctly
> aborts its simulated and rejects D as non-halting.
>

None of the HaN correctly simulate DaN, because they all need to
simulate a few steps more than they do. A H that simulates N steps and
more than N steps at the same time does not exist. So, there is no H
that correctly determines that the above is true in N steps, because it
always needs more steps than N. If H simulates N steps, it needs a few
steps more to see that DaN returns. No correct HaN exists, not even in
the limit N → ∞.
Remember That HaN(DaN,DaN) must decide on its input DaN, not on its
non-input DaM, with M ≠ N.

[olcott]

Of the infinite set of every H1...Hn that correctly simulates
1 to ∞ steps of its corresponding D1...Dn none of these infinite
pairs ever reaches its own final state.

The specific H that correctly simulates N steps of D correctly
determines that above is true (for the entire infinite set)
thus providing it with the correct halt status criteria basis
to reject D as non-halting.

[Fred. Zwarts]

Op 05.feb.2024 om 16:15 schreef olcott:

That should be:
Of the infinite set of every H1...Hn that simulates 1 to n steps, none
simulates enough steps to see that D1 halts normally. So, they all abort
too soon and return falsely an non-halting state.

>
> The specific H that correctly simulates N steps of D correctly
> determines that above is true (for the entire infinite set)
> thus providing it with the correct halt status criteria basis
> to reject D as non-halting.
>

That should be:
The fact that a true simulator that simulates Dn with enough steps halts
normally, proves that this is true for the entire infinite set, thus
proving that none of these H1...Hn correctly report a non-halting state.

[Fred. Zwarts]

Op 05.feb.2024 om 16:43 schreef Fred. Zwarts:

D1 should be Dn.

[Andy Walker]

On 05/02/2024 10:16, Fred. Zwarts wrote:
> In 1979 our lab got a PDP-11 computer. The engineer who installed the
> system gave us a copy of the game Eliza, probably a descendant of the
> famous Eliza.

I don't know what your engineer did, but we got Unix for our
PDP-11 a year or two before that, and the mag tape for it included
"eliza" [free]. I no longer recall whether that tape came directly
from Bell or via [what was then] QMC.

[...]
> When I see the discussion with olcott, I get the same feelings. [...]
> So I come to the conclusion that someone is playing a game. [...]

> I will not be surprised when olcott sooner or later tells us that his
> goal was not the discussion of the proofs of the theorems Gödel an
> Tarski, but the proof that it is possible to fool people on Internet
> with useless discussions for many years.

Well, we already knew that result. Many years ago, there were
signs of progress, and several people [inc me] tried to help with what
seemed to be genuine stumbling blocks. I still pitch in very occasionally
when there seems to be a new point, but I refuse to get dragged into the
more rubbish parts of the "debate". Rule of thumb: if you add the more
prolific posters [that means anyone posting 10+ times/day] and posts of
over 100 lines to your KF, you won't miss anything of interest. Anyone
who is aggrieved by being ignored in this way knows what they have to do
to become worth reading.

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Dandrieu

[olcott]

According to your reasoning no one has any idea that
Infinite_Loop() is an infinite loop until they run
it and wait until the end of time to find out that
it never halts.

void Infinite_Loop()
{
HERE: goto HERE;
}

As an actual fact H does correctly match correct never-halting
criteria for ∞ steps of D correctly simulated by H.

>>
>> The specific H that correctly simulates N steps of D correctly
>> determines that above is true (for the entire infinite set)
>> thus providing it with the correct halt status criteria basis
>> to reject D as non-halting.
>>
>
> That should be:
> The fact that a true simulator that simulates Dn with enough steps halts
> normally, proves that this is true for the entire infinite set, thus
> proving that none of these H1...Hn correctly report a non-halting state.

[immibis]

On 5/02/24 19:21, olcott wrote:
> On 2/5/2024 9:43 AM, Fred. Zwarts wrote:
>> Op 05.feb.2024 om 16:15 schreef olcott:
>>> On 2/5/2024 8:58 AM, Fred. Zwarts wrote:
>>>>
>>>> None of the HaN correctly simulate DaN, because they all need to
>>>
>>> Of the infinite set of every H1...Hn that correctly simulates
>>> 1 to ∞ steps of its corresponding D1...Dn none of these infinite
>>> pairs ever reaches its own final state.
>>
>> That should be:
>> Of the infinite set of every H1...Hn that simulates 1 to n steps, none
>> simulates enough steps to see that D1 halts normally. So, they all
>> abort too soon and return falsely an non-halting state.
>>
>
> According to your reasoning no one has any idea that
> Infinite_Loop() is an infinite loop until they run
> it and wait until the end of time to find out that
> it never halts.
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }

It is impossible for a simulating termination analyser to analyse
termination by any method other than simulation. If a termination
analyser uses something other than simulation, it is not as simulating
termination analyser.

[immibis]

On 5/02/24 05:19, olcott wrote:
>
> *Maybe these are finally the right words*
> D specifies that N to ∞ steps of D correctly simulated
> by H cannot possibly reach the final state of D.

It is impossible to simulate ∞ steps.

[immibis]

On 4/02/24 16:53, olcott wrote:
> An analytic expression x is any expression of language verified as
> completely true (or false) entirely on the basis that x (or ~x) is
> derived by applying truth preserving operations to other expressions
> of language that are stipulated to be true thus providing the semantic
> meaning of terms.

So you are a constructivist - you believe that proof by contradiction is
not valid.

>
> ...14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof...(Gödel 1931:43)
>

> When we understand that a True(L, x) predicate only applies to analytic
> expressions

True(L,x) is STIPULATED to apply to every logical formula.

[immibis]

On 5/02/24 15:18, olcott wrote:

> D specifies that N to ∞ steps of D *correctly* simulated
> by H cannot possibly reach the final state of D.

This doesn't make sense. You can't simulate ∞ steps.

> Innovation DOES CHANGE THINGS.
> No one ever thought of a simulating halt decider before.

Simulation was literally everyone's first thought when they thought
about how to make a halt decider. They thought some more, and realized
that it doesn't work and can't work.

> Everyone that thought of simulation rejected it as a basis.

Because it doesn't work.

>
> D specifies that N to ∞ steps of D *correctly* simulated
> by H cannot possibly reach the final state of D.
>
This doesn't make sense. You can't simulate ∞ steps.

[Richard Damon]

Nope.

Since every H in that set simulated a DIFFERENT version of D, none of
the simuatation prove anything for any other simulation.

And, it can be shown that for EVERY element in that set, if that exact
same input is give to a decider that simulates enough more step, that
simulator will reach a final state, and thus that input, when actually
correctly simulated, will halt.

Your logic just confounds the different input, because you are working
on POOP, not halting.

Halting looks at specific inputs, and the behavior of the machine
specified by it, not "program templates" and sets of deciders.

[Richard Damon]

And when if incorrectly reports on the actual behavior of its input, it
is just wrong as a Halt decider.

You are just proving you have POOP on your brain.

>
>>>
>>> It *is* the case that a halt decider must compute
>>> the mapping from the behavior that its finite string
>>> specifies...
>>>
>>
>> HaN(DaN,DaN) must judge in input, which contains HaN, which aborts
>> after N steps and therefore DaN halts. It should not judge its
>> non-input the DaM, which aborts after M steps. (With M ≠ N.) There is
>> no N for which HaH gets a correct result for HaN(DaN,DaN).
>>
>
> D specifies that N to ∞ steps of D correctly simulated
> by H cannot possibly reach the final state of D.

But once you fix the H to a given number of steps, then

>
> As soon as H correctly determines that the above is
> true in N steps of correct simulation then H correctly
> aborts its simulated and rejects D as non-halting.
>
>

So H is just a correct POOP decider, but not a Halt Decider, since a
Halt Decider needs to answer about the behavior of the specific input
given to it, and for any H that aborts this input and returns
non-halting, that input, which was based on THAT specific H, will halt
when run, and no H in your set every correctly simulated that specific
input (as the only one that was given it, incorrectly gave up too soon).

[Richard Damon]

Nope, because for THAT input, there exists valid logic that can show
that it will never halt, even for a simulator (not the Halt Decider)
that simulates forever.

Your logic can only show that the D built on an H that aborts after N
steps, doesn't stop in its first N step, even though it does for some
specific number higher than N.

[Richard Damon]

So, you don't understand what a predicate is.

True(L, x) needs to accept inputs that are True, and reject input that
are not.

You seem to be thinking of Truth(L, x) which returns the truth value of
the expression x.

Of course, you only get the difference if the language L has a statement
x as a member of it that doesn't have a truth value. Most Languages
don't admit nonsense as part of the language.

Tarski just shows that via the rules of Meta-systems, the existance of
the computable predicate True(L, x) in the system L, (with sufficiently
strong logic) allows the creation via a Meta-System a statement in L
that shows that breaks the system.

of course, this is all above your head, by your own admission.

[Richard Damon]

That is the set { Dn } as each D built on a Difffert H is a different Input.

Each of those Dn, when correctly simulated for enough more steps, does Halt.

>
> D specifies that N to ∞ steps of D *correctly* simulated
> by H cannot possibly reach the final state of D.

Proving you are just a three year old in temperment

>
> D specifies that N to ∞ steps of D *correctly* simulated
> by H cannot possibly reach the final state of D.

Continuing that proof.

Repetition doesn't make it true. just shows you are desperate.

>
>> It is NOT about can H simulate that input to the end, but does it have
>> one.
>>
>> And, for this case, the input is built on a copy of the EXACT
>> computation that is deciding on it.
>>
>> You don't get to change the criteria to something that creates a
>> different map.
>>
>
> Innovation DOES CHANGE THINGS.
> No one ever thought of a simulating halt decider before.
> Everyone that thought of simulation rejected it as a basis.

In other words, you are admitting that you aren't actually working on
the Halting Problem, but just your POOP in PO-Computation Theory.

Maybe if you can show some VALUE in your POOP, you might convince people
it is useful. But since you don't actually build a POOP decider that can
decide on ALL inputs, just one particular one, it doesn't seem that
useful. (Yes, it can handle some others, but you admit it can't handle
all inputs).

>
>> You clearly don't understand the nature of requirements, and thus the
>> meaning of "Correct" or "True"
>
> D specifies that N to ∞ steps of D *correctly* simulated
> by H cannot possibly reach the final state of D.
>

Nope, That is a SET of D's each built on a different H and haveing
varying behavior

Dn built on an H that simulates for a finite number of steps, all will
halt when simulated for a larger number of steps.

Only the D built on an H that NEVER stops simulation wil be non-halting,
but the H it is built on never gives an answer.

Thus, NONE of your H's is a correct Halt Decider, and only that last
case does H actually do an actual correct simulation instead of just a
partial simulation (which by itself, proves nothing except a lower bound
on the number of steps the machine takes to halt).

[Richard Damon]

No, depending on your exact definitions, you can simulate an infinite
number of steps, just not in finite time, which means the simulator can
not be a decider.

A UTM given the description of a Non-Halting compuation will simulate it
for an infinite number of steps.

[Mike Terry]

On 05/02/2024 10:16, Fred. Zwarts wrote:

> In 1979 our lab got a PDP-11 computer. The engineer who installed the system gave us a copy of the
> game Eliza, probably a descendant of the famous Eliza. <https://en.wikipedia.org/wiki/ELIZA>
> It was a simple chat program with a limited set of responses, but clever enough to respond with
> sentences containing fragments from messages typed in on the keyboard. For some people so realistic,
> that they only wanted to chat with the program in private.
> But after some time, it was easily seen that it was not a human being at the other side. The many
> repetitions. The answers that sometimes did not touch the point of the message. The sudden return to
> an much earlier phase of the chat.
> When I see the discussion with olcott, I get the same feelings. The first impression is that there
> is a human being at the other side, but here again, after some time I see the same symptoms:

> Many
> repetitions;

PO can't handle abstract concepts or reasoning - he can't prove any points he tries to make, and
those points are arrived at simply as his early intuitions on first encountering a topic, i.e. they
are unfettered by subsequent learning or logical reasoning.

What /could/ such a person do, other than repeat his intuition over and over varying the words slightly.

> often the answer does not address the point of the message;

PO cannot grasp "the point of the message". Literally. He cannot properly handle the definitions
of terms used, or the logical reasoning employed, or understand /why/ a responder is following the
track they are following. He just sees disagreement with his claim, and perhaps a presentation of
some counter-claim [which to normal people might be read as a /proof/ or a /definition/ or a
/counter example/ etc.] I don't believe he sees any qualitative difference between his logical
repetitions of his own claims, and logical reasoning presented by others. He is completely blind to
the difference due to his different neural wiring.

Of course his responses couldn't address points he simply lacks the ability to understand.

> suddenly the discussion
> goes back to a point of which everybody thought it had been passed definitively already.

He does that, because he is just repeating what he thinks is correct claims (intuitions), and those
claims are still correct because nothing has changed (in his mind). Sometimes he changes the
wording, thinking if he does that enough, people will suddenly agree with him. That doesn't mean he
agrees his previously worded claims were incorrect!

If PO sees someone respond with a load of guff (in PO's opinion) which he doesn't really get, he
can't leave that unanswered, since that might suggest to other readers that he's lost some argument.
So he ignores the (in PO's opinion) extraneous complexity and goes back to just posting his core
intuition.

> So I come to the conclusion that someone is playing a game. He is using an AI and tries to see how
> long he can get responses. His game evidently has an AI somewhat better than that of Eliza. Once in
> a while it seems to be updated with a few new responses. When it looks as if the discussion is going
> to halt, it starts a new thread (sometimes in a new newsgroup). Maybe every now and then the maker
> of the game adds a few responses himself.

Well, your comparisson with Eliza is useful in /some/ ways! Eliza also lacked the ability to
process abstract concepts and definitions, and didn't genuinely understand what people were saying
to it, amd couldn't deduce what they were thinking etc.. PO's brain has some of Eliza's
limitations, so it's not too surprising his responses seem to follow Eliza's traits - but that
doesn't mean anyone is "playing a game". It's just the way PO's brain works...

As a humerous side-thought I did once suggest an alternative explanation:

msgid: <timdp5$i88$1...@gioia.aioe.org>
[comp.theory; Re: A thought; Tue, 18 Oct 2022 15:38:29 +0100]


Mike.

[olcott]

On 2/10/2024 7:42 PM, Mike Terry wrote:
> On 05/02/2024 10:16, Fred. Zwarts wrote:
>> In 1979 our lab got a PDP-11 computer. The engineer who installed the
>> system gave us a copy of the game Eliza, probably a descendant of the
>> famous Eliza. <https://en.wikipedia.org/wiki/ELIZA>
>> It was a simple chat program with a limited set of responses, but
>> clever enough to respond with sentences containing fragments from
>> messages typed in on the keyboard. For some people so realistic, that
>> they only wanted to chat with the program in private.
>> But after some time, it was easily seen that it was not a human being
>> at the other side. The many repetitions. The answers that sometimes
>> did not touch the point of the message. The sudden return to an much
>> earlier phase of the chat.
>> When I see the discussion with olcott, I get the same feelings. The
>> first impression is that there is a human being at the other side, but
>> here again, after some time I see the same symptoms:
>
>> Many repetitions;
>
> PO can't handle abstract concepts or reasoning - he can't prove any
> points he tries to make, and those points are arrived at simply as his
> early intuitions on first encountering a topic, i.e. they are unfettered
> by subsequent learning or logical reasoning.
>
> What /could/ such a person do, other than repeat his intuition over and
> over varying the words slightly.

*My 2004 intuitions have proved to be correct and*
*two PhD computer science professors elaborate them*
*better than I have until now*

*The Halting Paradox* Bill Stoddart (2017)
https://arxiv.org/abs/1906.05340

*Objective and Subjective Specifications* Eric C.R. Hehner (2017)
https://www.cs.toronto.edu/~hehner/OSS.pdf

*Problems with the Halting Problem* Eric C.R. Hehner (2011)
https://www.cs.toronto.edu/~hehner/PHP.pdf

Alan Turing's Halting Problem is incorrectly formed (PART-TWO) sci.logic
*On 6/20/2004 11:31 AM, Peter Olcott wrote*
> PREMISES:
> (1) The Halting Problem was specified in such a way that a solution
> was defined to be impossible.
>
> (2) The set of questions that are defined to not have any possible
> correct answer(s) forms a proper subset of all possible questions.
> …
> CONCLUSION:
> Therefore the Halting Problem is an ill-formed question.
>
USENET Message-ID:
<kZiBc.103407$Gx4....@bgtnsc04-news.ops.worldnet.att.net>

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Ĥ applied to ⟨Ĥ⟩ asks: (Olcott 2024)
Do you halt on your own Turing Machine Description?

This is isomorphic to asking whether the Liar Paradox is true or false.

[immibis]

On 11/02/24 03:14, olcott wrote:
> On 2/10/2024 7:42 PM, Mike Terry wrote:
>> On 05/02/2024 10:16, Fred. Zwarts wrote:
>>> In 1979 our lab got a PDP-11 computer. The engineer who installed the
>>> system gave us a copy of the game Eliza, probably a descendant of the
>>> famous Eliza. <https://en.wikipedia.org/wiki/ELIZA>
>>> It was a simple chat program with a limited set of responses, but
>>> clever enough to respond with sentences containing fragments from
>>> messages typed in on the keyboard. For some people so realistic, that
>>> they only wanted to chat with the program in private.
>>> But after some time, it was easily seen that it was not a human being
>>> at the other side. The many repetitions. The answers that sometimes
>>> did not touch the point of the message. The sudden return to an much
>>> earlier phase of the chat.
>>> When I see the discussion with olcott, I get the same feelings. The
>>> first impression is that there is a human being at the other side,
>>> but here again, after some time I see the same symptoms:
>>
>>> Many repetitions;
>>
>> PO can't handle abstract concepts or reasoning - he can't prove any
>> points he tries to make, and those points are arrived at simply as his
>> early intuitions on first encountering a topic, i.e. they are
>> unfettered by subsequent learning or logical reasoning.
>>
>> What /could/ such a person do, other than repeat his intuition over
>> and over varying the words slightly.
>

> [more exact repetition of the stuff you posted before]

Thank you for proving that Mike is correct.

[immibis]

On 11/02/24 02:42, Mike Terry wrote:
> Sometimes he changes the wording, thinking
> if he does that enough, people will suddenly agree with him.  That
> doesn't mean he agrees his previously worded claims were incorrect!
>
> If PO sees someone respond with a load of guff (in PO's opinion) which
> he doesn't really get, he can't leave that unanswered, since that might
> suggest to other readers that he's lost some argument.  So he ignores
> the (in PO's opinion) extraneous complexity and goes back to just
> posting his core intuition.

I thought tangent of "D(D) doesn't halt even though it seems to halt"
was quite amusing. When people were pointing out that D(D) does halt
(evidence: just run it and see) Olcott responded that it does not halt.

Message-ID: <uorkac$1tiu7$1...@dont-email.me>

"You see, D(D) halts, but it only halts because it thinks it does not
halt, and if a computation only halts because it thinks it does not
halt, then it DOES NOT COUNT AS HALTING and therefore it was correct!"

Or something like that.

> As a humerous side-thought I did once suggest an alternative explanation:
>
>   msgid: <timdp5$i88$1...@gioia.aioe.org>
>   [comp.theory;  Re: A thought;  Tue, 18 Oct 2022 15:38:29 +0100]
>

I don't think I have any simple way to find this message, because
Thunderbird sucks.

[Mike Terry]

On 11/02/2024 03:14, immibis wrote:
> On 11/02/24 02:42, Mike Terry wrote:
>> Sometimes he changes the wording, thinking if he does that enough, people will suddenly agree with
>> him.  That doesn't mean he agrees his previously worded claims were incorrect!
>>
>> If PO sees someone respond with a load of guff (in PO's opinion) which he doesn't really get, he
>> can't leave that unanswered, since that might suggest to other readers that he's lost some
>> argument.  So he ignores the (in PO's opinion) extraneous complexity and goes back to just posting
>> his core intuition.
>
> I thought tangent of "D(D) doesn't halt even though it seems to halt" was quite amusing. When people
> were pointing out that D(D) does halt (evidence: just run it and see) Olcott responded that it does
> not halt.
>
> Message-ID: <uorkac$1tiu7$1...@dont-email.me>
>
> "You see, D(D) halts, but it only halts because it thinks it does not halt, and if a computation
> only halts because it thinks it does not halt, then it DOES NOT COUNT AS HALTING and therefore it
> was correct!"
>
> Or something like that.

Yes it's bizarre. A reader simply wishing to see that PO's claim is worthless need look no further.
It's only someone who wants to understand /where/ PO is going wrong, or to /correct his thinking/
that will be motivated to dive into all the mucky details...

>
>> As a humerous side-thought I did once suggest an alternative explanation:
>>
>>    msgid: <timdp5$i88$1...@gioia.aioe.org>
>>    [comp.theory;  Re: A thought;  Tue, 18 Oct 2022 15:38:29 +0100]
>>
>
> I don't think I have any simple way to find this message, because Thunderbird sucks.

Yeah, I use SeaMonkey which is Thunderbird based I believe, and I don't see a "retrieve by msgid"
option anywhere. I can sort messages by date and turn of the threading tree, and locate the post by
date, so you could maybe do that but that's no good if your server retention doesn't go back far
enough. Even a simpler "retrieve parent article" button would be very useful and cover the majority
of actual use cases where I want to retrieve by msgid...

(Also some time ago I wrote my own console mode program that takes a server and msgid and dumps the
article to the console... That's how I personally do it.)

Anyhow: ============================================================================

On 18/10/2022 15:38, Mike Terry wrote:
> On 18/10/2022 09:21, Fred. Zwarts wrote:
>> Op 18.okt..2022 om 05:04 schreef Richard Damon:
>>> On 10/17/22 10:15 PM, Ben Bacarisse wrote:
>>>> How many of the regular posters here would be prepared to commit to not
>>>> replying to any more of PO's nonsense? The trouble is that every reply
>>>> just adds more fuel to the dumpster fire we (and others now departed)
>>>> have been warming ourselves round for the last 18 or so years.
>>>>
>>>> Keeping quiet won't be easy because to get the fix he needs he'll insult
>>>> you, lie about you and misrepresent what you've said. You'll have to
>>>> sit on your hands while he calls you ignorant or says you are
>>>> incompetent or, even worse, that you agree with him!
>>>>
>>>> He won't stop posting of course (and I have no desire to curtail
>>>> anyone's speech), but un-replied-to posts and short threads won't get
>>>> the search weight that long ones get. Do a few Google or DuckDuckGo
>>>> searches for key names and terms in this area. Do you like what you
>>>> see? If not, consider just saying nothing!
>>>>
>>>> Naturally, he will spray other Usenet groups with his posts to rope in
>>>> new blood (and he /will/ succeed in doing so), but if there are a
>>>> reasonable number of us, some of these new victims might be more easily
>>>> persuaded to join us.
>>>>
>>>> Just to be clear, I'm not averse to people taking /about/ PO -- cranks
>>>> and crank ideas can be interesting -- but since we are sane (you know
>>>> who "we" are!), threads and sub-threads amongst ourselves will either
>>>> reach a conclusion or will simply peter out (no pun intended).
>>>>
>>>> There are other options such as agreeing a short, simple reply to be
>>>> posted, anonymously, only once in each thread. In that case my
>>>> preference would be a for this to be a couple of quotes using PO's own
>>>> words, but this should only be considered if there is insufficient
>>>> support for "just say nothing".
>>>>
>>>> So, anyone up for it?
>>>>
>>>
>>> My one concern is someone coming across his rantings and beleiving him.
>>>
>>> I suppose there is enough evidence that any sort of check will show the truth.
>>>
>>> I really do wonder if he does have an actual medical condition (other than his cancer he
>>> sometimes talks about) that impairs his brain function. It sounds like it goes back too far to be
>>> just a side effect of Chemo.
>>
>> Did you consider the possibility that he is not a real person, but an AI program? Same repetition
>> of words and sentences.
>
> I had an ironic thought a few months ago - PO has always claimed he wants to be the first to create
> a human mind in a computer [...as though he has the slightest clue what that would really
> involve...]. Well, it occured to me - what if many years ago, the real PO who actually /was/ an
> unacknowledged genius (kind-of) succeeded, but then died. His test subject had been his own mind,
> but he hadn't really got the whole process properly sorted, so the result was the PO we see today?
> Think I've been watching too many Rick and Morty episodes! :)
>
> Mike.

[olcott]

On 2/11/2024 9:17 AM, Mike Terry wrote:
> On 11/02/2024 03:14, immibis wrote:
>> On 11/02/24 02:42, Mike Terry wrote:
>>> Sometimes he changes the wording, thinking if he does that enough,
>>> people will suddenly agree with him.  That doesn't mean he agrees his
>>> previously worded claims were incorrect!
>>>
>>> If PO sees someone respond with a load of guff (in PO's opinion)
>>> which he doesn't really get, he can't leave that unanswered, since
>>> that might suggest to other readers that he's lost some argument.  So
>>> he ignores the (in PO's opinion) extraneous complexity and goes back
>>> to just posting his core intuition.
>>
>> I thought tangent of "D(D) doesn't halt even though it seems to halt"
>> was quite amusing. When people were pointing out that D(D) does halt
>> (evidence: just run it and see) Olcott responded that it does not halt.
>>
>> Message-ID: <uorkac$1tiu7$1...@dont-email.me>
>>
>> "You see, D(D) halts, but it only halts because it thinks it does not
>> halt, and if a computation only halts because it thinks it does not
>> halt, then it DOES NOT COUNT AS HALTING and therefore it was correct!"
>>
>> Or something like that.
>
> Yes it's bizarre.  A reader simply wishing to see that PO's claim is
> worthless need look no further.  It's only someone who wants to
> understand /where/ PO is going wrong, or to /correct his thinking/ that
> will be motivated to dive into all the mucky details...

[olcott]

On 2/10/2024 7:42 PM, Mike Terry wrote:

[olcott]

On 2/4/2024 9:53 AM, olcott wrote:
> An analytic expression x is any expression of language verified as
> completely true (or false) entirely on the basis that x (or ~x) is
> derived by applying truth preserving operations to other expressions
> of language that are stipulated to be true thus providing the semantic
> meaning of terms.
>

> ...14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof...(Gödel 1931:43)
>

> When we understand that a True(L, x) predicate only applies to analytic
> expressions then Tarski's proof utterly fails because epistemological
> antinomies are rejected as not analytic.
>

> It would then be possible to reconstruct the antinomy of the liar
> in the metalanguage, by forming in the language itself a sentence
> x such that the sentence of the metalanguage which is correlated
> with x asserts that x is not a true sentence.
> https://liarparadox.org/Tarski_247_248.pdf
> https://liarparadox.org/Tarski_275_276.pdf
>
>
> The proof of Tarski's undefinability theorem in this form is again
> by reductio ad absurdum. Suppose that an L-formula True(n)
>
> as above existed, i.e., if A is a sentence of arithmetic, then
> True(g(A)) holds in N if and only if A holds in N. Hence for all
>
> A, the formula True(g(A)) ⟺ A holds in N. But the diagonal
> lemma yields a counterexample to this equivalence, by
>
> giving a "liar" formula S such that S ⟺ ¬True(g(A)) holds
> in N. This is a contradiction QED.
> https://en.wikipedia.org/wiki/Tarski%27s_undefinability_theorem
>
>

In other words Tarski was simply too stupid to understand
that a correct and consistent truth predicate has a domain
of expressions of language that are truth bearers thus
non-truth-bearers such as the Liar Paradox must be rejected.

[immibis]

On 11/02/24 16:36, olcott wrote:
> On 2/11/2024 9:17 AM, Mike Terry wrote:
>> On 11/02/2024 03:14, immibis wrote:
>>> On 11/02/24 02:42, Mike Terry wrote:
>>>> Sometimes he changes the wording, thinking if he does that enough,
>>>> people will suddenly agree with him.  That doesn't mean he agrees
>>>> his previously worded claims were incorrect!
>>>>
>>>> If PO sees someone respond with a load of guff (in PO's opinion)
>>>> which he doesn't really get, he can't leave that unanswered, since
>>>> that might suggest to other readers that he's lost some argument.
>>>>  So he ignores the (in PO's opinion) extraneous complexity and goes
>>>> back to just posting his core intuition.
>>>
>>> I thought tangent of "D(D) doesn't halt even though it seems to halt"
>>> was quite amusing. When people were pointing out that D(D) does halt
>>> (evidence: just run it and see) Olcott responded that it does not halt.
>>>
>>> Message-ID: <uorkac$1tiu7$1...@dont-email.me>
>>>
>>> "You see, D(D) halts, but it only halts because it thinks it does not
>>> halt, and if a computation only halts because it thinks it does not
>>> halt, then it DOES NOT COUNT AS HALTING and therefore it was correct!"
>>>
>>> Or something like that.
>>
>> Yes it's bizarre.  A reader simply wishing to see that PO's claim is
>> worthless need look no further.  It's only someone who wants to
>> understand /where/ PO is going wrong, or to /correct his thinking/
>> that will be motivated to dive into all the mucky details...
>

> [a copy-paste of the same thing that is already proven to be stupid]

Thanks again for proving that Mike is correct.

[immibis]

On 11/02/24 18:00, olcott wrote:
> On 2/10/2024 7:42 PM, Mike Terry wrote:
>>
>> He does that, because he is just repeating what he thinks is correct
>> claims (intuitions), and those claims are still correct because
>> nothing has changed (in his mind).  Sometimes he changes the wording,
>> thinking if he does that enough, people will suddenly agree with him.
>> That doesn't mean he agrees his previously worded claims were incorrect!
>

> [a copy-paste of the same thing that was already proven to be stupid, with slight changes in wording]

Thank you for proving that Mike is correct.

[Richard Damon]

Nope, you are too stupid to understand what Tarski is talking about.

Since you think "English" could be a formal logic system, this is a
proven statement.

[Richard Damon]

Nope.

Proven otherwise

Your statement are still just lies.

[olcott]

That is libelous.

*to say something that is not true in order to deceive*
https://dictionary.cambridge.org/us/dictionary/english/lie

That you call my statement an intentional falsehood
shows a reckless disregard for the truth

*When you cannot even show that it is a falsehood*

That you cannot even show exactly how template Ĥ does not
contradict both Boolean values that embedded_H returns proves
that you cannot even show that my statement is false.

[Richard Damon]

No, it is a TRUE statement.

>
> *to say something that is not true in order to deceive*
> https://dictionary.cambridge.org/us/dictionary/english/lie

Which perfectly describes yourself.

>
> That you call my statement an intentional falsehood
> shows a reckless disregard for the truth

Nope, it is a statement of TRUTH.

>
> *When you cannot even show that it is a falsehood*
>
> That you cannot even show exactly how template Ĥ does not
> contradict both Boolean values that embedded_H returns proves
> that you cannot even show that my statement is false.
>
>

The falsehood is that you claim to be working on the Halting Problem,
but you are not, since you don't use any of the actual requirements of
the halting problem.

Your H is not A COMPUTATION.

your input D is not A REPRESENTATION OF A COMPUTATION.

Thus, your claims are all LIES.

[olcott]

You can't even stay on topic. I never mention H in this
whole thread. That you are responding to things that I
didn't even say is a reckless disregard for the truth.

[Richard Damon]

Really?

Lying again.

Look up at the quotes:

>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The fact that you don't even check what you are talking about shows your
stupidity.

YOU deflected this sub thread from its topic of Tarski to Halting in
your reply to Mike yesterday.

So, you are just proving that you are just a pathological liar.


Apology expected.

[olcott]

That IS NOT H IT IS CALLED H-HAT PAY ATTENTION
That IS NOT H IT IS CALLED H-HAT PAY ATTENTION
That IS NOT H IT IS CALLED H-HAT PAY ATTENTION
That IS NOT H IT IS CALLED H-HAT PAY ATTENTION

The Linz H is an entirely different template
The Linz H is an entirely different template
The Linz H is an entirely different template
The Linz H is an entirely different template

> YOU deflected this sub thread from its topic of Tarski to Halting in
> your reply to Mike yesterday.
>
> So, you are just proving that you are just a pathological liar.
>
>
> Apology expected.

[Richard Damon]

But Ĥ uses its copy of H that you call embedded_H.

So, H is there.

I guess you are just admitting you have just been lying for the past two
decades.

>
> The Linz H is an entirely different template
> The Linz H is an entirely different template
> The Linz H is an entirely different template
> The Linz H is an entirely different template
>

So, you admit that you are lying about trying to refute Linz?

I guess that puts two decades of work down the drain.

Why try to pull out of Linz's proof, if you admit your Ĥ isn't his?

>> YOU deflected this sub thread from its topic of Tarski to Halting in
>> your reply to Mike yesterday.
>>
>> So, you are just proving that you are just a pathological liar.
>>
>>
>> Apology expected.
>

So, you doubled down on your lies.

PROOF that you are just the ignorant hypocritical pthological lying
idiot that you have been exposed to be.

[olcott]

No H is not there you should see the screwing thing
that Linz calls embedded_H: Ĥq0 (a second start state)

Top of page 3
https://www.liarparadox.org/Linz_Proof.pdf

[Richard Damon]

So, you don't understand that H' is just the machine H with the added
infinite loop to the state H.qy?

He adds two new states to H, H.qa and H.qb, makes H.qy unconditionally
transfer to H.qa (instead of being a Final State), and H.qa
unconditionally transfera to H.qb, and H.qb unconditionally transfers to
H.qa.

What makes that a "screwing thing"?

Is your understanding of Turing Machines THAT defective?

So totally with in the code of Ĥ, and H' is the code for H. The ONLY
thing possibly missing is that H.qy is no longer marked as "Final", and
that is a common practice in reusing Turing Machines.

Do you still claim that your Ĥ doesn't contain a copy of the code for H
in it?

[olcott]

I understand that when Linz is all done with all of the
transformations and actually specifies the completed Ĥ
that he calls embedded_H *Ĥq0* on the top of page 3.

[Richard Damon]

Nope, you THINK you understand that, but you don't actually understand
what he is doing.

He has no "embedded_H", and that Ĥq0 is the name of of the state in Ĥ
that is the beginning state for H, not ALL the states of H. that ⊢*
after it represents all the states that H goes through (including the
equivalent states in Ĥ)

I not also, you have again ducked that hard questions, likely because
you don't have an answer and are trying to execute some red herring.

I guess since you didn't explain how that isn't H in Ĥ, you are just
admitting that it was, and you stupidly got caught in another lie.

You can't seem to avoid them.

[olcott]

Figure 12.2 shows that he merely appends the infinite loop to qy
thus calling his Ĥq0 (second start state) embedded_H is perfectly
accurate.

[immibis]

How can a state be the same as a program?

[Richard Damon]

No, because H was the states q0, qy, and qn and all the "omited" details
represented by the squiggly lines. The whole of Figure 12.1

Figure 12.2 shows the changes going from H to H' (the adding of the
infinite loop to qy)

Calling ONE state of a full machine as "The Machine" is just an error.

You are just showing your total ignorance.

[olcott]

embedded_H refers to all of the states specified in his H template.
two of these states have merely been renamed indicating that they
have been integrated into Ĥ because H has been embedded in Ĥ.

His two start states are wrong as Ben agreed to years ago.
No TM ever has two q0 states.

My name embedded_H is much easier to understand than his
second q0 state.

[Richard Damon]

Then why did you say it was just Ĥq0 that represented embedded_H?

>
> His two start states are wrong as Ben agreed to years ago.
> No TM ever has two q0 states.

No, there is q0 and Ĥq0

Admittedly, his nomenclature is a bit awkward.

The execution of the Machine Ĥ starts at the state q0 (as he defines q0
to be the starting state of all machines) with the expresion

q0 Wm

Which means at state q0, with a tape contents of Wm

It then goes through the steps to duplicate the tape and ends up at
state Ĥq0 which is the Ĥ machine equivalent of H's q0, at an expression

Ĥq0 Wm Wm

Meaning at state Ĥq0 with tape contents Wm Wm

and then (depending on the decision that H makes) to either

Ĥ∞

indicating that Ĥ doesn't halt or

Ĥ y0 qn y1

indicating it goes to state Ĥqn with the tape possible having symbols y0
before the head, and y1 after the head.

[olcott]

https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

*No you have that incorrectly*
q0 ⟨M⟩ ⊢* Ĥq0 ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qy ∞ // YES for M applied to ⟨M⟩ halts
q0 ⟨M⟩ ⊢* Ĥq0 ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qn // NO for M applied to ⟨M⟩ does not halt

> Ĥ y0 qn y1
>
> indicating it goes to state Ĥqn with the tape possible having symbols y0
> before the head, and y1 after the head.
>
>>
>> My name embedded_H is much easier to understand than his
>> second q0 state.
>>
>
>

[olcott]

All of the above is correct.

*This improves on his notation making is more clear*

q0 ⟨M⟩ ⊢* Ĥq0 ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qy ∞ // YES for M applied to ⟨M⟩ halts
q0 ⟨M⟩ ⊢* Ĥq0 ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qn // NO for M applied to ⟨M⟩ does not halt

> indicating that Ĥ doesn't halt or
>
> Ĥ y0 qn y1
>
> indicating it goes to state Ĥqn with the tape possible having symbols y0
> before the head, and y1 after the head.
>
>>
>> My name embedded_H is much easier to understand than his
>> second q0 state.
>>
>
>

[Richard Damon]

Which is for H saying that M applied to (M) Halts, which if M is Ĥ it
doesn't

> q0 ⟨M⟩ ⊢* Ĥq0  ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qn    // NO for M applied to ⟨M⟩ does not halt

Which is for H sayng that M applied to (M) Halts, which if M is Ĥ it
does Halt.

So, which every H you happen to try to use, it is wrong (and the two H's
got DIFFERENT input, so that doesn't say that either question didn't
have a correct answer, just not one that H gave.

So, this proves that NO H will correctly answer the halting question for
the input representing the specific computation built from the template
applied to that particular H.