A well-known brain­teaser asks about the truth of the state­ment “this state­ment is false”. My pre­vi­ous ar­ti­cle on this topic, out­lined com­mon ap­proaches to this prob­lem and then ar­gued that we should con­ceive of two dis­tinct kinds of truth:

• State­ments about the world, where as per Tarski there is a nat­u­ral in­ter­pre­ta­tion: “Snow is white” is true iff and only iff “Snow is white”

• Log­i­cal/​Math­e­mat­i­cal state­ments, where the no­tion truth is con­structed to give us a con­ve­nient way of talk­ing about our rules of in­fer­ence within a par­tic­u­lar sys­tem that nor­mally ex­cludes self-refer­en­tial statements

I should add that some state­ments can only be defined us­ing a com­bined no­tion of truth, ie. “The car is red and 1+1=2”.

My point was that if we chose to ex­tent log­i­cal/​math­e­mat­i­cal state­ments out­side of their usual bound, we shouldn’t be sur­prised that it breaks down and that if we choose to patch it, there will be mul­ti­ple pos­si­ble ways of achiev­ing this.

## Patch­ing with INFINITE-LOOP

So let’s con­sider how we might at­tempt to patch it. Sup­pose we fol­low the For­mal­ists (ht Cous­inIt) and in­sist that “true” or “false” or only ap­plied to sen­tences that can be eval­u­ated by run­ning a finite com­pu­ta­tion pro­cess. Let’s add a third pos­si­ble “truth” value: INFINITE-LOOP.

Con­sider the fol­low­ing sen­tence:

``The truth value of this sen­tence is not INFINITE-LOOP``

This seems to be a con­tra­dic­tion be­cause the sen­tence is in­finitely re­cur­sive, but at the same time de­nies this.

In or­der to un­der­stand what is hap­pen­ing, we need to make our al­gorithm for as­sign­ing truth val­ues more ex­plicit:

``if ex­pan­sion ter­mi­nates:    Re­solve truth value nor­mal­lyelse:    As­sign INFINITE-LOOPif ex­pan­sion ter­mi­nates:``

What we see here is that if the sen­tence is not able to be ex­panded with­out end­ing up in an in­finite loop, it is as­signed the truth value INFINITE-LOOP with­out any re­gard to what the sen­tence as­serts. So there isn’t ac­tu­ally an in­con­sis­tency, at most, this sys­tem for as­sign­ing truth val­ues just isn’t be­hav­ing how we’d want.

In fact con­sider the fol­low­ing:

``A: This sen­tence is falseB: Sen­tence A has a truth value of INFINITE-LOOP``

Ac­cord­ing to the above al­gorithm, as­sign­ing INFINITE-LOOP to B is cor­rect, when it seems like it should be FALSE. Fur­ther, this sys­tem as­signs INFINITE-LOOP to:

``1+1=2 or this sen­tence is false­``

when per­haps it’d be bet­ter to as­sign it a value of TRUE.

## Patch­ing with an oracle

Be­ing able to talk about whether or not sen­tences end up in an in­finite loop seems use­ful. So we can imag­ine that we have a proof or­a­cle that can de­ter­mine whether sen­tence will end up in a loop or not.

``for refer­ence in sen­tence:    if or­a­cle re­turns INFINITE-LOOP:         Eval­u­ate the clause given the value INFINITE-LOOP as the truth value of the refer­ence    else:        Ex­pand nor­mal­ly``

How­ever, our or­a­cle still doesn’t de­mys­tify:

``The truth value of this sen­tence is not INFINITE-LOOP``

As our al­gorithm would re­place the first clause with INFINITE-LOOP and hence evaluate

``INFINITE-LOOP is not INFINITE-LOOP``

to FALSE. But then:

``FALSE is not INFINITE-LOOP``

so we would ex­pect it to also be TRUE.

So per­haps we should define our or­a­cle to only work with sen­tences that don’t con­tain refer­ences to INFINITE-LOOPS. Con­sider the fol­low­ing situ­a­tion:

``A: This sen­tence is falseB: Sen­tence A has a truth-value of INFINITE-LOOPC: Sen­tence B is trueD: Sen­tence C is true``

B would be TRUE (even though it refers to INFINITE-LOOP, the or­a­cle only has to work with the refer­ence “Sen­tence A”). How­ever, C would be un­defined.

We could fix this by al­low­ing the or­a­cle to re­turn TERMINATES for sen­tences that can be eval­u­ated af­ter one level of ex­pan­sion with our ini­tial defi­ni­tion of an or­a­cle. We can then al­low sen­tence D to be true by al­low­ing the or­a­cle to re­turn TERMINATES for any sen­tence that can be eval­u­ated af­ter two lev­els of ex­pan­sion and we can re­cur­sively ex­tend this defi­ni­tion un­til in­finity.

This also re­solves cases like:

``1+1=2 or this sen­tence is false``

The sec­ond clause eval­u­ates to INFINITE-LOOP and since this is a truth value, rather than ac­tu­ally in­finitely loop­ing, (TRUE OR INFINITE-LOOP) should give true.

## Patch­ing with ORACLE-LOOP

We still haven’t figured out how to han­dle cases like:

``The truth value of this sen­tence is not INFINITE-LOOP``

I would sug­gest that we might want to re­peat our first move and say that the truth value is ORACLE-LOOP when­ever an or­a­cle fails to re­solve it (even if we ex­pand it an in­finite num­ber of times, we still end up with a sen­tence con­tain­ing INFINITE-LOOP). We can then stack meta-lev­els and fur­ther met­alevels on top of this.

## Fi­nal Note

I’ll finish by not­ing that we could also define an­other no­tion of truth whether a state­ment is true when there is a sin­gle fixed point. This would re­sult in state­ments like:

``This sen­tence is true``

Be­ing set to true in­stead of INFINITE-LOOP.

In any case, the way that we ex­tend the con­cept of truth to ap­ply to these de­gen­er­ate cases is purely up to what we find con­ve­nient.

• Con­sider patch­ing by taboo­ing “truth”. Declar­a­tive sen­tences don’t ac­tu­ally have truth value, ex­cept in the sense where “truth” is a hand­wave to­ward con­vey­ing in­for­ma­tion which al­lows an up­date of the re­ceiver’s be­liefs. The im­prove­ment of pre­dic­tions en­abled by this up­date is some­times referred to as “truth”.

Don’t get me wrong—it’s a very use­ful short­hand, and in many many cases you don’t need to ex­pand it. But in the ad­ver­sar­ial case where state­ments are picked to break the nor­mal use of “truth”, the right re­sponse is to aban­don the sim­ple con­cept for those cases.

• I re­ally like the idea that an eval­u­a­tion al­gorithm of a propo­si­tion can ei­ther ter­mi­nate or end up in a fixed point, map­ping back to the eval­u­a­tion al­gorithm it­self. It unites math­e­mat­i­cal and non-math­e­mat­i­cal state­ments in­stead of sep­a­rat­ing them, and it al­lows for al­gorithm-de­pen­dent out­comes of propo­si­tions, which fits well into my anti-re­al­ist on­tol­ogy. In this ap­proach a lack of con­ver­gence would be an in­di­ca­tion that a new, po­ten­tially higher-level eval­u­a­tion al­gorithm (I call those “mod­els”) is re­quired.

Go­ing by what you have pre­sented, some ba­sic hi­er­ar­chy could be some­thing like this:

Eval­u­at­ing al­gorithm-1: Im­me­di­ately/​ob­vi­ously/​pos­tu­lated true or false, no ex­tra eval­u­a­tion needed

Eval­u­at­ing al­gorithm-2: Eval­u­ated to true or false with or the eval­u­at­ing al­gorithm-2 (your “in­finite loop”)

Eval­u­at­ing al­gorithm-3: Eval­u­ated to one of the 2 above or to it­self, if the “eval­u­a­tion field” is not closed.

Etc.

• I can’t figure out how to in­dent my code

• Open a code-block by typ­ing ``` (triple tick), then press en­ter.

• Didn’t work, just showed the triple ticks

• Weird, here is a gif of how it’s sup­posed to work:

http://​​www.gi­phy.com/​​gifs/​​IgigWli9bG8OmtpFPv

Are you us­ing the mark­down or the draft-js ed­i­tor? If it’s the mark­down ed­i­tor, then sur­round­ing things with those ticks should make ev­ery­thing in be­tween them code.

• Prob­a­bly wrong editor

• Hmm, it looks like it was writ­ten in the draft-js ed­i­tor. In any case, I fixed it for you.

• Try edit­ing the post on GreaterWrong. There’s a “code block” but­ton in the ed­i­tor—se­lect your code and click it, it’ll gen­er­ate the right Mark­down to make it a code block.

• There are a cou­ple of books I know of that deal with para­doxes of cir­cu­lar­ity. I’ve read the first one (a long time ago, so don’t ask me about the de­tails) but not the sec­ond.

“The Liar: An Es­say on Truth and Cir­cu­lar­ity” by Bar­wise and Etchemendy, which is all about the liar para­dox, its elab­o­ra­tions, and at­tempts to re­solve them.

“Vi­cious Cir­cles: On the Math­e­mat­ics of Non-Wel­lfounded Phenom­ena” by Bar­wise and Moss is more wide-rang­ing.

• The truth value of this sen­tence is not INFINITE-LOOP

Can’t this sen­tence be as­signed the value of “True”? If you have those 3 pos­si­ble as­sign­ments (and there is no ad­di­tional “un­known” value that may be as­signed) then the sen­tences may be true or false or “in­finite loop”. If it were in­finite loop then it would be false. If it were false then it would be in­finite loop. But if it is true, then (since true isn’t in­finite loop) it is true.

• Yep, it can be as­signed that if you use the fixed point defi­ni­tion of truth.

• A similar con­jec­ture is: “Om­nis­cent Omega tells you that you see is an illu­sion.”

It could be in­ter­preted as a) Omega is real, it said truth and thus I see is an illu­sion. b) Omega is not real and thus Omega is illu­sion, no mat­ter what it says. In both cases I see an illu­sion.

This para­dox ap­pears in the dis­cus­sions about the Si­mu­la­tion Ar­gu­ment in the fol­low­ing form: some peo­ple ob­ject to SA: if I am in simu­la­tion, I can’t make any con­clu­sion about the out­side world and thus I can’t use the com­puter power es­ti­ma­tions to prove fu­ture AI ca­pa­bil­ities, and thus SA does not work.

How­ever, as it is already as­sumed that you are in simu­la­tion, SA is already proved, no mat­ter what you can or can not con­clude, and it is similar to (b) branch of Omega para­dox from above.

• In any case, the way that we ex­tend the con­cept of truth to ap­ply to these de­gen­er­ate cases is purely up to what we find con­ve­nient. Obviously

How does this last sen­tence end?

• Un­for­tu­nately, I didn’t see this com­ment and now I can’t re­mem­ber, so I just re­moved it and we’ll never know.