On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that
there is a Turing machine that can determine whether a string is a >>>>>> valid sentence of your language. If no such Turing machine exists
you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that there is a
Turing machine that can determine whether a string is a valid sentence
of your lanugage. The article does not even mention Turing machine.
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the formalized
Prolog determines that there is a cycle in the directed graph of the evaluation sequence of LP the simple English proves that the Liar
Paradox never gets to the point. It has merely been semantically unsound
all these years.
On 26/11/2025 15:27, olcott wrote:
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Why do you keep posting that?
Tristan Wibberley kirjoitti 26.11.2025 klo 21.46:
On 26/11/2025 15:27, olcott wrote:
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Why do you keep posting that?
In order to distract from the facts he doesn't want to face.
olcott kirjoitti 26.11.2025 klo 17.27:
On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that >>>>>>> there is a Turing machine that can determine whether a string is a >>>>>>> valid sentence of your language. If no such Turing machine exists >>>>>>> you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that there is a >>> Turing machine that can determine whether a string is a valid sentence
of your lanugage. The article does not even mention Turing machine.
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the formalized
Prolog determines that there is a cycle in the directed graph of the
evaluation sequence of LP the simple English proves that the Liar
Paradox never gets to the point. It has merely been semantically
unsound all these years.
All ot that is irrelevant to your lie about where the proof is.
That you chose to lie about it and then to distract is a strong
indication that you have no proof but prefer to lie otherwise.
On 11/27/2025 2:20 AM, Mikko wrote:
olcott kirjoitti 26.11.2025 klo 17.27:
On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that >>>>>>>> there is a Turing machine that can determine whether a string is a >>>>>>>> valid sentence of your language. If no such Turing machine exists >>>>>>>> you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that there
is a
Turing machine that can determine whether a string is a valid sentence >>>> of your lanugage. The article does not even mention Turing machine.
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the formalized
Prolog determines that there is a cycle in the directed graph of the
evaluation sequence of LP the simple English proves that the Liar
Paradox never gets to the point. It has merely been semantically
unsound all these years.
All ot that is irrelevant to your lie about where the proof is.
That you chose to lie about it and then to distract is a strong
indication that you have no proof but prefer to lie otherwise.
Formalized in Olcott's Minimal Type Theory
LP := ~True(LP) // LP {is defined as} ~True(LP)
that expands to ~True(~True(~True(~True(~True(~True(...)))))) https://philarchive.org/archive/PETMTT-4v2
The Liar Paradox fails because its specifies
infinite recursion.
On 11/27/2025 2:20 AM, Mikko wrote:
olcott kirjoitti 26.11.2025 klo 17.27:
On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that >>>>>>>> there is a Turing machine that can determine whether a string is a >>>>>>>> valid sentence of your language. If no such Turing machine exists >>>>>>>> you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that there
is a
Turing machine that can determine whether a string is a valid sentence >>>> of your lanugage. The article does not even mention Turing machine.
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the formalized
Prolog determines that there is a cycle in the directed graph of the
evaluation sequence of LP the simple English proves that the Liar
Paradox never gets to the point. It has merely been semantically
unsound all these years.
All ot that is irrelevant to your lie about where the proof is.
That you chose to lie about it and then to distract is a strong
indication that you have no proof but prefer to lie otherwise.
Formalized in Olcott's Minimal Type Theory
LP := ~True(LP) // LP {is defined as} ~True(LP)
that expands to ~True(~True(~True(~True(~True(~True(...)))))) https://philarchive.org/archive/PETMTT-4v2
The Liar Paradox fails because its specifies
infinite recursion.
olcott kirjoitti 27.11.2025 klo 17.49:
On 11/27/2025 2:20 AM, Mikko wrote:
olcott kirjoitti 26.11.2025 klo 17.27:
On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that >>>>>>>>> there is a Turing machine that can determine whether a string is a >>>>>>>>> valid sentence of your language. If no such Turing machine exists >>>>>>>>> you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that there >>>>> is a
Turing machine that can determine whether a string is a valid sentence >>>>> of your lanugage. The article does not even mention Turing machine.
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the formalized
Prolog determines that there is a cycle in the directed graph of the
evaluation sequence of LP the simple English proves that the Liar
Paradox never gets to the point. It has merely been semantically
unsound all these years.
All ot that is irrelevant to your lie about where the proof is.
That you chose to lie about it and then to distract is a strong
indication that you have no proof but prefer to lie otherwise.
Formalized in Olcott's Minimal Type Theory
LP := ~True(LP) // LP {is defined as} ~True(LP)
that expands to ~True(~True(~True(~True(~True(~True(...))))))
https://philarchive.org/archive/PETMTT-4v2
The Liar Paradox fails because its specifies
infinite recursion.
Irrelevant to your lie about where the proof is. That you chose to lie
about it and then to distract is a strong indication that you have no
proof but prefer to lie otherwise.
On 11/28/2025 2:45 AM, Mikko wrote:
olcott kirjoitti 27.11.2025 klo 17.49:
On 11/27/2025 2:20 AM, Mikko wrote:
olcott kirjoitti 26.11.2025 klo 17.27:
On 11/26/2025 4:30 AM, Mikko wrote:
olcott kirjoitti 14.11.2025 klo 16.42:
On 11/14/2025 3:01 AM, Mikko wrote:
On 2025-11-13 16:00:58 +0000, olcott said:
On 11/13/2025 3:05 AM, Mikko wrote:
On 2025-11-12 14:45:34 +0000, olcott said:
Rejecting expressions of formal language
having pathological self-reference
Explained how expressions with pathological self
reference can simply be rejected as semantically/
syntactically unsound thus preventing undefinability,
and undecidability.
This sentence is not true: "This sentence is not true"
is true only because the inner sentence is semantically
unsound. The inner sentence is formalized in Minimal
Type Theory as LP := ~True(LP).
(where A := B means A is defined as B).
https://philpapers.org/rec/OLCREO
Can someone review my actual reasoning
elaborated in the paper?
If you want to use the term "formal language" you must prove that >>>>>>>>>> there is a Turing machine that can determine whether a string >>>>>>>>>> is a
valid sentence of your language. If no such Turing machine exists >>>>>>>>>> you have no justifiction for the use of the word "formal".
Been there done that and provided all the details.
Where? At least not where the above pointer points to.
In the paper that you failed to read.
https://www.researchgate.net/
publication/397533139_Rejecting_expressions_of_formal_language_having_pathological_self-reference
In that article there is no proof that there is no proof that
there is a
Turing machine that can determine whether a string is a valid
sentence
of your lanugage. The article does not even mention Turing machine. >>>>>>
It is all the deep meaning of unify_with_occurs_check()
that rejects an expression as semantically unsound
because its evaluation is stuck in an infinite loop.
The Liar Paradox formalized in the Prolog Programming language
This sentence is not true.
It is not true about what?
It is not true about being not true.
It is not true about being not true about what?
It is not true about being not true about being not true.
Oh I see you are stuck in a loop!
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Failing an occurs check seems to mean that the resolution of an
expression remains stuck in an infinite loop. Just as the
formalized Prolog determines that there is a cycle in the directed
graph of the evaluation sequence of LP the simple English proves
that the Liar Paradox never gets to the point. It has merely been
semantically unsound all these years.
All ot that is irrelevant to your lie about where the proof is.
That you chose to lie about it and then to distract is a strong
indication that you have no proof but prefer to lie otherwise.
Formalized in Olcott's Minimal Type Theory
LP := ~True(LP) // LP {is defined as} ~True(LP)
that expands to ~True(~True(~True(~True(~True(~True(...))))))
https://philarchive.org/archive/PETMTT-4v2
The Liar Paradox fails because its specifies
infinite recursion.
Irrelevant to your lie about where the proof is. That you chose to lie
about it and then to distract is a strong indication that you have no
proof but prefer to lie otherwise.
In other words you are simply ignoring this ~True(~True(~True(~True(~True(~True(...))))))
On 11/26/2025 1:46 PM, Tristan Wibberley wrote:
On 26/11/2025 15:27, olcott wrote:
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Why do you keep posting that?
Until it is accepted or someone correctly shows
how it does not once-and-for-all resolve
the Liar Paradox I will keep posting it.
On 26/11/2025 20:07, olcott wrote:
On 11/26/2025 1:46 PM, Tristan Wibberley wrote:
On 26/11/2025 15:27, olcott wrote:
This is formalized in the Prolog programming language
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
Why do you keep posting that?
Until it is accepted or someone correctly shows
how it does not once-and-for-all resolve
the Liar Paradox I will keep posting it.
Can you show how it /does/ ?
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,090 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 63:14:27 |
| Calls: | 13,949 |
| Calls today: | 2 |
| Files: | 187,035 |
| D/L today: |
3,464 files (1,014M bytes) |
| Messages: | 2,461,403 |