Discussion:
The error of the Liar Paradox and Gödel's 1931 Incompleteness Theorem.
peteolcott
2020-02-24 18:31:56 UTC
The error of the Liar Paradox and Gödel's 1931 Incompleteness Theorem.

Here is the kind of self reference that creates the liar "paradox".

void main()
{
bool LP = !(LP == true);
}

Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true.

This is like asking a person that does not own a car: How many feet long is your car?

Or asking someone that has never been married: Have you stopped beating your spouse yet?

The problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.

We can see that this same reasoning also applies to Gödel's 1931 Incompleteness Theorem.

void main()
{
bool G = !(G == Provable(G));
}

Copyright 2016 and 2020 Pete Olcott
peteolcott
2020-02-24 19:56:38 UTC
Post by peteolcott
The error of the Liar Paradox and Gödel's 1931 Incompleteness Theorem.
Here is the kind of self reference that creates the liar "paradox".
void main()
{
bool LP = !(LP == true);
}
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true.
This is like asking a person that does not own a car: How many feet long is your car?
Or asking someone that has never been married: Have you stopped beating your spouse yet?
The problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.
We can see that this same reasoning also applies to Gödel's 1931 Incompleteness Theorem.
void main()
{
bool G = !(G == Provable(G));
}
Copyright 2016 and 2020 Pete Olcott
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true. It is easy to see this through the "C" program because "C" has precisely defined and fully elaborated semantics.

When we understand that the above "C" program accurately captures the essence of the Liar Paradox we see that the problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.

"This sentence is not true". It not a truth bearer because it does not specify a relation between things that can be tested that resolves to a single Boolean value.

"This sentence is a bag of green onions". Is a truth bearer because it specifies a relation between things that can be tested that resolves to a single Boolean value.

https://plato.stanford.edu/entries/truthmakers/ This much is agreed: “x makes it true that p” is a construction that signifies, if it signifies anything at all, a relation borne to a truth-bearer by something else, a truth-maker.

"This sentence is not true". Has no object of truth, there is only a relation between the negation of the Boolean value of TRUE and an undefined Boolean value.

"This sentence is a bag of green onions". Has an object of truth, when we test the assertion that the abstraction of the sentence (having no physical existence) is a member of the set of a specific set of physically existing things we find that the answer is Boolean false.
David Kleinecke
2020-02-25 00:13:45 UTC
Post by peteolcott
Post by peteolcott
The error of the Liar Paradox and Gödel's 1931 Incompleteness Theorem.
Here is the kind of self reference that creates the liar "paradox".
void main()
{
bool LP = !(LP == true);
}
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true.
This is like asking a person that does not own a car: How many feet long is your car?
Or asking someone that has never been married: Have you stopped beating your spouse yet?
The problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.
We can see that this same reasoning also applies to Gödel's 1931 Incompleteness Theorem.
void main()
{
bool G = !(G == Provable(G));
}
Copyright 2016 and 2020 Pete Olcott
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true. It is easy to see this through the "C" program because "C" has precisely defined and fully elaborated semantics.
When we understand that the above "C" program accurately captures the essence of the Liar Paradox we see that the problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.
"This sentence is not true". It not a truth bearer because it does not specify a relation between things that can be tested that resolves to a single Boolean value.
"This sentence is a bag of green onions". Is a truth bearer because it specifies a relation between things that can be tested that resolves to a single Boolean value.
https://plato.stanford.edu/entries/truthmakers/ This much is agreed: “x makes it true that p” is a construction that signifies, if it signifies anything at all, a relation borne to a truth-bearer by something else, a truth-maker.
"This sentence is not true". Has no object of truth, there is only a relation between the negation of the Boolean value of TRUE and an undefined Boolean value.
"This sentence is a bag of green onions". Has an object of truth, when we test the assertion that the abstraction of the sentence (having no physical existence) is a member of the set of a specific set of physically existing things we find that the answer is Boolean false.
Welcome back, Peter. Glad you are able to do business at the same
old stand.

But your point has not improved.

The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1

But, of course, that doesn't refute your observation because the rules
of the C Language are not all the possible ways to do logic.

I think the paradox is better presented as
the set of all sets that do not belong to themselves
What does that phrase refer to?
Keith Thompson
2020-02-25 06:39:54 UTC
David Kleinecke <***@gmail.com> writes:
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]

That turns out not to be a good example.

LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.

In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.

Here is a complete and valid C program:

#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}

Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".

Here is a complete C program with undefined or unspecified behavior:

#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}

The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.

The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+***@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
David Kleinecke
2020-02-25 17:29:20 UTC
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
Have I jumped too fast and declared an error where none is required?
Oh well - there are other errors in my compiler.

I am curious how PO will respond to my set theoretical version.
Previously he has demonstrated no comprehension of set theory.
peteolcott
2020-02-25 18:48:36 UTC
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
David Kleinecke
2020-02-25 22:20:34 UTC
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?

I have trouble believing in them.
peteolcott
2020-02-26 01:26:07 UTC
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
David Kleinecke
2020-02-26 03:28:32 UTC
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.

Note that isomorphism does not just involve sets it also involves
all the operations on the sets.

Have you any such isomorphisms?
peteolcott
2020-02-26 03:35:08 UTC
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.
Note that isomorphism does not just involve sets it also involves
all the operations on the sets.
Have you any such isomorphisms?
An isomorphism is the mathematical version of an analogy.

http://mathworld.wolfram.com/Isomorphism.html
Isomorphism is a very general concept that appears in several areas of mathematics. The word derives from the Greek iso, meaning "equal," and morphosis, meaning "to form" or "to shape."
David Kleinecke
2020-02-26 04:21:36 UTC
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.
Note that isomorphism does not just involve sets it also involves
all the operations on the sets.
Have you any such isomorphisms?
An isomorphism is the mathematical version of an analogy.
http://mathworld.wolfram.com/Isomorphism.html
Isomorphism is a very general concept that appears in several areas of mathematics. The word derives from the Greek iso, meaning "equal," and morphosis, meaning "to form" or "to shape."
"Isomorphism" has a very well-established mathematical meaning which I
explained. If Wolfram disagrees Wolfram is wrong. If you use
"isomorphism" in any other sense you will not be understood.
peteolcott
2020-02-26 05:11:28 UTC
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.
Note that isomorphism does not just involve sets it also involves
all the operations on the sets.
Have you any such isomorphisms?
An isomorphism is the mathematical version of an analogy.
http://mathworld.wolfram.com/Isomorphism.html
Isomorphism is a very general concept that appears in several areas of mathematics. The word derives from the Greek iso, meaning "equal," and morphosis, meaning "to form" or "to shape."
"Isomorphism" has a very well-established mathematical meaning which I
explained. If Wolfram disagrees Wolfram is wrong. If you use
"isomorphism" in any other sense you will not be understood.
I am creating brand new things here that don't yet have names.
https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
In other words, the Curry–Howard correspondence is the observation that two families of seemingly unrelated formalisms—namely, the proof systems on one hand, and the models of computation on the other—are in fact the same kind of mathematical objects. I refer to finite string transformations by an algorithm.

The chain of symbolic manipulations in the calculus corresponds to
and represents the chain of deductions in the deductive system.

Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…

When we combine all that together we get finite strings that have been assigned the semantic value of Boolean true as the complete set of true premises. Truth preserving finite string transformations representing deductive inference and conclusions that are necessarily true because the argument is deductively sound.

The above shows how the whole notion of analytical True(X) can be one-and-the-same-thing as a theorem of a formal system, thus eliminating incompleteness. Also the formal system can be the entire body of analytical truth.

David Kleinecke
2020-02-26 16:08:43 UTC
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.
Note that isomorphism does not just involve sets it also involves
all the operations on the sets.
Have you any such isomorphisms?
An isomorphism is the mathematical version of an analogy.
http://mathworld.wolfram.com/Isomorphism.html
Isomorphism is a very general concept that appears in several areas of mathematics. The word derives from the Greek iso, meaning "equal," and morphosis, meaning "to form" or "to shape."
"Isomorphism" has a very well-established mathematical meaning which I
explained. If Wolfram disagrees Wolfram is wrong. If you use
"isomorphism" in any other sense you will not be understood.
I am creating brand new things here that don't yet have names.
https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
In other words, the Curry–Howard correspondence is the observation that two families of seemingly unrelated formalisms—namely, the proof systems on one hand, and the models of computation on the other—are in fact the same kind of mathematical objects. I refer to finite string transformations by an algorithm.
The chain of symbolic manipulations in the calculus corresponds to
and represents the chain of deductions in the deductive system.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
When we combine all that together we get finite strings that have been assigned the semantic value of Boolean true as the complete set of true premises. Truth preserving finite string transformations representing deductive inference and conclusions that are necessarily true because the argument is deductively sound.
The above shows how the whole notion of analytical True(X) can be one-and-the-same-thing as a theorem of a formal system, thus eliminating incompleteness. Also the formal system can be the entire body of analytical truth.
You are dabbling with very powerful tools and it is easy to go
wrong. I see no references to isomorphisms of the type you
suppose.
peteolcott
2020-02-26 18:20:12 UTC
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
Post by Keith Thompson
[...]
Post by David Kleinecke
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
[...]
That turns out not to be a good example.
LP is a variable (in C terms, an "object"), and it can have an initial
value and then other values assigned to it over time. It's a container
that can hold values.
In typical mathematics notation, something like
LP = not LP
(with "=" meaning equality) is simply a false statement, for any value
of LP.
#include <stdio.h>
int main(void) {
int LP = 1; /* line 3 */
LP = ! LP; /* line 4 */
printf("LP = %d\n", LP);
}
Line 3 defines an object named LP and initializes it to the value 1.
Line 4 ("=" is the assignment operator, not the equality operator)
stores a new value in LP. The output is "LP = 0".
#include <stdio.h>
int main(void) {
int LP = ! LP;
printf("LP = %d\n", LP);
}
The name "LP" is visible in its initializer. The initializer
is invalid because it refers to LP before it has been assigned a
value, but that doesn't make it illegal. I believe the behavior is
undefined, meaning that the C standard says nothing about what it
might do. It will *likely* print either "LP = 1" or "LP = 0",
depending on what garbage value happens to be stored in LP before
it's initialized.
The lesson (not directed at you, David) is: Don't use C code as an
example if you don't understand C, and in this case the difference
between assignment ("=") and equality ("==").
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
My "C" program is isomorphic to both the Liar Paradox and the
1931 Incompleteness Theorem which are isomorphic to each other.
Have you exhibited these isomorphisms somewhere?
I have trouble believing in them.
Both versions of the "C" program are obviously isomorphic to
each other in that both of them assign a value to an undefined
variable by testing this variable before it has been defined.
The normal way to show an isomorphism (between) A and B is to
a one-to-one map (such that a in A maps onto a* and b in B into
b*) from all the members of A to all the members of B such that
if x is a unary/binary operation in A and y an operation of B
then for any u and v in A
(u x v)* = u* y v*
and vice versa.
Note that isomorphism does not just involve sets it also involves
all the operations on the sets.
Have you any such isomorphisms?
An isomorphism is the mathematical version of an analogy.
http://mathworld.wolfram.com/Isomorphism.html
Isomorphism is a very general concept that appears in several areas of mathematics. The word derives from the Greek iso, meaning "equal," and morphosis, meaning "to form" or "to shape."
"Isomorphism" has a very well-established mathematical meaning which I
explained. If Wolfram disagrees Wolfram is wrong. If you use
"isomorphism" in any other sense you will not be understood.
I am creating brand new things here that don't yet have names.
https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence
In other words, the Curry–Howard correspondence is the observation that two families of seemingly unrelated formalisms—namely, the proof systems on one hand, and the models of computation on the other—are in fact the same kind of mathematical objects. I refer to finite string transformations by an algorithm.
The chain of symbolic manipulations in the calculus corresponds to
and represents the chain of deductions in the deductive system.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
When we combine all that together we get finite strings that have been assigned the semantic value of Boolean true as the complete set of true premises. Truth preserving finite string transformations representing deductive inference and conclusions that are necessarily true because the argument is deductively sound.
The above shows how the whole notion of analytical True(X) can be one-and-the-same-thing as a theorem of a formal system, thus eliminating incompleteness. Also the formal system can be the entire body of analytical truth.
You are dabbling with very powerful tools and it is easy to go
wrong. I see no references to isomorphisms of the type you
suppose.
Within the entire body of analytical knowledge truth is exactly one of two things:
(1) Expressions of language (finite strings) that have been defined to have the semantic property of Boolean True. Corresponding to Axioms of a formal system. (Curry 1977:45)

(2) Truth preserving operations (finite string transformations) applied to these expressions of language (finite strings). Corresponding to Theorems of a formal system.

This proves that True(X) and Provable(X) cannot ever possibly diverge.

Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
We begin by postulating a certain non void, definite class {E} of statements, which we call elementary statements...

The statements of {E} are called elementary statements to distinguish them from other statements which we may form from them or about them in the U language...

Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…

The terminology which has just been used implies that the elementary statements are not such that their truth and falsity are known to us without reference to {T}.
David Kleinecke
2020-02-26 23:51:33 UTC
Post by peteolcott
(1) Expressions of language (finite strings) that have been defined to have the semantic property of Boolean True. Corresponding to Axioms of a formal system. (Curry 1977:45)
(2) Truth preserving operations (finite string transformations) applied to these expressions of language (finite strings). Corresponding to Theorems of a formal system.
That is NOT the definition of "truth".
Post by peteolcott
This proves that True(X) and Provable(X) cannot ever possibly diverge.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
We begin by postulating a certain non void, definite class {E} of statements, which we call elementary statements...
The statements of {E} are called elementary statements to distinguish them from other statements which we may form from them or about them in the U language...
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
The terminology which has just been used implies that the elementary statements are not such that their truth and falsity are known to us without reference to {T}.
peteolcott
2020-02-27 00:11:05 UTC
Post by David Kleinecke
Post by peteolcott
(1) Expressions of language (finite strings) that have been defined to have the semantic property of Boolean True. Corresponding to Axioms of a formal system. (Curry 1977:45)
(2) Truth preserving operations (finite string transformations) applied to these expressions of language (finite strings). Corresponding to Theorems of a formal system.
That is NOT the definition of "truth".
I can be just as dogmatic as you:
YES it is the definition and the algorithm of truth.

The only reason that "cats" are "animals" and not "boxcars" is that this was stipulated as a "fact" in the body of conceptual knowledge, thus essentially an axiom.

The only reason that we know that the fact that "cats are mammals" and "mammals are animals" semantically entails that "cats are animals" is the fact of the stipulated relations between the three. Thus essentially a rule-of-inference.

You can say that you disagree, what you cannot do is point out any logically correct basis for disagreement because what I say is self-evidently correct thus impossibly incorrect.
Post by David Kleinecke
Post by peteolcott
This proves that True(X) and Provable(X) cannot ever possibly diverge.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
We begin by postulating a certain non void, definite class {E} of statements, which we call elementary statements...
The statements of {E} are called elementary statements to distinguish them from other statements which we may form from them or about them in the U language...
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
The terminology which has just been used implies that the elementary statements are not such that their truth and falsity are known to us without reference to {T}.
David Kleinecke
2020-02-27 04:03:39 UTC
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
(1) Expressions of language (finite strings) that have been defined to have the semantic property of Boolean True. Corresponding to Axioms of a formal system. (Curry 1977:45)
(2) Truth preserving operations (finite string transformations) applied to these expressions of language (finite strings). Corresponding to Theorems of a formal system.
That is NOT the definition of "truth".
YES it is the definition and the algorithm of truth.
The only reason that "cats" are "animals" and not "boxcars" is that this was stipulated as a "fact" in the body of conceptual knowledge, thus essentially an axiom.
The only reason that we know that the fact that "cats are mammals" and "mammals are animals" semantically entails that "cats are animals" is the fact of the stipulated relations between the three. Thus essentially a rule-of-inference.
You can say that you disagree, what you cannot do is point out any logically correct basis for disagreement because what I say is self-evidently correct thus impossibly incorrect.
Post by David Kleinecke
Post by peteolcott
This proves that True(X) and Provable(X) cannot ever possibly diverge.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
We begin by postulating a certain non void, definite class {E} of statements, which we call elementary statements...
The statements of {E} are called elementary statements to distinguish them from other statements which we may form from them or about them in the U language...
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
The terminology which has just been used implies that the elementary statements are not such that their truth and falsity are known to us without reference to {T}.
It is not even agreed upon that "truth" can be expressed in a formal
system (such as strings).

You may call "provable" "true" if you please but no other human being
is likely to go along with you.

In particular you must not imagine that ideas are true in the every
day meaning of true just because they are true in your sense.
peteolcott
2020-02-27 04:18:36 UTC
Post by David Kleinecke
Post by peteolcott
Post by David Kleinecke
Post by peteolcott
(1) Expressions of language (finite strings) that have been defined to have the semantic property of Boolean True. Corresponding to Axioms of a formal system. (Curry 1977:45)
(2) Truth preserving operations (finite string transformations) applied to these expressions of language (finite strings). Corresponding to Theorems of a formal system.
That is NOT the definition of "truth".
YES it is the definition and the algorithm of truth.
The only reason that "cats" are "animals" and not "boxcars" is that this was stipulated as a "fact" in the body of conceptual knowledge, thus essentially an axiom.
The only reason that we know that the fact that "cats are mammals" and "mammals are animals" semantically entails that "cats are animals" is the fact of the stipulated relations between the three. Thus essentially a rule-of-inference.
You can say that you disagree, what you cannot do is point out any logically correct basis for disagreement because what I say is self-evidently correct thus impossibly incorrect.
Post by David Kleinecke
Post by peteolcott
This proves that True(X) and Provable(X) cannot ever possibly diverge.
Curry, Haskell 1977. Foundations of Mathematical Logic. New York: Dover Publications, 45
We begin by postulating a certain non void, definite class {E} of statements, which we call elementary statements...
The statements of {E} are called elementary statements to distinguish them from other statements which we may form from them or about them in the U language...
Then the elementary statements which belong to {T} we shall call the elementary theorems of {T}; we also say that these elementary statements are true for {T}. Thus, given {T}, an elementary theorem is an elementary statement which is true. A theory is thus a way of picking out from the statements of {E} a certain subclass of true statements…
The terminology which has just been used implies that the elementary statements are not such that their truth and falsity are known to us without reference to {T}.
It is not even agreed upon that "truth" can be expressed in a formal
system (such as strings).
Of course you know that statement is utterly ridiculous and you are just pulling my chain to get a reaction. You know damn well that "cows are animals" is indeed a finite string that expresses truth.
Post by David Kleinecke
You may call "provable" "true" if you please but no other human being
is likely to go along with you.
Yes if they want to argue against me at the cost of the truth you may be right, yet you and I both know that I already proved my point. All that we have to do to make provable true is simply express a syllogism as finite strings, bingo deduction now has a formal proof.

You might still honestly not fully realize that every fact known to man works this same way. Knowing this requires the synthesis of many abstractions.
Post by David Kleinecke
In particular you must not imagine that ideas are true in the every
day meaning of true just because they are true in your sense.
That is my achievement. I have forced the mathematical sense of true to conform to the common understanding of true and I have done it very simply.

Some expressions of language are stipulated to be true and some relations between expressions of language are stipulated to be truth preserving. That really is all there is to the entire body of conceptual truth.

When you search everywhere and find that no counter-example can possibly exist, thenn (then and only then) you will know that I am right.

peteolcott
2020-02-25 18:45:56 UTC
Post by David Kleinecke
Post by peteolcott
Post by peteolcott
The error of the Liar Paradox and Gödel's 1931 Incompleteness Theorem.
Here is the kind of self reference that creates the liar "paradox".
void main()
{
bool LP = !(LP == true);
}
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true.
This is like asking a person that does not own a car: How many feet long is your car?
Or asking someone that has never been married: Have you stopped beating your spouse yet?
The problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.
We can see that this same reasoning also applies to Gödel's 1931 Incompleteness Theorem.
void main()
{
bool G = !(G == Provable(G));
}
Copyright 2016 and 2020 Pete Olcott
Before LP is defined to have any value, this non-existent value is tested to see if it is equal to true. It is easy to see this through the "C" program because "C" has precisely defined and fully elaborated semantics.
When we understand that the above "C" program accurately captures the essence of the Liar Paradox we see that the problem with the Liar Paradox is that its value is only defined on the basis of testing this value before it has been defined.
"This sentence is not true". It not a truth bearer because it does not specify a relation between things that can be tested that resolves to a single Boolean value.
"This sentence is a bag of green onions". Is a truth bearer because it specifies a relation between things that can be tested that resolves to a single Boolean value.
https://plato.stanford.edu/entries/truthmakers/ This much is agreed: “x makes it true that p” is a construction that signifies, if it signifies anything at all, a relation borne to a truth-bearer by something else, a truth-maker.
"This sentence is not true". Has no object of truth, there is only a relation between the negation of the Boolean value of TRUE and an undefined Boolean value.
"This sentence is a bag of green onions". Has an object of truth, when we test the assertion that the abstraction of the sentence (having no physical existence) is a member of the set of a specific set of physically existing things we find that the answer is Boolean false.
Welcome back, Peter. Glad you are able to do business at the same
old stand.
But your point has not improved.
The statement in the C language that
int LP = ! (LP == 1);
fails because the rules of C don't allow LP to be used before it is
defined and LP is still undefined when one tries to evaluate
LP == 1
The key point is that both the Liar Paradox and the 1931
Incompleteness are an isomorphism to each other and the
above "C" program.

My refutation of the Halting Problem is going fabulously well.
I decided to use X86 machine language as my model of a Turing
Machine and a software X86 emulator as the UTM.
Ben Bacarisse
2020-02-26 21:19:20 UTC
Post by peteolcott
The error of the Liar Paradox and Gödel's 1931 Incompleteness
Theorem...
All good waffling topics. But it is now over a year (14 months) since
you claimed to have "an actual Turing machine" that everyone here told
you was impossible. You came up with all sort of excuses for not
posting it. Come clean, you never had such TM and you are never going
to post anything resembling such a TM, are you? It would be best to
simply admit this now. I can't help the urge to remind the world of
this deception of yours every time you pop back into these groups with
some new nonsense.
--
Ben.