//
/**
* function TT-CHECK-ALL(KB, α symbols, model) returns true or false
*
* @param kb
* KB, the knowledge base, a sentence in propositional logic
* @param alpha
* α, the query, a sentence in propositional logic
* @param symbols
* a list of currently unassigned propositional symbols in the
* model.
* @param model
* a partially or fully assigned model for the given KB and
* query.
* @return true if KB entails α, false otherwise.
*/
public bool ttCheckAll(KnowledgeBase kb, Sentence alpha, ICollection <PropositionSymbol> symbols, Model model)
{
// if EMPTY?(symbols) then
if (symbols.IsEmpty())
{
// if PL-TRUE?(KB, model) then return PL-TRUE?(α, model)
if (model.isTrue(kb.asSentence()))
{
return(model.isTrue(alpha));
}
else
{
// else return true // when KB is false, always return true
return(true);
}
}
// else do
// P <- FIRST(symbols)
PropositionSymbol p = Util.first(symbols);
// rest <- REST(symbols)
ICollection <PropositionSymbol> rest = Util.rest(symbols);
// return (TT-CHECK-ALL(KB, α, rest, model ∪ { P = true })
// and
// TT-CHECK-ALL(KB, α, rest, model U { P = false }))
return(ttCheckAll(kb, alpha, rest, model.union(p, true)) &&
ttCheckAll(kb, alpha, rest, model.union(p, false)));
}
private Token symbol()
{
int startPosition = getCurrentPositionInInput();
IStringBuilder sbuf = TextFactory.CreateStringBuilder();
while (null != lookAhead(1) && PropositionSymbol.isPropositionSymbolIdentifierPart(lookAhead(1).Value))
{
sbuf.Append(lookAhead(1));
consume();
}
string symbol = sbuf.ToString();
if (PropositionSymbol.isAlwaysTrueSymbol(symbol))
{
return(new Token(LogicTokenTypes.TRUE, PropositionSymbol.TRUE_SYMBOL, startPosition));
}
else if (PropositionSymbol.isAlwaysFalseSymbol(symbol))
{
return(new Token(LogicTokenTypes.FALSE, PropositionSymbol.FALSE_SYMBOL, startPosition));
}
else if (PropositionSymbol.isPropositionSymbol(symbol))
{
return(new Token(LogicTokenTypes.SYMBOL, sbuf.ToString(), startPosition));
}
throw new LexerException("Lexing error on symbol " + symbol + " at position " + getCurrentPositionInInput(), getCurrentPositionInInput());
}
/**
* La función TT-CHECK-ALL(KB, α symbols, model) devuelve cierto o falso
*
* @param kb
* KB, la base de conocimiento, una sentencia en lógica proposicional
* @param alpha
* α, la consulta, una sentencia en lógica proposicional
* @param symbols
* una lista de símbolos proposicionales no asignados actualmente en el modelo
* @param model
* una asignación del modelo parcial o completa para la BC dada y la consulta.
* @return cierto si α es consecuencia lógica de KB, falso en otro caso.
*/
public bool TTCheckAll(KnowledgeBase kb, Sentence alpha, IList <PropositionSymbol> symbols, Model model)
{
// si EMPTY?(symbols) entonces
if (symbols.Count == 0)
{
// si PL-TRUE?(KB, model) entonces return PL-TRUE?(α, model)
if (model.IsTrue(kb.AsSentence()))
{
return(model.IsTrue(alpha));
}
else
{
// en caso contrario devolver cierto (cuando la KB es falsa, SIEMPRE se devuelve cierto)
return(true);
}
}
// en caso contrario hacer
// P <- FIRST(symbols)
PropositionSymbol p = Util.First(symbols);
// rest <- REST(symbols)
IList <PropositionSymbol> rest = Util.Rest(symbols);
// return (TT-CHECK-ALL(KB, α, rest, model ∪ { P = true })
// and
// TT-CHECK-ALL(KB, α, rest, model U { P = false }))
var checkIfTrue = TTCheckAll(kb, alpha, rest, model.Union(p, true));
var checkIfFalse = TTCheckAll(kb, alpha, rest, model.Union(p, false));
return(checkIfTrue && checkIfFalse);
}
public Model union(PropositionSymbol symbol, bool?b)
{
Model m = new Model();
m.assignments.PutAll(this.assignments);
m.assignments.Put(symbol, b);
return(m);
}
public Model Union(PropositionSymbol symbol, bool?b)
{
Model m = new Model();
m.assignments = new Dictionary <PropositionSymbol, bool?>(assignments); //m.assignments.putAll(this.assignments);
m.assignments.Add(symbol, b);
return(m);
}
/**
* Dice si es falso un símbolo proposicional.
*/
public bool IsFalse(PropositionSymbol symbol)
{
bool?result = false; // ESTO LO HE PUESTO YO... si no está el símbolo va a devolver false (no sé si es correcto!)
assignments.TryGetValue(symbol, out result);
return(bool.FalseString.Equals(result)); //Boolean.FALSE lo he cambiado a esto
}
/**
* Dice si es cierto un símbolo proposicional.
*/
public bool IsTrue(PropositionSymbol symbol)
{
bool?result = false; // ESTO LO HE PUESTO YO... si no está el símbolo va a devolver false (no sé si es correcto!)
assignments.TryGetValue(symbol, out result);
return(true.Equals(result)); //Había un bool.TrueString ... que no tiene mucho sentido
}
/**
* Obtiene el valor de un símbolo proposicional.
*/
public bool?GetValue(PropositionSymbol symbol)
{
bool?result = null; // O no haría falta inicializarlo, y ya se sobreentiende que está a nulo
assignments.TryGetValue(symbol, out result);
return(result);
}
public override ISet <Clause> VisitPropositionSymbol(PropositionSymbol s, ISet <Clause> arg)
{
// una cláusula unidad positiva
Literal positiveLiteral = new Literal(s);
arg.Add(new Clause(positiveLiteral));
return(arg);
}
public override ISet <Clause> visitPropositionSymbol(PropositionSymbol s, ISet <Clause> arg)
{
// a positive unit clause
Literal positiveLiteral = new Literal(s);
arg.Add(new Clause(positiveLiteral));
return(arg);
}
public override ISet <Literal> visitPropositionSymbol(PropositionSymbol s, ISet <Literal> arg)
{
// a positive literal
Literal positiveLiteral = new Literal(s);
arg.Add(positiveLiteral);
return(arg);
}
protected PropositionSymbol randomlySelectSymbolFromClause(Clause clause)
{
// all the symbols in clause
ISet <PropositionSymbol> symbols = clause.getSymbols();
// a randomly selected symbol from clause
PropositionSymbol result = (CollectionFactory.CreateQueue <PropositionSymbol>(symbols)).Get(random.Next(symbols.Size()));
return(result);
}
public Model flip(PropositionSymbol s)
{
if (isTrue(s))
{
return(union(s, false));
}
if (isFalse(s))
{
return(union(s, true));
}
return(this);
}
public Model Flip(PropositionSymbol s)
{
if (IsTrue(s))
{
return(Union(s, false));
}
if (IsFalse(s))
{
return(Union(s, true));
}
return(this);
}
protected bool callDPLL(ISet <Clause> clauses, ICollection <PropositionSymbol> symbols,
Model model, PropositionSymbol p, bool?value)
{
// We update the model in place with the assignment p=value,
bool result = dpll(clauses, symbols, model.unionInPlace(p, value));
// as backtracking can occur during the recursive calls we
// need to remove the assigned value before we pop back out from this
// call.
model.remove(p);
return(result);
}
public bool?visitPropositionSymbol(PropositionSymbol s, bool?arg)
{
if (s.isAlwaysTrue())
{
return(true);
}
if (s.isAlwaysFalse())
{
return(false);
}
return(getValue(s));
}
public void test_isAlwaysTrueSymbol()
{
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("True"));
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("tRue"));
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("trUe"));
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("truE"));
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("TRUE"));
Assert.IsTrue(PropositionSymbol.isAlwaysTrueSymbol("true"));
//
Assert.IsFalse(PropositionSymbol.isAlwaysTrueSymbol("Tru3"));
Assert.IsFalse(PropositionSymbol.isAlwaysTrueSymbol("True "));
Assert.IsFalse(PropositionSymbol.isAlwaysTrueSymbol(" True"));
}
public void test_isAlwaysFalseSymbol()
{
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("False"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("fAlse"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("faLse"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("falSe"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("falsE"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("FALSE"));
Assert.IsTrue(PropositionSymbol.isAlwaysFalseSymbol("false"));
//
Assert.IsFalse(PropositionSymbol.isAlwaysFalseSymbol("Fals3"));
Assert.IsFalse(PropositionSymbol.isAlwaysFalseSymbol("False "));
Assert.IsFalse(PropositionSymbol.isAlwaysFalseSymbol(" False"));
}
public void testAIMAExample()
{
KnowledgeBase kb = new KnowledgeBase();
kb.tell("P => Q");
kb.tell("L & M => P");
kb.tell("B & L => M");
kb.tell("A & P => L");
kb.tell("A & B => L");
kb.tell("A");
kb.tell("B");
PropositionSymbol q = (PropositionSymbol)parser.parse("Q");
Assert.AreEqual(true, plfce.plfcEntails(kb, q));
}
public void testKBWithNonDefiniteClauses()
{
KnowledgeBase kb = new KnowledgeBase();
kb.tell("P => Q");
kb.tell("L & M => P");
kb.tell("B & L => M");
kb.tell("~A & P => L"); // Not a definite clause
kb.tell("A & B => L");
kb.tell("A");
kb.tell("B");
PropositionSymbol q = (PropositionSymbol)parser.parse("Q");
Assert.AreEqual(true, plfce.plfcEntails(kb, q));
}
/**
* PL-FC-ENTAILS?(KB, q)<br>
* The forward-chaining algorithm for propositional logic.
*
* @param kb
* the knowledge base, a set of propositional definite clauses.
* @param q
* q, the query, a proposition symbol
* @return true if KB |= q, false otherwise.
* @throws IllegalArgumentException
* if KB contains any non-definite clauses.
*/
public bool plfcEntails(KnowledgeBase kb, PropositionSymbol q)
{
// count <- a table, where count[c] is the number of symbols in c's
// premise
IMap <Clause, int> count = initializeCount(kb);
// inferred <- a table, where inferred[s] is initially false for all
// symbols
IMap <PropositionSymbol, bool?> inferred = initializeInferred(kb);
// agenda <- a queue of symbols, initially symbols known to be true in
// KB
ICollection <PropositionSymbol> agenda = initializeAgenda(count);
// Note: an index for p to the clauses where p appears in the premise
IMap <PropositionSymbol, ISet <Clause> > pToClausesWithPInPremise = initializeIndex(count, inferred);
// while agenda is not empty do
while (!agenda.IsEmpty())
{
// p <- Pop(agenda)
PropositionSymbol p = agenda.Pop();
// if p = q then return true
if (p.Equals(q))
{
return(true);
}
// if inferred[p] = false then
if (inferred.Get(p).Equals(false))
{
// inferred[p] <- true
inferred.Put(p, true);
// for each clause c in KB where p is in c.PREMISE do
foreach (Clause c in pToClausesWithPInPremise.Get(p))
{
// decrement count[c]
decrement(count, c);
// if count[c] = 0 then add c.CONCLUSION to agenda
if (count.Get(c) == 0)
{
agenda.Add(conclusion(c));
}
}
}
}
// return false
return(false);
}
public void test_isPropositionSymbolDoesNotContainConnectiveChars()
{
// '~', '&', '|', '=', '<', '>'
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("~"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("&"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("|"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("="));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("<"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol(">"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A~"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A&"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A|"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A="));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A<"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A>"));
}
public bool dpll(ISet <Clause> clauses, ICollection <PropositionSymbol> symbols, Model model)
{
// if every clause in clauses is true in model then return true
if (everyClauseTrue(clauses, model).Value)
{
return(true);
}
// if some clause in clauses is false in model then return false
if (someClauseFalse(clauses, model) || currIsCancelled)
{
return(false);
}
// P, value <- FIND-PURE-SYMBOL(symbols, clauses, model)
Pair <PropositionSymbol, bool?> pAndValue = findPureSymbol(symbols,
clauses, model);
// if P is non-null then
if (pAndValue != null)
{
// return DPLL(clauses, symbols - P, model U {P = value})
return(dpll(clauses, minus(symbols, pAndValue.GetFirst()),
model.union(pAndValue.GetFirst(), pAndValue.getSecond())));
}
// P, value <- FIND-UNIT-CLAUSE(clauses, model)
pAndValue = findUnitClause(clauses, model);
// if P is non-null then
if (pAndValue != null)
{
// return DPLL(clauses, symbols - P, model U {P = value})
return(dpll(clauses, minus(symbols, pAndValue.GetFirst()),
model.union(pAndValue.GetFirst(), pAndValue.getSecond())));
}
// P <- FIRST(symbols); rest <- REST(symbols)
PropositionSymbol p = Util.first(symbols);
ICollection <PropositionSymbol> rest = Util.rest(symbols);
// return DPLL(clauses, rest, model U {P = true}) or
// ...... DPLL(clauses, rest, model U {P = false})
return(dpll(clauses, rest, model.union(p, true)) ||
dpll(clauses, rest, model.union(p, false)));
}
/**
* Determina basándose en las asignaciones actuales del modelo, cuando una cláusula se sabe que es cierta, falsa o desconocida.
*
* @param c
* una cláusula proposicional.
* @return cierto, si se conoce que la cláusula es cierta bajo las actuales asignaciones del modelo.
* falso, si se conoce que la cláusula es falsa bajo las actuales asignaciones del modelo.
* nulo, si se desconoce que la cláusula sea cierta o falsa bajo las actuales asignaciones del modelo.
*/
// Aquí claramente se está apostando por usar un bool nullable
public bool?DetermineValue(Clause c)
{
bool?result = null; // es decir, desconocido
if (c.IsTautology()) // Prueba independiente de las asignaciones del modelo
{
result = true; // Boolean.TRUE ponía
}
else if (c.IsFalse()) // Prueba independiente de las asignaciones del modelo
{
result = false; // Boolean.FALSE ponía
}
else
{
bool unassignedSymbols = false;
foreach (Literal literal in c.GetLiterals())
{
PropositionSymbol symbol = literal.GetAtomicSentence();
bool?value;
assignments.TryGetValue(symbol, out value);
if (value == null) // Debería meterse el TryGetValue aquí en vez de ver si es nulo
{
unassignedSymbols = true;
}
else if (value.Equals(literal.IsPositiveLiteral()))
{
result = true;
break;
}
}
if (result == null && !unassignedSymbols)
{
// Si no se ha determinado que sea cierto y no hay símbolos sin asignar entonces podemos determinaar falsedad
// (es decir, todos sus literales se asignan como falsos bajo el modelo)
result = false;
}
}
return(result);
}
public void test_isPropositionSymbol()
{
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("True"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("False"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("A"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("A1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("A_1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("a"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("a1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("A_1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("_"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("_1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("_1_2"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("$"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("$1"));
Assert.IsTrue(PropositionSymbol.isPropositionSymbol("$1_1"));
// Commas not allowed (only legal java identifier characters).
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A1,2"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol(" A"));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A "));
Assert.IsFalse(PropositionSymbol.isPropositionSymbol("A B"));
}
// No hace falta override porque PLVisitor es una interfaz, pero pongo virtual por si queremos seguir sobreescribiendo
public virtual Sentence VisitPropositionSymbol(PropositionSymbol s, A arg)
{
// El comportamiento por defecto es tratar los símbolos proposicionales como áromos y dejarlos sin cambios.
return(s);
}
public bool remove(PropositionSymbol p)
{
return(assignments.Remove(p));
}
public Model unionInPlace(PropositionSymbol symbol, bool?b)
{
assignments.Put(symbol, b);
return(this);
}
public bool isFalse(PropositionSymbol symbol)
{
return(false.Equals(assignments.Get(symbol)));
}
public bool isTrue(PropositionSymbol symbol)
{
return(true.Equals(assignments.Get(symbol)));
}
