I made an attempt to formulate the 3 statements:

A ∧ B. A is true because B is true.
B ∨ = ¬B. B says the truth or not but not both.
¬(C ∨ B). C says the truth as a negation of B. — javi2541997

How First Order Logic achieves this is beyond my pay grade. — RussellA

A is either True or False, so A∨¬A. Therefore, A→B can be either True or False (in this case False). No inconsistency in the solution presented. — Lionino

That A is coherent but ambiguous or what — javi2541997

B -> A ∧ B = ¬A — javi2541997

#!/usr/bin/env qjs

//it is possible to generate the solution space automatically
//but it is so small that it is easier to just supply it manually
var solutionSpace= [
			{"A":"truth", "B":"liar","C":"random"},
			{"A":"liar","B":"truth","C":"random"},
			{"A":"random","B":"truth","C":"liar"},
			{"A":"random","B":"liar","C":"truth"},
			{"A":"truth","B":"random","C":"liar"},
			{"A":"liar","B":"random","C":"truth" }
		   ];

//constraint.index is just for the purpose of reference
var constraints = [ 
	{"index":"a","who_says":"A","B_is":"truth"},
	{"index":"b","who_says":"B", "B_is":"random"},
	{"index":"c","who_says":"C", "B_is":"liar"}
	];

//we iterate over every potential solution in the solution space
for(var solution of solutionSpace) {
	var B=solution["B"];
    console.log("--------------------------");
    //A and C are just for printing the potential solution
    //they are not needed for the algorithm
	var A=solution["A"];
	var C=solution["C"];
    console.log("checking: "+A+" "+B+" "+C);
    //we assume that the solution is valid, until it isn't anymore.
    var abort_solution=false;
    //now we check every constraint for the current potential solution
    for(var constraint of constraints) {
        var index=constraint["index"];
        var who_says=constraint["who_says"];
        var B_is=constraint["B_is"];
        //check 1: truth is not allowed to lie about B
        if(solution[who_says]=="truth" && B!==B_is) {
            console.log("violation of constraint ("+index+
                "); truth is not allowed to lie and say that "+B+" is "+B_is);
            abort_solution=true;
            break;
        }
        //check 2: liar is not allowed to tell the truth about
        if(solution[who_says]=="liar" && B==B_is) {
            console.log("violation of constraint ("+index+
                "); liar is not allowed to tell the truth and say that "+B+" is "+B_is);
            abort_solution=true;
            break;
        }
        //we cannot check random; so, no check for that one
    }
    if(!abort_solution) console.log("found legitimate solution");
}
console.log("--------------------------");

$ ./truth-liar-random.js
--------------------------
checking: truth liar random
violation of constraint (a); truth is not allowed to lie and say that liar is truth
--------------------------
checking: liar truth random
violation of constraint (a); liar is not allowed to tell the truth and say that truth is truth
--------------------------
checking: random truth liar
violation of constraint (b); truth is not allowed to lie and say that truth is random
--------------------------
checking: random liar truth
found legitimate solution
--------------------------
checking: truth random liar
violation of constraint (a); truth is not allowed to lie and say that random is truth
--------------------------
checking: liar random truth
violation of constraint (c); truth is not allowed to lie and say that random is liar
--------------------------

Then I asked yesterday if A was ambiguous or just contradictory. The debate remains. — javi2541997

So (B∨¬B) is False, it is always the case that ¬B. — Lionino

Even in my attempt I had to change the definition of an operator. — Lionino

The "or" operator must not be traditionally understood, rather it should be understood as "It can be one or the other, both are possible". So A∨¬A means A can be True or False. — Lionino

I'm personally amazed that he's made such a simple riddle last 3 pages, when nobody else has any question about what the answer is. — flannel jesus

I still don't get why the answer everyone else is giving isn't satisfying to you. — flannel jesus

Is it possible to formulate it using first-order logic? — javi2541997

• A→(B∧¬C) is if A, B tells the truth and C lies
• (B→((A∧¬C)∨(¬A∧C))) is if B, {A tells the truth and C lies} or {A lies and C tells the truth}
• C→(¬B) is if C, B lies
• (A∧¬B)∨(¬A∧B)∨(A∧¬C)∨(¬A∧C)∨(B∧¬C)∨(¬B∧C) are the conditions that one of the three has to lie and another tell the truth