[an input that does the opposite of
-awhat one particular decider outputs]
-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider for analysis
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do this,
the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider for analysis
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do this,
the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do
this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do
this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do
this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider >>>>> for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not reach
it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end state, however
for example: any implementation of EYon as defined by turing in /on computable numbers/
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do
this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the
decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not reach
it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end
state, however
for example: any implementation of EYon as defined by turing in /on
computable numbers/
Not when DD calls this same EYon
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do >>>>>> this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own >>>>>>> definition using a quine, and then submits that copy to the
decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not
reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end
state, however
for example: any implementation of EYon as defined by turing in /on
computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation DD_EYon,
-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon) would
halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts...
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do >>>>>>> this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 12:02 PM, dart200 wrote:
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own >>>>>>>> definition using a quine, and then submits that copy to the
decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not
reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end
state, however
for example: any implementation of EYon as defined by turing in /on
computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation DD_EYon,
-a-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon) >> would halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts...
Proving that the call to EYon(DD) or HHH(DD) cannot be
ignored and must form the basis for a correct halt
decision when applying finite stings transformation
rules to input static finite strings.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can >>>>>>>> do this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/26 10:11 AM, olcott wrote:
On 11/6/2026 12:02 PM, dart200 wrote:
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's >>>>>>>>> own definition using a quine, and then submits that copy to the >>>>>>>>> decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not
reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end
state, however
for example: any implementation of EYon as defined by turing in /on >>>>> computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation
DD_EYon, -a-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon) >>> would halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts... >>>
Proving that the call to EYon(DD) or HHH(DD) cannot be
ignored and must form the basis for a correct halt
decision when applying finite stings transformation
rules to input static finite strings.
i apologize, i don't understand the comment
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can >>>>>>>>> do this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/5/26 11:18 PM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
the thing u don't understand polcott is that paradoxical machines do not exist by anyone's choice, not even a god could do fuck all about them
if giving a set of finite string transformations that attempts to
compute the halting function, totally, partially, or otherwise...
some paradoxical machine is simply a logical possibility (and more so infinite variations of which) that can be written as a series of finite string transformations. its existence in the total enumeration of finite string transformations, is necessarily implied by any existence of any finite string transformation, that attempts to compute the halting
function, totally, partially, or otherwise
HHH does exist, u wrote it. therefore must DD does exist, which u also wrote, so theory aligns with evidence
for any HHH_N, of which there are infinite variations of, that compute difference infinite slices of the total halting function, however
accurate, there will necessarily be some DD1 analogy for it that is necessarily not in that slice.
that just is the nature of undecidability within computing, whatcha
gunna do about it polcott?
in my opinion the real question we should be asking is which infinite
slice we're truly interested in, which honestly we've answered quite
poorly thus far
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can do
this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 12:30 PM, dart200 wrote:
On 11/6/26 10:11 AM, olcott wrote:
On 11/6/2026 12:02 PM, dart200 wrote:
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's >>>>>>>>>> own definition using a quine, and then submits that copy to >>>>>>>>>> the decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not
reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end >>>>>> state, however
for example: any implementation of EYon as defined by turing in /on >>>>>> computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation
DD_EYon, -a-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon)
would halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts... >>>>
Proving that the call to EYon(DD) or HHH(DD) cannot be
ignored and must form the basis for a correct halt
decision when applying finite stings transformation
rules to input static finite strings.
i apologize, i don't understand the comment
Computation defined
Paraphrase of Emil Post definition of computation
All computations are equivalent applying finite string
transformation rules to finite string inputs to derive
any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite strings inputs is outside of
the domain of ChurchrCoTuring computable functions.
Its this theory of computation definition.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines can >>>>>>>>>> do this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/26 10:45 AM, olcott wrote:
On 11/6/2026 12:30 PM, dart200 wrote:
On 11/6/26 10:11 AM, olcott wrote:
On 11/6/2026 12:02 PM, dart200 wrote:
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's >>>>>>>>>>> own definition using a quine, and then submits that copy to >>>>>>>>>>> the decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable.
The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not >>>>>>> reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
correct, there are other simulators that do reach DDs natural end >>>>>>> state, however
for example: any implementation of EYon as defined by turing in /on >>>>>>> computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation >>>>> DD_EYon, -a-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon)
would halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts... >>>>>
Proving that the call to EYon(DD) or HHH(DD) cannot be
ignored and must form the basis for a correct halt
decision when applying finite stings transformation
rules to input static finite strings.
i apologize, i don't understand the comment
Computation defined
Paraphrase of Emil Post definition of computation
All computations are equivalent applying finite string
transformation rules to finite string inputs to derive
any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite strings inputs is outside of
the domain of ChurchrCoTuring computable functions.
which the total halting function is, and that is the halting theorem in
a nutshell
Its this theory of computation definition.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines >>>>>>>>>>> can do this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
On 11/6/2026 3:41 PM, dart200 wrote:
On 11/6/26 10:45 AM, olcott wrote:
On 11/6/2026 12:30 PM, dart200 wrote:
On 11/6/26 10:11 AM, olcott wrote:
On 11/6/2026 12:02 PM, dart200 wrote:
On 11/6/26 9:19 AM, olcott wrote:
On 11/6/2026 11:12 AM, dart200 wrote:
On 11/6/26 9:05 AM, olcott wrote:
On 11/6/2026 10:38 AM, dart200 wrote:
On 11/6/26 6:25 AM, olcott wrote:
On 11/6/2026 1:18 AM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's >>>>>>>>>>>> own definition using a quine, and then submits that copy to >>>>>>>>>>>> the decider for analysis
If has never been possible to construct an input that
does the opposite of what its halt decider reports
because this do the opposite code is always unreachable. >>>>>>>>>>> The DD that does the opposite of what HHH(DD) reports
is the caller of HHH(DD) thus not its actual input.
the DD simulated by HHH is stopped by HHH polcott,
it does not reach it's natural end state
Maybe this stuff is just over your head?
gaslighting me ain't a good look polcott
HHH as implemented is what causes the DD simulated by HHH to not >>>>>>>> reach it's natural end state
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches >>>>>>>>> its own simulated return statement in any N finite number of >>>>>>>>> steps.
correct, there are other simulators that do reach DDs natural >>>>>>>> end state, however
for example: any implementation of EYon as defined by turing in /on >>>>>>>> computable numbers/
Not when DD calls this same EYon
if DD called EYon(DD) instead of HHH(DD)-- lets call this variation >>>>>> DD_EYon, -a-athen DD_EYon would be an infinite recursion
neither the top level DD_EYon, nor any recursively simulated EYon(DD_EYon)
would halt
but if EYon calls the original DD that calls HHH, then EYon(DD) halts... >>>>>>
Proving that the call to EYon(DD) or HHH(DD) cannot be
ignored and must form the basis for a correct halt
decision when applying finite stings transformation
rules to input static finite strings.
i apologize, i don't understand the comment
Computation defined
Paraphrase of Emil Post definition of computation
All computations are equivalent applying finite string
transformation rules to finite string inputs to derive
any and all outputs.
Because Post canonical systems are Turing-equivalent,
anything that cannot be derived by applying finite string
transformations to finite strings inputs is outside of
the domain of ChurchrCoTuring computable functions.
which the total halting function is, and that is the halting theorem
in a nutshell
We are TOTALLY WRONG to start with what math
wants computations to achieve. We must only
begin with what finite string transformations
applied to input finite strings can achieve.
Its this theory of computation definition.
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
it's more akin to cloning itself polcott. and yes machines >>>>>>>>>>>> can do this, the technique isn't that complicated
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf >>>>>>>>>>>>>
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
Of course -- thatrCOs how the proof--
works: if the starting assumption leads to a nonsensical conclusion,
and no other fault in the logic can be found, then the assumption (in
this case, that you *can* create a decision procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof works: if the starting assumption leads to a nonsensical conclusion,
and no other fault in the logic can be found, then the assumption (in
this case, that you *can* create a decision procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
[an input that does the opposite of
-awhat one particular decider outputs]
-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
[an input that does the opposite of
-awhat one particular decider outputs]
-ais inherently incoherent.
If it gets a return value to do the opposite of^^^^^^^^^^^^
On 11/5/26 11:18 PM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
the thing u don't understand polcott is that paradoxical machines do not exist by anyone's choice
On 06/11/2026 04:53, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
That is a straw man deception. What you are talking about is not
the halting theorem. In particular, the identified incoherence
is not in the halting theorem.
Would you honestly want to show an incoherence in the halting
theorem you would first present the theorem you are going to
talk about and then identifiy the first sentence that is not
coherent in the context of the sentences before it. The rest
of the theorem is irrelevant to the existence of the incoherence
but are needed because they specify what you are talking about.
On 06/11/2026 02:53, olcott wrote:
[an input that does the opposite of
-awhat one particular decider outputs]
-ais inherently incoherent.
I continue to reject your acceptance of the explication of "incoherent"
that you're relying on. It should be rejected and an alternative
pedagogy that uses a different word should be sought.
"incoherent" normally describes something like this:
I went for a short vigourous dream in a cave
all conditionals wield a hope
the sun is the yeti's willy and it smells of rancid newt vomit. qed
The steps do not "stick together": they do not cohere regardless of the
the yeti's actual degree of access to sexual health services.
I can't accept that having one /end/ of the chain flapping loose in the infinite tundra of unbounded recursion qualifies as incoherency because
the end doesn't even exist to fail to stick to something!
If it gets a return value to do the opposite of^^^^^^^^^^^^
stateful imperative stack-based programming or message-passing
emulations of the same is the context?
On 06/11/2026 08:35, dart200 wrote:
On 11/5/26 11:18 PM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
the thing u don't understand polcott is that paradoxical machines do not
exist by anyone's choice
They don't exist, in the everyday meaning of the word exist. In the
sense of being objects of a formal system we never make one. We rely on
a nontology to fool ourselves.
On 06/11/2026 08:35, dart200 wrote:
On 11/5/26 11:18 PM, dart200 wrote:
On 11/5/26 6:53 PM, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
the paradoxical machine constructs an in memory copy of it's own
definition using a quine, and then submits that copy to the decider
for analysis
the thing u don't understand polcott is that paradoxical machines do not
exist by anyone's choice
They don't exist, in the everyday meaning of the word exist. In the
sense of being objects of a formal system we never make one. We rely on
a nontology to fool ourselves.
On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
If the starting assumption is not nonsensical already ...
On 11/8/2026 8:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
An INPUT to a function instance that CALLS this same function
instance is like a guy that is his own father.
On Sun, 8 Nov 2026 20:46:19 -0600, olcott wrote:The specified counter-example that the HP proof depends on
On 11/8/2026 8:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
An INPUT to a function instance that CALLS this same function
instance is like a guy that is his own father.
So what?
On Mon, 9 Nov 2026 08:54:11 +0000, Tristan Wibberley wrote:
On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
If the starting assumption is not nonsensical already ...
rCLNonsensicalrCY is not a concept that enters into formal logical
arguments.
For example, the square root of 2 can be proven to not be
representable as a ratio of two integers.
The term coined for this new
sort of number was rCLirrationalrCY. It could just have easily been rCLnonsensicalrCY. But calling them rCLnonsensical numbersrCY doesnrCOt make them any less real.
On 11/9/2026 2:55 PM, Lawrence DrCOOliveiro wrote:
On Mon, 9 Nov 2026 08:54:11 +0000, Tristan Wibberley wrote:
On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
If the starting assumption is not nonsensical already ...
rCLNonsensicalrCY is not a concept that enters into formal logical
arguments.
For example, the square root of 2 can be proven to not be
representable as a ratio of two integers.
Infinite convergents of continued fractions are pretty fun.
The term coined for this new
sort of number was rCLirrationalrCY. It could just have easily been
rCLnonsensicalrCY. But calling them rCLnonsensical numbersrCY doesnrCOt make >> them any less real.
On 11/9/2026 5:01 PM, Lawrence DrCOOliveiro wrote:
The specified counter-example that the HP proof depends on an INPUT
On Sun, 8 Nov 2026 20:46:19 -0600, olcott wrote:
On 11/8/2026 8:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
An INPUT to a function instance that CALLS this same function
instance is like a guy that is his own father.
So what?
to a function that CALLS this same function cannot coherently exist
even as an abstract object.
On Mon, 9 Nov 2026 17:18:45 -0600, olcott wrote:
On 11/9/2026 5:01 PM, Lawrence DrCOOliveiro wrote:
The specified counter-example that the HP proof depends on an INPUT
On Sun, 8 Nov 2026 20:46:19 -0600, olcott wrote:
On 11/8/2026 8:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
An INPUT to a function instance that CALLS this same function
instance is like a guy that is his own father.
So what?
to a function that CALLS this same function cannot coherently exist
even as an abstract object.
Trivial example in Python:
def f(f) :
return f
print(f(f))
It exists as a concrete object. Try it on your own computer if you
donrCOt believe me.
Actual run:
Python 3.14.9 (main, Oct 23 2026, 16:12:59) [GCC 16.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def f(f) :
... return f
...
>>> print(f(f) is f)
True
On 11/9/2026 3:00 AM, Mikko wrote:
On 06/11/2026 04:53, olcott wrote:
[an input that does the opposite of
-a-awhat one particular decider outputs]
-a-ais inherently incoherent.
If it gets a return value to do the opposite of
then it is the caller of the decider and not
the input to this same decider. If it is the
input to a decider then it is not the caller
of this same decider. One can be a father or
a son one can fill both roles for the same person.
One cannot be onerCOs own father.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
That is a straw man deception. What you are talking about is not
the halting theorem. In particular, the identified incoherence
is not in the halting theorem.
An INPUT to a function instance
that CALLS this same function instance
is like a guy that is his own father.
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof works: if the starting assumption leads to a nonsensical conclusion,
and no other fault in the logic can be found, then the assumption (in
this case, that you *can* create a decision procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
On Mon, 9 Nov 2026 08:54:11 +0000, Tristan Wibberley wrote:
On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
If the starting assumption is not nonsensical already ...
rCLNonsensicalrCY is not a concept that enters into formal logical
arguments.
For example, the square root of 2 can be proven to not be
representable as a ratio of two integers. The term coined for this new
sort of number was rCLirrationalrCY. It could just have easily been rCLnonsensicalrCY. But calling them rCLnonsensical numbersrCY doesnrCOt make them any less real.
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical conclusion,
and no other fault in the logic can be found, then the assumption (in
this case, that you *can* create a decision procedure for the halting
problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur",
that any statement is only true or false and no third ground,
and, "ex falso quodlibet", out of fallacy anything, with
regards "tertium datur", there is a third ground, and "ex falso
nihilum", a fallacy was already not true, about logical contradiction,
and various accounts of _inductive_ inference, as for monotonicity
and entailment what follows, about the "riddles" or "fallacies" or "paradoxes" of inductive inference, and the "invincible ignorance
of inductive inference", when it's _deductive_ inference that provides grounds for the account, and when that's the only way, that
"super-classical reasoning is involved". Then, "classical logic", isn't necessarily the 20'th century account with "quasi-modal logic"
and "material implication", like after Russell since Philo and
Plotinus, since "classical logic" is modal or since Aristotle then
Chrysippus the "moods" the "mood-al", making a modal, and thusly
temporal, then "relevance" logic, about reasons why then:
some "constructivists", in mathematics or logic, they don't
accept "proof by contradiction", since, it's just less wrong.
About "reductio ad absurdam" then "reduction ad infinitum", are
two different accounts about the same thing, one "away" and the
other "to" somewhere, away from zero or to infinity. Then, the
"double reductio" is an account of mutual and complementary
considerations, since induction by itself is "weak induction",
what must be so to make "strong induction", which reasoners about
reason over time often give to the "a priori", yet that often enough
since "Zeno's classical expositions of the super-classical", start
with things like the geometric series.
So, it's not just that "no other flaw in the logic may be found",
it's also that the stipulations also can't be wrong, then that's
a chicken-and-egg scenario of "ad absurdam", then for the "ab absurdam".
Surds are forms. So, reasoning is its own forms or surds, then
the "ab-surd" usually means that there's a real true absolute
world of objective forms, then reasoning is subjective or relative
while on its own account objective to the individual, thus that
the "ab-surd" is as "from the forms", then that usually enough
the "ad absurdam" is "to-the out-of (the forms)", while "ab absurdam"
is rather sort of what accounts "arriving-from (the forms)".
Then the Halting Problem or Branching Problem, those being considered equivalent in lots of ways, besides that somebody like Turing says
"well, you've heard of Turing tapes, yet in the real world nothing
is finitistic it's continuous", then about Boolos & Jeffreys or the
usual account of ordinary theory's approach to the _infinite_ since
the problems about these are what happens in _the infinite_, well,
it's sad since they have "non-classical logic", which if you bother
to go looking sees murmured "well, there's contradictions, ...",
instead of the "extra-ordinary", since _infinity_ isn't _ordinary_
besides that it's "axiomatized" or _stipulated_ so, that infinity
is _extra_ ordinary and thusly lives under _super-classical_ reasoning.
Anyways the polcott is kind of like a howler-troll, where a mathematical "howler" is some broken thing like "1 + 1 = 11",
though that could be in unary, then being a troll and being
inconstant, and not keeping definitions, then one can point out
that the usual "classical logic" of the 20'th century is also,
since it claims "entailment" and "monotonicity" as maintaining
reason, yet, quasi-modal logic has "see rule 1" and "last wins",
like for example the proof-by-contradiction bit there.
The problems with proof-by-contradiction after the problems of
induction, then then for the reduction and double-reductio about
them, still has that the contrapositive is always so, i.e. that
"(A -> B) -> (not B -> not A)", that _direct_ implication with
causality is always so, there's that "material implication" with
"false antecedent" or "false consequent", it's false.
So, anyways, for Halting Theorem to be consistent, then models of
arithmetic need to be coherent, and when there's not a standard
model of arithmetic at all, only fragments or extensions, then
about at least three "laws of large numbers", it's super-classical
logic not non-classical logic that needs make it reasonable, and so.
On Mon, 9 Nov 2026 08:54:11 +0000, Tristan Wibberley wrote:
On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
If the starting assumption is not nonsensical already ...
rCLNonsensicalrCY is not a concept that enters into formal logical
arguments.
...On 09/11/2026 02:43, Lawrence DrCOOliveiro wrote:
--... if the starting assumption leads to a nonsensical
conclusion ...
On Sun, 8 Nov 2026 20:46:19 -0600, olcott wrote:
On 11/8/2026 8:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY?
An INPUT to a function instance that CALLS this same function
instance is like a guy that is his own father.
So what? In many common programming languages, functions are indeed rCLfirst-class objectsrCY, which means they can be passed to functions as arguments, and returned as results.
There is a whole mathematical
theory (++-calculus) that makes heavy use of this sort of thing. Which
is of course computationally equivalent to Turing machines anyway.
You seem to be obsessed with expressing everything in C that compiles
to x86 code. If you take a step back from that and consider other, higher-level languages, you might discover other interesting concepts,
like the Y-combinator <https://www.playfulpython.com/y-combinator-in-python/>.
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that
any statement is only true or false and no third ground ...
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that
any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there
*was* a third ground ...
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that
any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there
*was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof >>>>> works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the
assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that
any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there
*was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
On 11/14/2026 3:09 AM, Mikko wrote:
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the >>>>>> assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that >>>>> any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there
*was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that
unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
BZZZT Wrong Answer.
The the directed graphs of the evaluation sequence
of the formalized Liar Paradox in Prolog has a cycle
thus is stuck in infinite recursion.
Outline of a Theory of Truth
Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Kripke comes up with the exact same truth value
of "undefined" as my above Prolog code.
Proof Theoretic Semantics also derives this
same result.
Le 14/11/2026 |a 15:16, olcott a |-crit :
On 11/14/2026 3:09 AM, Mikko wrote:
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider >>>>>>>> outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the >>>>>>> assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that >>>>>> any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there >>>>> *was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that
unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
BZZZT Wrong Answer.
The the directed graphs of the evaluation sequence
of the formalized Liar Paradox in Prolog has a cycle
thus is stuck in infinite recursion.
Outline of a Theory of Truth
Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/
files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Kripke comes up with the exact same truth value
of "undefined" as my above Prolog code.
Proof Theoretic Semantics also derives this
same result.
Peter,
-a-a "BZZZT Wrong Answer."
No, Peter. Mikko's answer is EXACTLY correct.
-a-a "?- unify_with_occurs_check(LP, not(true(LP))).
-a-a-a false."
This does NOT assign the truth value "undefined" to the Liar Paradox.
It means that the UNIFICATION FAILED.
Specifically, the occurs check prevents a variable from being unified
with a term containing that same variable.
THAT IS A PROPERTY OF TERM UNIFICATION.
NOT A THEORY OF TRUTH.
Your first query:
-a-a LP = not(true(LP)).
may construct a cyclic term in Prolog implementations supporting
rational trees.
Your second query rejects that cyclic construction.
NEITHER QUERY EVALUATES THE TRUTH OF THE LIAR SENTENCE.
And neither establishes that a recursive computation must run forever.
-a-a "Kripke comes up with the exact same truth value
-a-a-a of 'undefined' as my above Prolog code."
NO.
Kripke's 1975 theory constructs partial interpretations of a truth predicate. In the relevant fixed-point semantics, the Liar sentence is ungrounded and receives no classical truth value.
That is a SEMANTIC result.
Prolog's `false` is a COMPUTATIONAL result: a particular unification
goal failed.
THE TWO ARE NOT THE SAME.--
You have confused:
1. Failure of unification.
2. Nontermination of recursive evaluation.
3. Undefinedness in a partial truth semantics.
These are THREE DIFFERENT CONCEPTS.
And even if you correctly implemented Kripke's theory in Prolog, that
would tell us NOTHING about the existence of a universal halting decider.
The diagonal program is a perfectly legitimate computation.
It does not become an invalid program merely because its behavior contradicts the prediction of a hypothetical total halting decider.
That contradiction refutes the hypothetical decider.
NOT THE PROGRAM.
On 11/14/2026 8:26 AM, Python wrote:
Le 14/11/2026 |a 15:16, olcott a |-crit :
On 11/14/2026 3:09 AM, Mikko wrote:
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider >>>>>>>>> outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the >>>>>>>> assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that >>>>>>> any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there >>>>>> *was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that
unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
BZZZT Wrong Answer.
The the directed graphs of the evaluation sequence
of the formalized Liar Paradox in Prolog has a cycle
thus is stuck in infinite recursion.
Outline of a Theory of Truth
Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/
files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Kripke comes up with the exact same truth value
of "undefined" as my above Prolog code.
Proof Theoretic Semantics also derives this
same result.
Peter,
-a-a "BZZZT Wrong Answer."
No, Peter. Mikko's answer is EXACTLY correct.
-a-a "?- unify_with_occurs_check(LP, not(true(LP))).
-a-a-a false."
This does NOT assign the truth value "undefined" to the Liar Paradox.
It means that the UNIFICATION FAILED.
because assigning a truth value to LP is impossible
because the directed graph of the evaluation sequence
of LP contains a cycle.
At a shallow depth of understanding you would seem to
be correct. When we go deeper then non-so-much.
Specifically, the occurs check prevents a variable from being unified
with a term containing that same variable.
THAT IS A PROPERTY OF TERM UNIFICATION.
NOT A THEORY OF TRUTH.
Your first query:
-a-a LP = not(true(LP)).
Minimal Type Theory does this same thing. https://philarchive.org/archive/PETMTT-4v2
LP := ~True(LP)
resolves to ~True(~True(~True(~True(~True(~True(...))))))
may construct a cyclic term in Prolog implementations supporting
rational trees.
Your second query rejects that cyclic construction.
NEITHER QUERY EVALUATES THE TRUTH OF THE LIAR SENTENCE.
and likewise the square root of a dead cat is never found.
And neither establishes that a recursive computation must run forever.
-a-a "Kripke comes up with the exact same truth value
-a-a-a of 'undefined' as my above Prolog code."
NO.
Kripke's 1975 theory constructs partial interpretations of a truth
predicate. In the relevant fixed-point semantics, the Liar sentence is
ungrounded and receives no classical truth value.
That is a SEMANTIC result.
The same way the Proof Theoretic Semantics works.
"true on the basis of meaning expressed in language"
requires semantic inference steps specified syntactically.
Prolog's `false` is a COMPUTATIONAL result: a particular unification
goal failed.
and is a Semantic result within Proof Theoretic Semantics.
THE TWO ARE NOT THE SAME.
You have confused:
1. Failure of unification.
2. Nontermination of recursive evaluation.
3. Undefinedness in a partial truth semantics.
These are THREE DIFFERENT CONCEPTS.
And even if you correctly implemented Kripke's theory in Prolog, that
would tell us NOTHING about the existence of a universal halting decider.
The diagonal program is a perfectly legitimate computation.
It does not become an invalid program merely because its behavior
contradicts the prediction of a hypothetical total halting decider.
That contradiction refutes the hypothetical decider.
NOT THE PROGRAM.
Le 14/11/2026 |a 15:47, olcott a |-crit :
On 11/14/2026 8:26 AM, Python wrote:
Le 14/11/2026 |a 15:16, olcott a |-crit :
On 11/14/2026 3:09 AM, Mikko wrote:
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider >>>>>>>>>> outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the >>>>>>>>> proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the >>>>>>>>> assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", >>>>>>>> that
any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there >>>>>>> *was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that
unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
BZZZT Wrong Answer.
The the directed graphs of the evaluation sequence
of the formalized Liar Paradox in Prolog has a cycle
thus is stuck in infinite recursion.
Outline of a Theory of Truth
Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/
files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Kripke comes up with the exact same truth value
of "undefined" as my above Prolog code.
Proof Theoretic Semantics also derives this
same result.
Peter,
-a-a-a "BZZZT Wrong Answer."
No, Peter. Mikko's answer is EXACTLY correct.
-a-a-a "?- unify_with_occurs_check(LP, not(true(LP))).
-a-a-a-a false."
This does NOT assign the truth value "undefined" to the Liar Paradox.
It means that the UNIFICATION FAILED.
because assigning a truth value to LP is impossible
because the directed graph of the evaluation sequence
of LP contains a cycle.
At a shallow depth of understanding you would seem to
be correct. When we go deeper then non-so-much.
Specifically, the occurs check prevents a variable from being unified
with a term containing that same variable.
THAT IS A PROPERTY OF TERM UNIFICATION.
NOT A THEORY OF TRUTH.
Your first query:
-a-a-a LP = not(true(LP)).
Minimal Type Theory does this same thing.
https://philarchive.org/archive/PETMTT-4v2
LP := ~True(LP)
resolves to ~True(~True(~True(~True(~True(~True(...))))))
may construct a cyclic term in Prolog implementations supporting
rational trees.
Your second query rejects that cyclic construction.
NEITHER QUERY EVALUATES THE TRUTH OF THE LIAR SENTENCE.
and likewise the square root of a dead cat is never found.
And neither establishes that a recursive computation must run forever.
-a-a-a "Kripke comes up with the exact same truth value
-a-a-a-a of 'undefined' as my above Prolog code."
NO.
Kripke's 1975 theory constructs partial interpretations of a truth
predicate. In the relevant fixed-point semantics, the Liar sentence
is ungrounded and receives no classical truth value.
That is a SEMANTIC result.
The same way the Proof Theoretic Semantics works.
"true on the basis of meaning expressed in language"
requires semantic inference steps specified syntactically.
Prolog's `false` is a COMPUTATIONAL result: a particular unification
goal failed.
and is a Semantic result within Proof Theoretic Semantics.
THE TWO ARE NOT THE SAME.
You have confused:
1. Failure of unification.
2. Nontermination of recursive evaluation.
3. Undefinedness in a partial truth semantics.
These are THREE DIFFERENT CONCEPTS.
And even if you correctly implemented Kripke's theory in Prolog, that
would tell us NOTHING about the existence of a universal halting
decider.
The diagonal program is a perfectly legitimate computation.
It does not become an invalid program merely because its behavior
contradicts the prediction of a hypothetical total halting decider.
That contradiction refutes the hypothetical decider.
NOT THE PROGRAM.
Peter,
-a-a "because assigning a truth value to LP is impossible
-a-a-a because the directed graph of the evaluation sequence
-a-a-a of LP contains a cycle."
NO.
You are STILL confusing a cyclic term with a semantic paradox.
Try this:--
-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a false.
WHERE IS THE LIAR PARADOX?
WHERE IS THE TRUTH PREDICATE?
WHERE IS THE SEMANTIC CONTRADICTION?
NOWHERE.
The unification fails because X occurs inside f(X).
THAT IS ALL.
Your occurs check does not know whether `f` means truth, negation,
addition, or a dead cat.
It simply checks the structure of a term.
-a-a "LP := ~True(LP)
-a-a-a resolves to ~True(~True(~True(...)))"
Writing an infinite expansion does not establish a semantic interpretation.
Kripke's construction involves a truth predicate, a partial valuation,
and a fixed-point construction.
It does not consist of detecting cycles in arbitrary Prolog terms.
Indeed, cyclic dependencies are not automatically semantic contradictions.
For example, a positive self-referential truth sentence can remain ungrounded without asserting its own falsity.
THE STRUCTURE OF THE DEPENDENCY ALONE DOES NOT DETERMINE ITS TRUTH VALUE.
-a-a "and is a Semantic result within Proof Theoretic Semantics."
THEN SHOW THE SEMANTICS.
Define your interpretation function.
Define your consequence relation.
Show the inference rule that turns the failure of:
-a-a unify_with_occurs_check(X, f(X))
into a statement about truth.
You cannot simply label an operational failure "semantic" and pretend
that you have proved something about Kripke's theory.
And none of this rescues your attack on the Halting Theorem.
The diagonal argument does not ask a halting decider to assign a truth
value to the Liar Paradox.
It assumes a total computable function H that correctly decides whether programs halt.
It then constructs a program D that behaves contrary to H's prediction.
If H says D halts, D loops.
If H says D does not halt, D halts.
If H refuses to answer, H IS NOT TOTAL.
THOSE ARE THE POSSIBILITIES YOU KEEP REFUSING TO ADDRESS.
A Prolog occurs check cannot make the diagonal program disappear.
And citing Kripke does not turn a failed unification into a refutation
of Turing.
Peter,
-a-a "It never reaches the paradoxical code."
WHAT PARADOXICAL CODE?
Look at the actual query:
-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a false.
There is no paradox.
There is no truth predicate.
There is no recursive evaluation.
There is no "paradoxical code" to reach.
The unification algorithm simply detects that X occurs inside f(X) and fails.
END OF STORY.
Now replace f(X) with not(true(X)):
-a-a ?- unify_with_occurs_check(X, not(true(X))).
-a-a false.
THE SAME THING HAPPENS.
Not because Prolog has discovered the Liar Paradox.
Not because it has computed an undefined truth value.
Not because it has detected an infinite execution.
But because THE OCCURS CHECK REJECTS CYCLIC UNIFICATION.
You are assigning philosophical significance to an operation that does--
not even inspect the meaning of your predicate names.
And your claim that the computation "never reaches the paradoxical code"
is especially revealing.
THERE IS NO SUCH CODE IN THE QUERY.
You have constructed a term, not implemented a truth evaluator.
If you want to demonstrate a semantic result, DEFINE THE SEMANTICS.
If you want to demonstrate infinite recursion, SHOW THE RECURSIVE EVALUATION.
If you want to refute the Halting Theorem, IDENTIFY THE INVALID STEP IN
ITS DIAGONAL PROOF.
So far, you have done none of these things.
You have merely confused three different problems and declared victory
over all of them.
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the
proof works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then
the assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur",
that any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that
there *was* a third ground ...
[irrelevancies deleted]
On 11/14/2026 3:09 AM, Mikko wrote:
On 14/11/2026 05:50, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the proof
works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then the >>>>>> assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur", that >>>>> any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that there
*was* a third ground ...
?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.
What truth value does that Prolog code determine
that its formalized Liar Paradox is grounded it?
(Quick answer Kripke 1975 ungrounded)
Prolog does not know or care about Liar's Paradox. The truth that
unify_with_occurs_check/2 detects but =/2 may fail to detect is
that the unification of LP with not(true(LP)) creates a cyclic
data structure.
BZZZT Wrong Answer.
The the directed graphs of the evaluation sequence
of the formalized Liar Paradox in Prolog has a cycle
thus is stuck in infinite recursion.
On Fri, 13 Nov 2026 21:50:57 -0600, olcott wrote:
On 11/13/2026 9:25 PM, Lawrence DrCOOliveiro wrote:
On Wed, 11 Nov 2026 07:27:41 -0800, Ross Finlayson wrote:
On 11/08/2026 06:43 PM, Lawrence DrCOOliveiro wrote:
On Thu, 5 Nov 2026 20:53:26 -0600, olcott wrote:
[an input that does the opposite of what one particular decider
outputs] is inherently incoherent.
You mean rCLlogical contradictionrCY? Of course -- thatrCOs how the
proof works: if the starting assumption leads to a nonsensical
conclusion, and no other fault in the logic can be found, then
the assumption (in this case, that you *can* create a decision
procedure for the halting problem) must be wrong.
This is the essence of a rCLreductio ad absurdumrCY proof.
Some care must be taken in reasoning about "tertium non datur",
that any statement is only true or false and no third ground ...
Even if that were not true, it would not logically follow that
there *was* a third ground ...
[irrelevancies deleted]
What Mr Finlayson and I were discussing might better be known as rCLthe
Law of the Excluded MiddlerCY. He was trying to suggest that, because a rCLreductio ad absurdumrCY argument depends on that law, then if the law
were not valid, that would invalidate the rCLreductio ad absurdumrCY argument.
I was merely pointing out that that does not necessarily follow.
On 11/14/2026 11:03 AM, Python wrote:
Peter,
-a-a "It never reaches the paradoxical code."
WHAT PARADOXICAL CODE?
Look at the actual query:
-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a false.
There is no paradox.
There is no truth predicate.
There is no recursive evaluation.
There is no "paradoxical code" to reach.
The unification algorithm simply detects that X occurs inside f(X) and
fails.
END OF STORY.
Now replace f(X) with not(true(X)):
-a-a ?- unify_with_occurs_check(X, not(true(X))).
-a-a false.
THE SAME THING HAPPENS.
Not because Prolog has discovered the Liar Paradox.
Not because it has computed an undefined truth value.
Not because it has detected an infinite execution.
But because THE OCCURS CHECK REJECTS CYCLIC UNIFICATION.
Bingo !!! Do you know the underlying details of this?
You are assigning philosophical significance to an operation that does
not even inspect the meaning of your predicate names.
And your claim that the computation "never reaches the paradoxical code"
is especially revealing.
THERE IS NO SUCH CODE IN THE QUERY.
You have constructed a term, not implemented a truth evaluator.
If you want to demonstrate a semantic result, DEFINE THE SEMANTICS.
If you want to demonstrate infinite recursion, SHOW THE RECURSIVE
EVALUATION.
If you want to refute the Halting Theorem, IDENTIFY THE INVALID STEP IN
ITS DIAGONAL PROOF.
So far, you have done none of these things.
You have merely confused three different problems and declared victory
over all of them.
Le 15/11/2026 |a 04:21, olcott a |-crit :
On 11/14/2026 11:03 AM, Python wrote:
Peter,
-a-a-a "It never reaches the paradoxical code."
WHAT PARADOXICAL CODE?
Look at the actual query:
-a-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a-a false.
There is no paradox.
There is no truth predicate.
There is no recursive evaluation.
There is no "paradoxical code" to reach.
The unification algorithm simply detects that X occurs inside f(X)
and fails.
END OF STORY.
Now replace f(X) with not(true(X)):
-a-a-a ?- unify_with_occurs_check(X, not(true(X))).
-a-a-a false.
THE SAME THING HAPPENS.
Not because Prolog has discovered the Liar Paradox.
Not because it has computed an undefined truth value.
Not because it has detected an infinite execution.
But because THE OCCURS CHECK REJECTS CYCLIC UNIFICATION.
Bingo !!! Do you know the underlying details of this?
You are assigning philosophical significance to an operation that
does not even inspect the meaning of your predicate names.
And your claim that the computation "never reaches the paradoxical
code" is especially revealing.
THERE IS NO SUCH CODE IN THE QUERY.
You have constructed a term, not implemented a truth evaluator.
If you want to demonstrate a semantic result, DEFINE THE SEMANTICS.
If you want to demonstrate infinite recursion, SHOW THE RECURSIVE
EVALUATION.
If you want to refute the Halting Theorem, IDENTIFY THE INVALID STEP
IN ITS DIAGONAL PROOF.
So far, you have done none of these things.
You have merely confused three different problems and declared
victory over all of them.
Peter,
-a-a "Bingo !!! Do you know the underlying details of this?"
YES, PETER.
DO YOU?
The occurs check is a standard part of first-order term unification.
When attempting to unify a variable X with a term t, it checks whether X already occurs within t.
If it does, the unification is rejected, because no finite first-order
term can satisfy that substitution.
For example:
-a-a unify_with_occurs_check(X, f(X))
fails.
So does:
-a-a unify_with_occurs_check(X, not(true(X)))
And so does:
-a-a unify_with_occurs_check(X, banana(X))
SAME ALGORITHM.
SAME RESULT.
NO SEMANTIC INTERPRETATION REQUIRED.
Now consider:
-a-a unify_with_occurs_check(X, f(Y))
This succeeds, provided X and Y are distinct unbound variables.
The algorithm is examining TERM STRUCTURE.
It is not deciding whether f is true, false, paradoxical, or meaningful.
And here is the crucial distinction:
The occurs check does not detect infinite recursion in a program.
It prevents the construction of a cyclic substitution in finite-term unification.
Those are NOT the same problem.
So what exactly are you celebrating?
That Prolog implements an occurs check?
WE ALREADY KNEW THAT.
That a self-referential term may be rejected by a particular unification algorithm?
WE ALREADY KNEW THAT TOO.
That this somehow invalidates the diagonal proof of the Halting Theorem?
THEN PROVE THE CONNECTION.
Because a diagonal program is not a cyclic first-order term.
And rejecting cyclic terms does not establish that a universal halting decider exists.
Your "Bingo" is not a mathematical argument.
It's the sound of someone recognizing a familiar word without
understanding what it proves.
On 11/15/2026 5:36 AM, Python wrote:
Le 15/11/2026 |a 04:21, olcott a |-crit :
On 11/14/2026 11:03 AM, Python wrote:
Peter,
-a-a-a "It never reaches the paradoxical code."
WHAT PARADOXICAL CODE?
Look at the actual query:
-a-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a-a false.
There is no paradox.
There is no truth predicate.
There is no recursive evaluation.
There is no "paradoxical code" to reach.
The unification algorithm simply detects that X occurs inside f(X)
and fails.
END OF STORY.
Now replace f(X) with not(true(X)):
-a-a-a ?- unify_with_occurs_check(X, not(true(X))).
-a-a-a false.
THE SAME THING HAPPENS.
Not because Prolog has discovered the Liar Paradox.
Not because it has computed an undefined truth value.
Not because it has detected an infinite execution.
But because THE OCCURS CHECK REJECTS CYCLIC UNIFICATION.
Bingo !!! Do you know the underlying details of this?
You are assigning philosophical significance to an operation that
does not even inspect the meaning of your predicate names.
And your claim that the computation "never reaches the paradoxical
code" is especially revealing.
THERE IS NO SUCH CODE IN THE QUERY.
You have constructed a term, not implemented a truth evaluator.
If you want to demonstrate a semantic result, DEFINE THE SEMANTICS.
If you want to demonstrate infinite recursion, SHOW THE RECURSIVE
EVALUATION.
If you want to refute the Halting Theorem, IDENTIFY THE INVALID STEP
IN ITS DIAGONAL PROOF.
So far, you have done none of these things.
You have merely confused three different problems and declared
victory over all of them.
Peter,
-a-a "Bingo !!! Do you know the underlying details of this?"
YES, PETER.
DO YOU?
The occurs check is a standard part of first-order term unification.
When attempting to unify a variable X with a term t, it checks whether X
already occurs within t.
If it does, the unification is rejected, because no finite first-order
term can satisfy that substitution.
For example:
-a-a unify_with_occurs_check(X, f(X))
fails.
So does:
-a-a unify_with_occurs_check(X, not(true(X)))
And so does:
-a-a unify_with_occurs_check(X, banana(X))
SAME ALGORITHM.
SAME RESULT.
NO SEMANTIC INTERPRETATION REQUIRED.
Now consider:
-a-a unify_with_occurs_check(X, f(Y))
This succeeds, provided X and Y are distinct unbound variables.
The algorithm is examining TERM STRUCTURE.
It is not deciding whether f is true, false, paradoxical, or meaningful.
And here is the crucial distinction:
The occurs check does not detect infinite recursion in a program.
It prevents the construction of a cyclic substitution in finite-term
unification.
Those are NOT the same problem.
So what exactly are you celebrating?
That Prolog implements an occurs check?
WE ALREADY KNEW THAT.
That a self-referential term may be rejected by a particular unification
algorithm?
WE ALREADY KNEW THAT TOO.
That this somehow invalidates the diagonal proof of the Halting Theorem?
THEN PROVE THE CONNECTION.
Because a diagonal program is not a cyclic first-order term.
And rejecting cyclic terms does not establish that a universal halting
decider exists.
Your "Bingo" is not a mathematical argument.
It's the sound of someone recognizing a familiar word without
understanding what it proves.
Like my Minimal Type Theory unify_with_occurs_check()
detects a cycle in the directed graph of the
evaluation sequence.
LP := ~True(LP) which expands into:
~True(~True(~True(~True(...)))) infinite recursion. https://philarchive.org/archive/PETMTT-4v8
Cannot possibly get to a truth value is what
Saul Kripke meant by assigning ungrounded to it.
Outline of a Theory of Truth --- Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716.
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Le 15/11/2026 |a 14:23, olcott a |-crit :
On 11/15/2026 5:36 AM, Python wrote:
Le 15/11/2026 |a 04:21, olcott a |-crit :
On 11/14/2026 11:03 AM, Python wrote:
Peter,
-a-a-a "It never reaches the paradoxical code."
WHAT PARADOXICAL CODE?
Look at the actual query:
-a-a-a ?- unify_with_occurs_check(X, f(X)).
-a-a-a false.
There is no paradox.
There is no truth predicate.
There is no recursive evaluation.
There is no "paradoxical code" to reach.
The unification algorithm simply detects that X occurs inside f(X)
and fails.
END OF STORY.
Now replace f(X) with not(true(X)):
-a-a-a ?- unify_with_occurs_check(X, not(true(X))).
-a-a-a false.
THE SAME THING HAPPENS.
Not because Prolog has discovered the Liar Paradox.
Not because it has computed an undefined truth value.
Not because it has detected an infinite execution.
But because THE OCCURS CHECK REJECTS CYCLIC UNIFICATION.
Bingo !!! Do you know the underlying details of this?
You are assigning philosophical significance to an operation that
does not even inspect the meaning of your predicate names.
And your claim that the computation "never reaches the paradoxical
code" is especially revealing.
THERE IS NO SUCH CODE IN THE QUERY.
You have constructed a term, not implemented a truth evaluator.
If you want to demonstrate a semantic result, DEFINE THE SEMANTICS.
If you want to demonstrate infinite recursion, SHOW THE RECURSIVE
EVALUATION.
If you want to refute the Halting Theorem, IDENTIFY THE INVALID
STEP IN ITS DIAGONAL PROOF.
So far, you have done none of these things.
You have merely confused three different problems and declared
victory over all of them.
Peter,
-a-a-a "Bingo !!! Do you know the underlying details of this?"
YES, PETER.
DO YOU?
The occurs check is a standard part of first-order term unification.
When attempting to unify a variable X with a term t, it checks
whether X already occurs within t.
If it does, the unification is rejected, because no finite first-
order term can satisfy that substitution.
For example:
-a-a-a unify_with_occurs_check(X, f(X))
fails.
So does:
-a-a-a unify_with_occurs_check(X, not(true(X)))
And so does:
-a-a-a unify_with_occurs_check(X, banana(X))
SAME ALGORITHM.
SAME RESULT.
NO SEMANTIC INTERPRETATION REQUIRED.
Now consider:
-a-a-a unify_with_occurs_check(X, f(Y))
This succeeds, provided X and Y are distinct unbound variables.
The algorithm is examining TERM STRUCTURE.
It is not deciding whether f is true, false, paradoxical, or meaningful. >>>
And here is the crucial distinction:
The occurs check does not detect infinite recursion in a program.
It prevents the construction of a cyclic substitution in finite-term
unification.
Those are NOT the same problem.
So what exactly are you celebrating?
That Prolog implements an occurs check?
WE ALREADY KNEW THAT.
That a self-referential term may be rejected by a particular
unification algorithm?
WE ALREADY KNEW THAT TOO.
That this somehow invalidates the diagonal proof of the Halting Theorem? >>>
THEN PROVE THE CONNECTION.
Because a diagonal program is not a cyclic first-order term.
And rejecting cyclic terms does not establish that a universal
halting decider exists.
Your "Bingo" is not a mathematical argument.
It's the sound of someone recognizing a familiar word without
understanding what it proves.
Like my Minimal Type Theory unify_with_occurs_check()
detects a cycle in the directed graph of the
evaluation sequence.
LP := ~True(LP) which expands into:
~True(~True(~True(~True(...)))) infinite recursion.
https://philarchive.org/archive/PETMTT-4v8
Cannot possibly get to a truth value is what
Saul Kripke meant by assigning ungrounded to it.
Outline of a Theory of Truth --- Saul Kripke
The Journal of Philosophy, Vol. 72, No. 19,
Seventy-Second Annual Meeting American
Philosophical Association, Eastern Division.
(Nov. 6, 1975), pp. 690-716.
https://files.commons.gc.cuny.edu/wp-content/blogs.dir/1358/
files/2019/04/Outline-of-a-Theory-of-Truth.pdf
Peter,
-a-a "Like my Minimal Type Theory unify_with_occurs_check()
-a-a-a detects a cycle in the directed graph of the
-a-a-a evaluation sequence."
YOU ARE STILL CONFUSING THREE DIFFERENT THINGS.
1. A cyclic term.
2. A cyclic dependency between propositions.
3. An infinite computational evaluation.
THEY ARE NOT EQUIVALENT.
-a-a "LP := ~True(LP) which expands into:
-a-a-a ~True(~True(~True(~True(...)))) infinite recursion."
No.
That is an infinite syntactic unfolding.
It is not, by itself, an execution trace of a truth-evaluation algorithm.
And detecting a cycle does not automatically establish nontermination.
Consider the ordinary recursive function:
-a-a int f(int n) {
-a-a-a-a-a-a if (n == 0) return 0;
-a-a-a-a-a-a return f(n - 1);
-a-a }
Its call graph contains a cycle.
YET IT TERMINATES FOR EVERY NONNEGATIVE INTEGER INPUT.
A cycle in a dependency graph does not prove that evaluation runs forever.
Now consider the sentence:
-a-a P <-> True("P")
This sentence refers to its own truth, WITHOUT NEGATION.
Its dependency graph contains exactly the same kind of self-reference as your Liar sentence.
But its semantic behavior is different.
In Kripke's least fixed-point construction, both can remain ungrounded.
However, the positive truth-teller can receive TRUE or FALSE in suitable other fixed points, whereas the Liar cannot receive either classical
truth value in a consistent fixed point.
SAME SELF-REFERENCE.
DIFFERENT SEMANTIC CONSTRAINTS.
Therefore the existence of a cycle is NOT sufficient to determine the semantic status of a sentence.
-a-a "Cannot possibly get to a truth value is what
-a-a-a Saul Kripke meant by assigning ungrounded to it."
NO.
Kripke's notion of groundedness is defined through a semantic fixed-
point construction using a partial truth predicate.
It is not defined by whether a Prolog unification algorithm detects a
cyclic term.
The Liar remains undefined
in the relevant fixed-point semantics because
neither assigning it TRUE nor assigning it FALSE is consistent with its truth conditions.
THAT IS A SEMANTIC FACT.
Your occurs check, meanwhile, rejects:
-a-a X = banana(X)
just as readily as:
-a-a X = not(true(X))
IT HAS NO IDEA WHAT "TRUE" OR "BANANA" MEANS.
So here is the question:
Does your algorithm distinguish the Liar from the positive Truth-Teller?
If so, SHOW THE SEMANTIC RULES THAT MAKE THE DISTINCTION.
If not, you have not implemented Kripke's theory.
You have implemented a cycle detector.
And once again, NONE OF THIS REFUTES THE HALTING THEOREM.--
A diagonal program is a valid computation, not a malformed cyclic Prolog term.
You cannot make undecidability disappear by confusing self-reference
with invalid syntax.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 58:39:10 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
4 files (9,632K bytes) |
| Messages: | 285,989 |