DDD correctly emulated by HHH is correctly rejected as non-halting.

Discussion:

(too old to reply)

olcott

2024-07-10 15:03:46 UTC

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
HHH(DDD);
}

int main()
{
HHH(DDD);
}

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated by
each pure function x86 emulator HHH (of the infinite set
of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

*This algorithm is used by the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Simulating termination analyzer HHH aborts its emulation of DDD
as soon as it correctly detects any non-halting behavior pattern.
At this point it aborts its emulation and returns 0 indicating
that it rejected this input as non-halting.

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

olcott

2024-07-10 15:19:38 UTC

Permalink

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(DDD);
}
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated by
each pure function x86 emulator HHH (of the infinite set
of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
*This algorithm is used by the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then
    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Simulating termination analyzer HHH aborts its emulation of DDD
as soon as it correctly detects any non-halting behavior pattern.
At this point it aborts its emulation and returns 0 indicating
that it rejected this input as non-halting.

This is the 63rd rewrite of this 13th revision of the paper.
Simulating Termination Analyzer H is Not Fooled by Pathological Input D

https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

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

Fred. Zwarts

2024-07-10 17:45:43 UTC

Permalink

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(DDD);
}

Unneeded complexity. It is equivalent to:

int main()
{
return HHH(main);
}

Post by olcott
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated by
each pure function x86 emulator HHH (of the infinite set
of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
*This algorithm is used by the simulating termination analyzers*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then
    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

But these words do not apply for the above example, because these words
apply to a correct simulation, not to HHH, which performs an incorrect
simulation.

Post by olcott
Simulating termination analyzer HHH aborts its emulation of DDD
as soon as it correctly detects any non-halting behavior pattern.
At this point it aborts its emulation and returns 0 indicating
that it rejected this input as non-halting.

It cannot detect a non-halting pattern in a program that is programmed
to halt after a few cycles of recursive simulation.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

So, not only is the simulation incorrect, also the detection of a
non-halting pattern failed.
So, the only report that it can make is that its own simulation failed.

olcott

2024-07-10 17:53:38 UTC

Permalink

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(DDD);
}

       int main()
       {
         return HHH(main);
       }

Every time any HHH correctly emulates DDD it calls the
x86utm operating system to create a separate process
context with its own memory virtual registers and stack,
thus each recursively emulated DDD is a different instance.

The instance of main() can't possibly halt HHH correctly
aborts and rejects as non-halting. The entirely different
instance of main() that calls HHH only halts because HHH
was correct to abort its simulated instance.

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

Fred. Zwarts

2024-07-10 18:30:44 UTC

Permalink

Post by olcott

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(DDD);
}

        int main()
        {
          return HHH(main);
        }

Irrelevant information.

Post by olcott
The instance of main() can't possibly halt HHH correctly
aborts and rejects as non-halting. The entirely different
instance of main() that calls HHH only halts because HHH
was correct to abort its simulated instance.

HHH cannot possibly simulate itself correctly. So, it aborts the
simulation one cycle too soon. So, it aborts incorrectly.
Aborting a halting program halfway its simulation is incorrect.
Therefore, its report is not about halting, but about correct simulation.
HHH reports that its simulation failed.
When HHH aborts, it can only report that its simulation failed. It
cannot report about halting behaviour, because that behaviour is present
in the part of the program that was skipped by the abort.

Richard Damon

2024-07-11 00:01:41 UTC

Permalink

Post by olcott

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
HHH(DDD);
}
int main()
{
HHH(DDD);
}

        int main()
        {
          return HHH(main);
        }

Every time any HHH correctly emulates DDD it calls the
x86utm operating system to create a separate process
context with its own memory virtual registers and stack,
thus each recursively emulated DDD is a different instance.
The instance of main() can't possibly halt HHH correctly
aborts and rejects as non-halting. The entirely different
instance of main() that calls HHH only halts because HHH
was correct to abort its simulated instance.

But ALL instances of the smsame program must behavir the same, or you
are proving that your HHH isn't actualy a pure function, or doesn't
correct emulate its input.

So, it CAN'T say that its emulated version is correct determined to not
return without admiting that something about it make it different when
emulated which means either it fails to be pure, or fails to correctly
emulate itself.

So, you just blew up your argument in a great big LIE.

Alan Mackenzie

2024-07-10 18:12:08 UTC

Permalink

[ Followup-To: set ]

In comp.theory Fred. Zwarts <***@hetnet.nl> wrote:

[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?

[ .... ]

--
Alan Mackenzie (Nuremberg, Germany).

olcott

2024-07-10 18:32:32 UTC

Permalink

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

Welcome back.
I stipulate that I am referring to 1 to ∞ steps of correct
emulation according to the semantics of the x86 language.

This means that when HHH does correctly emulate 1 step
that *it is a correct emulation* of this 1 step, thus
making everyone that disagrees disagree with a tautology
making them look foolish.

We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

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

Fred. Zwarts

2024-07-11 07:32:22 UTC

Permalink

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

And nobody disagrees with that. So, *you* look foolish. The disagreement
is that you think that simulating only 1 step for a program that needs N
steps is correct, whereas we know that a correct simulation needs N
steps. It is a finite recursion as in:

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It seems that you do not understand the semantics of the x86 language,
which requires the simulation of all N steps.

Post by olcott
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language.

So, use it. Simulate all N steps.
We know that an aborting program does halt, so the number of steps to
simulate is finite.
Your problem is that HHH cannot possibly simulate itself correctly up to
the end. You need another simulator for that.

Post by olcott
By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

Yes. This proves that HHH cannot possibly simulate itself correctly up
to the end.

olcott

2024-07-10 18:54:05 UTC

Permalink

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

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

Fred. Zwarts

2024-07-11 07:43:48 UTC

Permalink

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

But not a correct simulation of a program. The x86 language specifies
that it is insufficient to interpret only one instruction of a program.
For a correct simulation of a halting program, all instructions must be
simulated.
Maybe you don't know the x86 language well enough to understand that the
behaviour of a program is not defined by the first few instructions.

Post by olcott
thus
making everyone that disagrees disagree with a tautology
making them look foolish.
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

Which proves that the simulation is incomplete and, therefore, incorrect.
You proved again that HHH cannot possibly simulate itself correctly.
Even when you wish it very very much that it is correct and even if you
repeat it a thousand times more, that will not make it correct.
A correct simulation by another simulator shows that the correct
simulation is possible, but not by HHH itself.

olcott

2024-07-10 20:49:21 UTC

Permalink

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

A non-halting program cannot be simulated correctly in a finite time.
So, it depends whether we can call it a correct simulation, when it does
not abort. But, for some meaning of 'correct', indeed, a simulator
should not abort a non-halting program either.

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

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

olcott

2024-07-10 20:53:02 UTC

Permalink

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

In other words he is using deceitful weasel wording to
try to escape a truism.

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language. By this measure when 1 to ∞
steps of DDD are correctly emulated by each pure function x86 emulator
HHH (of the infinite set of every HHH that can possibly exist) then DDD
cannot possibly reach past its own machine address of 0000216b and halt.

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

Post by olcott
But H determines (correctly) that D would not halt
if it were not halted. That much is a truism.

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

Fred. Zwarts

2024-07-11 07:25:49 UTC

Permalink

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

In other words he is using deceitful weasel wording to
try to escape a truism.

Why are you twisting my words? Is English such a difficult language for you?

Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language. By this measure when 1 to ∞
steps of DDD are correctly emulated by each pure function x86 emulator
HHH (of the infinite set of every HHH that can possibly exist) then DDD
cannot possibly reach past its own machine address of 0000216b and halt.

And since HHH is a program that halts, this proves that the simulation
was aborted halfway, which makes it incorrect.
Showing that the set of HHH that can correctly simulate itself is empty.
When a correct simulation needs N steps and you abort it halfway after M
steps, with M much smaller than N, then the simulation of N steps is
correct, but the simulation as a whole is incorrect, because the
semantics of the x86 languages specifies that N steps must me simulated.

Post by olcott
But H determines (correctly) that D would not halt
if it were not halted. That much is a truism.

olcott

2024-07-11 13:05:44 UTC

Permalink

Post by Fred. Zwarts

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

In other words he is using deceitful weasel wording to
try to escape a truism.

Why are you twisting my words? Is English such a difficult language for you?

Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language. By this measure when 1 to ∞
steps of DDD are correctly emulated by each pure function x86 emulator
HHH (of the infinite set of every HHH that can possibly exist) then
DDD cannot possibly reach past its own machine address of 0000216b and
halt.

And since HHH is a program that halts, this

DDD emulated by pure function x86 emulator HHH can't
possibly ever reach is own emulated machine address at
00002174 according to the correct semantics of the x86
language.

Post by Fred. Zwarts
proves that the simulation
was aborted halfway, which makes it incorrect.
Showing that the set of HHH that can correctly simulate itself is empty.
When a correct simulation needs N steps and you abort it halfway after M
steps, with M much smaller than N, then the simulation of N steps is
correct, but the simulation as a whole is incorrect, because the
semantics of the x86 languages specifies that N steps must me simulated.

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

2024-07-12 02:08:20 UTC

Permalink

Post by olcott

Post by Fred. Zwarts

Post by olcott

Post by Alan Mackenzie
[ Followup-To: set ]
[ .... ]

Post by Fred. Zwarts
Proving that the simulation is incorrect. Because a correct simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting
program either, would it? Or have I misunderstood this correctness?
[ .... ]

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

In other words he is using deceitful weasel wording to
try to escape a truism.

Why are you twisting my words? Is English such a difficult language for you?

Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language. By this measure when 1 to
∞ steps of DDD are correctly emulated by each pure function x86
emulator HHH (of the infinite set of every HHH that can possibly
exist) then DDD cannot possibly reach past its own machine address of
0000216b and halt.

And since HHH is a program that halts, this

DDD emulated by pure function x86 emulator HHH can't
possibly ever reach is own emulated machine address at
00002174 according to the correct semantics of the x86
language.

You are again LYIHG by using imprecise language.

The emulation of DDD by HHH doesn't reach that point.

The behavior of DDD, (which happens to be the DDD that HHH emulates)
does reach that point, just after HHH stops its emulation.

You confuse the Observation by HHH for the reality of the behavior of
the program, because you don't understand what Truth actually is, so you
can't actually understand logic.

Post by olcott

Post by Fred. Zwarts
proves that the simulation was aborted halfway, which makes it incorrect.
Showing that the set of HHH that can correctly simulate itself is empty.
When a correct simulation needs N steps and you abort it halfway after
M steps, with M much smaller than N, then the simulation of N steps is
correct, but the simulation as a whole is incorrect, because the
semantics of the x86 languages specifies that N steps must me simulated.

olcott

2024-07-21 13:20:04 UTC

Permalink

Some undecidable expressions are only undecidable because
they are self contradictory. In other words they are undecidable
because there is something wrong with them.

Being self-contradictory is a semantic property. Being uncdecidable is
independent of any semantics.

Not it is not. When an expression is neither true nor false
that makes it neither provable nor refutable.

There is no aithmetic sentence that is neither true or false. If the
sentnece
contains both existentia and universal quantifiers it may be hard to
find out
whether it is true or false but there is no sentence that is neither.

As Richard
Montague so aptly showed Semantics can be specified syntactically.

An arithmetic sentence is always about
numbers, not about sentences.

So when Gödel tried to show it could be about provability
he was wrong before he even started?

Gödel did not try to show that an arithmetic sentence is about provability.
He constructed a sentence about numbers that is either true and provable
or false and unprovable in the theory that is an extension of Peano
arithmetics.

You just directly contradicted yourself.

A proof is about sentences, not about
numbers.

The Liar Paradox: "This sentence is not true"

cannot be said in the language of Peano arithmetic.

Since Tarski anchored his whole undefinability theorem in a
self-contradictory sentence he only really showed that sentences that
are neither true nor false cannot be proven true.

By Gödel's completeness theorem every consistent incomplete first order
theory has a model where at least one unprovable sentence is true.

https://liarparadox.org/Tarski_247_248.pdf // Tarski Liar Paradox basis
https://liarparadox.org/Tarski_275_276.pdf // Tarski proof

It is very simple to redefine the foundation of logic to eliminate
incompleteness. Any expression x of language L that cannot be shown
to be true by some (possibly infinite) sequence of truth preserving
operations in L is simply untrue in L: True(L, x).

Tarski showed that True(Tarski_Theory, Liar_Paradox) cannot be defined
never understanding that Liar_Paradox is not a truth bearer.

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

2024-07-21 17:53:04 UTC

Permalink

Post by olcott

Some undecidable expressions are only undecidable because
they are self contradictory. In other words they are undecidable
because there is something wrong with them.

Being self-contradictory is a semantic property. Being uncdecidable is
independent of any semantics.

Not it is not. When an expression is neither true nor false
that makes it neither provable nor refutable.

As Richard
Montague so aptly showed Semantics can be specified syntactically.

An arithmetic sentence is always about
numbers, not about sentences.

So when Gödel tried to show it could be about provability
he was wrong before he even started?

You just directly contradicted yourself.

No, Godel didnt show that arithmetic is about provablity, but that
provability can be reduced to arithmetic.

As with many things, you get your direction of implication reversed.

Post by olcott

A proof is about sentences, not about
numbers.

The Liar Paradox: "This sentence is not true"

cannot be said in the language of Peano arithmetic.

Since Tarski anchored his whole undefinability theorem in a
self-contradictory sentence he only really showed that sentences that
are neither true nor false cannot be proven true.

By Gödel's completeness theorem every consistent incomplete first order
theory has a model where at least one unprovable sentence is true.

https://liarparadox.org/Tarski_247_248.pdf // Tarski Liar Paradox basis
https://liarparadox.org/Tarski_275_276.pdf // Tarski proof

And if you try that you find that your logic system can't handle very
complex topics without becoming inconsistent. And that level turns out
to be well below what we normally want out of logic.

Post by olcott
Tarski showed that True(Tarski_Theory, Liar_Paradox) cannot be defined
never understanding that Liar_Paradox is not a truth bearer.

But he didn't do that, that is just your misunderstanding of what he
did. Your stupidity doesn't negate the work he did that was above your head.

If you think he made an error, show the exact step where he did
something that violates the rules of logic that he was using.

Special note, that doesn't mean coming up with a result you find wrong,
show the operation that he did that is incorrect.

Your problem is the point you like to point to isn't a point where he
makes an assumption, but a point were he calls forward something he
previously proved, so if you don't like that, you need to find the error
with that proof.

But, since you don't seem to understand how formal logic and
meta-theories work, I don't think you can understand that.

I think Formal Logic and Meta-Theories are just to abstract of a concept
for you to understand.

Note, if you ACTUALLY want to "redefine" the Foundations of Logic, go
ahead, just remember when you tear down a foundation, you also tear down
everything built on it, so you need to rebuild them, especially since
you GOAL seems to be to change some of the things above the foundation.

Go ahead and try that, but remember, you need to start AT THAT
FOUNDATION, and to be honest, I don't think you understand how that sort
of logic actually works well enough to make a foundation that would
actual\ly hold anything. I don't think you have the time to do it eather
since you wasted the last 20 years on your lies.

olcott

2024-07-22 14:40:41 UTC

Permalink

Post by olcott

Some undecidable expressions are only undecidable because
they are self contradictory. In other words they are undecidable
because there is something wrong with them.

Being self-contradictory is a semantic property. Being uncdecidable is
independent of any semantics.

Not it is not. When an expression is neither true nor false
that makes it neither provable nor refutable.

As Richard
Montague so aptly showed Semantics can be specified syntactically.

An arithmetic sentence is always about
numbers, not about sentences.

So when Gödel tried to show it could be about provability
he was wrong before he even started?

You just directly contradicted yourself.

I don't, and you cant show any contradiction.

Gödel's proof had nothing what-so-ever to do with provability
except that he proved that g is unprovable in PA.

Post by olcott

A proof is about sentences, not about
numbers.

The Liar Paradox: "This sentence is not true"

cannot be said in the language of Peano arithmetic.

Since Tarski anchored his whole undefinability theorem in a
self-contradictory sentence he only really showed that sentences that
are neither true nor false cannot be proven true.

By Gödel's completeness theorem every consistent incomplete first order
theory has a model where at least one unprovable sentence is true.

https://liarparadox.org/Tarski_247_248.pdf // Tarski Liar Paradox basis
https://liarparadox.org/Tarski_275_276.pdf // Tarski proof

It is very simple to redefine the foundation of logic to eliminate
incompleteness.

Yes, as long as you don't care whether the resulting system is useful.
Classical logic has passed practical tests for thousands of years, so
it is hard to find a sysem with better empirical support.

When we show how incompleteness is eliminated then this also shows
how undefinability is eliminated and this would have resulted in a
chatbot that eviscerated Fascist lies about election fraud long
before they could have taken hold in the minds of 45% of the electorate.

Because people have been arguing against my correct system of reasoning
we will probably see the rise of the fourth Reich.

Post by olcott
Any expression x of language L that cannot be shown
to be true by some (possibly infinite) sequence of truth preserving
operations in L is simply untrue in L: True(L, x).

That does not help much if you cannot determine whether a particular
string can be shown to be true.

Every element of the set of human knowledge can be proven true
by a finite sequence of truth preserving operations. Also every
line can be proved to be false by this same basis.

The Heritage Foundation is the author of Project
2025 and a staunch Trump ally could only find 1546
cases of voter fraud in the last ten years.

#ElectionFraudLies
Even the Heritage Foundation agrees
Never any evidence of election fraud
that could possibly change the results:

Only 1,546 total cases of voter fraud
https://www.heritage.org/voterfraud
Trump is just copying Hitler's "big lie"

Post by olcott
Tarski showed that True(Tarski_Theory, Liar_Paradox) cannot be defined
never understanding that Liar_Paradox is not a truth bearer.

However, every arithmetic sentence is either true or false.

The same diagonalization proof that Gödel used works on
the arithmetization of the Tarski proof. Diagonalization
never shows why g is unprovable in PA, it only shows that
g is unprovable in PA.

The Tarski proof shows why x is unprovable in the Tarski Theory
(because x is self-contradictory in the Tarski Theory)

Tarski's Liar Paradox from page 248
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

Formalized as:
x ∉ True if and only if p
where the symbol 'p' represents the whole sentence x

https://www.researchgate.net/publication/315367846_Minimal_Type_Theory_MTT

In my own Minimal Type Theory the self contradiction
is much easier to see: LP := ~True(LP)

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

2024-07-23 00:12:14 UTC

Permalink

Post by olcott

Some undecidable expressions are only undecidable because
they are self contradictory. In other words they are undecidable
because there is something wrong with them.

Being self-contradictory is a semantic property. Being
uncdecidable is
independent of any semantics.

Not it is not. When an expression is neither true nor false
that makes it neither provable nor refutable.

As Richard
Montague so aptly showed Semantics can be specified syntactically.

An arithmetic sentence is always about
numbers, not about sentences.

So when Gödel tried to show it could be about provability
he was wrong before he even started?

You just directly contradicted yourself.

I don't, and you cant show any contradiction.

Gödel's proof had nothing what-so-ever to do with provability
except that he proved that g is unprovable in PA.

Right, which since G was TRUE in PA, makes PA incomplete.

So, you argee that Godel was correct, but then argue he isn;t

YOU are just showing your logic is inconsistent, and thus unusable.

Post by olcott

A proof is about sentences, not about
numbers.

The Liar Paradox: "This sentence is not true"

cannot be said in the language of Peano arithmetic.

Since Tarski anchored his whole undefinability theorem in a
self-contradictory sentence he only really showed that sentences that
are neither true nor false cannot be proven true.

By Gödel's completeness theorem every consistent incomplete first order
theory has a model where at least one unprovable sentence is true.

https://liarparadox.org/Tarski_247_248.pdf // Tarski Liar Paradox basis
https://liarparadox.org/Tarski_275_276.pdf // Tarski proof

It is very simple to redefine the foundation of logic to eliminate
incompleteness.

Yes, as long as you don't care whether the resulting system is useful.
Classical logic has passed practical tests for thousands of years, so
it is hard to find a sysem with better empirical support.

HOW did you "eliminate" incompleteness. YOo ADMITTED that statements
could be true by just an infinte chain of steps, which is not a proof.

You just are proving you don't unstand what you are talking about, it
seems, because you just don't understand what "Formal Systems" are,
perhaps because they are just too abstract for you.

Post by olcott
Because people have been arguing against my correct system of reasoning
we will probably see the rise of the fourth Reich.

No, you have proved that your system of reasoning can't be correct,
because it denies things you admit are true.,

Post by olcott

Post by olcott
Any expression x of language L that cannot be shown
to be true by some (possibly infinite) sequence of truth preserving
operations in L is simply untrue in L: True(L, x).

That does not help much if you cannot determine whether a particular
string can be shown to be true.

Every element of the set of human knowledge can be proven true
by a finite sequence of truth preserving operations. Also every
line can be proved to be false by this same basis.

So?

You confuse KNOWLEDGE wth TRUTH.

Post by olcott
The Heritage Foundation is the author of Project
2025 and a staunch Trump ally could only find 1546
cases of voter fraud in the last ten years.

And you ar just validating theeir method of logic by using t your self.

You ignore the truth presented to you, bacause you "know" it can't be true.

YOU USE THE METHOD OF THE BIG LIE.

Post by olcott
#ElectionFraudLies
Even the Heritage Foundation agrees
Never any evidence of election fraud
Only 1,546 total cases of voter fraud
https://www.heritage.org/voterfraud
Trump is just copying Hitler's "big lie"

Post by olcott
Tarski showed that True(Tarski_Theory, Liar_Paradox) cannot be defined
never understanding that Liar_Paradox is not a truth bearer.

However, every arithmetic sentence is either true or false.

The same diagonalization proof that Gödel used works on
the arithmetization of the Tarski proof. Diagonalization
never shows why g is unprovable in PA, it only shows that
g is unprovable in PA.

So? The fact that it IS unprovable is enough.

Post by olcott
The Tarski proof shows why x is unprovable in the Tarski Theory
(because x is self-contradictory in the Tarski Theory)

No, he shows that the assumption of a universal truth primative leads to
contradictions, and thus can not exist.

Post by olcott
Tarski's Liar Paradox from page 248
   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

Right, he PROVES that, given the existance of the truth primative, you
can build as a sentence in the logic, a sentence of that form.

Post by olcott
x ∉ True if and only if p
where the symbol 'p' represents the whole sentence x

Which you don't understand where that comes from. You seem to think it
is jus something he made uo, he PROVES that you can form that statement
given that a Truth Primative exists.

Post by olcott
https://www.researchgate.net/publication/315367846_Minimal_Type_Theory_MTT
In my own Minimal Type Theory the self contradiction
is much easier to see: LP := ~True(LP)

Because you don't actually understand what Tarski is doing.

Richard Damon

2024-07-11 00:01:38 UTC

Permalink

Except that you can't stipulate what is "corrrect" or what someone else
means by the words they used, so all you are doing is proving you aren't
working with the normal system.

So, you are just admitting you words are meaningless for computaiton theory.

Also, since the x86 programming language DEFINES (and you didn't
stipulate it away) that the correct behavior of an x86 proggram is that
it runs until it reaches an end, thus the only possible "correct
emulation" is one that doesn't stop, you CAN'T have a finite emulation
that didn't reach a final state, so the only HHH you are alllowed is the
one that never aborts, and thus fails to answer.

And the only behavior of "correct simulation" allowed here is the actual
correct simulation that exactly reproduces the behavior of the program
the input represents, which means it does not EVER abort.

If HHH ever aborts its simulation, it is NOT such a simulation, nor does
it correctly predict the behavior of such a simulation, since if
HHH(DED) aborts its emulation and returns, then the actual behavior of
the input, is to return, thus HHH never was correct to use the second
paragraph.

And thus fails to meet your stipulations, thus proving you to be a liar.

And it doesn't prove that the input, CALLING THAT SAME HHH, is
non-halting, because by your stipuated defintion, the ONLY measure of
the correct behavior of the input is by an actually correct emulation
per the x86 languge specification (which isn't the one by HHH since it
aborted) and when we give this input, that calls this HHH as defined, we
see that it will halt when we simulate it FULLY.

You problem is you don't understand that you don't get to change HHH in
the middle of the problem. If it does abort, it will always abort, and
return, and thus it is never correct to say that it has correctly
decided that it will never stop.

The fact that a DIFFERENT input, with the same code for the C function
DDD but linked to a diffferent HHH (and thus is a different program
represented by the input) behavies diffferently is irrelvent, as this
DDD wasn't lonked to that over HHH.