> A liar's goal is to fool you, not to predictably invert answers.

Indeed, though you'll see this is closer to the chaotic liar I discussed, which basically makes the problem useless to try and solve, as nobody could possible fool a chaotic liar (assuming they have infinite intelligence and will lie perfectly in order to fool you everytime).

However, the idea of a liar which evaluates the question similarly to the truth-teller but then inverts the answer at the end is something I did not really think about when I approached the question. I posted the following excerpt in the comments section below the article, but I think it would be worthwhile to post here as well:

"""
Sorry about that. To be honest, it was something I overlooked when coming up with a formal definition for a liar, but let me try to (informally) explain why you can't complete God Mode or God Slayer mode with that definition of a liar (let's go ahead and call this the NOT Liar).

So recall that when dealing with the complex liar, we used the difference in how our (AND, OR, NOT, XOR) operators were evaluated in order to differentiate the liar from the truth teller. Likewise recall that for the simple liar we needed to use prior information about the room in order differentiate between the liar and the truth teller. In this case, we can treat both the honest bird (BirdA) and the liar (BirdB) as two different evaluation environments. Specifically, they evaluate our statements and the relationship between statements.

The goal then, is to come up with some phrase or statement which evaluate to the same values without regard for which environment the statement is evaluated under. The simplest form of this is a tautology, which is true under _any_ interpretation. So let's use the names BirdA and BirdB as functions, which act like eval() in e.g. Python or Scheme/Lisp. You then have to consider the following:

1. God Slayer mode insists that you use no if statements or hypothetical expressions. In the context of an eval-like function, this is equivalent to not introducing any additional state to the environment.
2. God mode insists that you cannot reference the other bird. So basically, we can't make calls like BirdA(BirdB( ... question ... )) or BirdB(BirdA( ... question ...)).

With respect to #1 above, this basically means we can't make things up, and I am taking the challenge on the interpretation that doing God Slayer mode implies doing God mode as well. So at best, we can choose one of the following:

BirdA( ... question ... , [R, M, D])
BirdB( ... question ... , [R, M, D])

And again, we can't reference BirdB inside the BirdA function, and vice-versa, because they are not defined in the environment (stuff in [ ] braces). You could argue that we have more prior information about our room than just D, but even the existence of that won't help you, because we're defining our evaluation functions BirdA and BirdB as follows:

def BirdA(expression, env):
# Process expression only using symbols found in env

def BirdB(expression, env):
return not BirdA(expression, env)

So the only difference we can make is based on our inputs, so we either need the ability to choose our evaluation function (BirdA or BirdB, we would have to know who is the liar in advance), or we need to introduce something else into our environment (such as inputting BirdA into the environment of BirdB, or vice-versa, which means we can't do God mode, and thus not God Slayer mode).

Basically, there is no differentiating factor between the liar and the truth-teller, so you have no way of logically knowing which one you are asking, and no way to fool them, because expression is evaluated the same in both environments, and then the final output is changed only when the liar (BirdB) is asked.

You'll notice the traditional answer to this game is to ask what the opposite bird would say is the door to heaven, which works for this type of liar, but God mode and God slayer don't, because you can't make hypothetical situations (introduce new variables into the environment), and you can't ask about the other evaluation environment in God mode.

Please let me know if this makes any sense. I'm approaching this from a somewhat weird angle, but I'm pretty sure this is a (very) informal proof as to why you can't solve God or God-Slayer mode with a NOT Liar present.
"""

But yes, please feel free to try and break my logic, I would prefer to have a correct article than a poor one.