public override Proposition Resolve(string[] key, SymbolIs[] state)
{
//Resolve child prepositions.
_requirement = _requirement.Resolve(key, state);
_implication = _implication.Resolve(key, state);
SymbolIs solution = CheckSolvable(key, state);
if (solution == SymbolIs.True)
{
return(new True());
}
else if (solution == SymbolIs.False)
{
return(new Not(new True()));
}
else
{
//If the requirement [A in A=>B] is true, return the implication [B].
SymbolIs req = _requirement.CheckSolvable(key, state);
if (req == SymbolIs.True)
{
return(_implication);
}
else
{
return(this);
}
}
}
public override Proposition Resolve(string[] key, SymbolIs[] state)
{
//Resolve child prepositions.
_fact1 = _fact1.Resolve(key, state);
_fact2 = _fact2.Resolve(key, state);
SymbolIs sol1 = _fact1.CheckSolvable(key, state);
SymbolIs sol2 = _fact2.CheckSolvable(key, state);
//If both are false resolve to Not-True, if either is true resolve to True.
if (sol1 == SymbolIs.False && sol2 == SymbolIs.False)
{
return(new Not(new True()));
}
else if (sol1 == SymbolIs.True || sol2 == SymbolIs.True)
{
return(new True());
}
else
{
//If one of the facts can be proved false, it can be removed from the logic.
if (sol1 == SymbolIs.False)
{
return(_fact2);
}
else if (sol2 == SymbolIs.False)
{
return(_fact1);
}
else
{
return(this);
}
}
}
protected override int QueryUsingRule(Rule query)
{
List <HornRule> checkedRules = new List <HornRule>();
bool stateChanged = true;
while (stateChanged)
{
stateChanged = false;
//Try to solve each of the rules given the current knowledge.
foreach (HornRule HR in KB)
{
if (checkedRules.Contains(HR))
{
continue;
}
//Resolve the rule. If it was fully resolved:
HR.Resolve(literalsKey, literalsSolutions);
if (HR.IsFullyResolved)
{
//If this rule proves a literal (i.e. doesn't return Unknown), add the literal to the knowledge and remove the rule.
HornRule.Literal newLiteral = HR.ProveLiteral(literalsKey, literalsSolutions);
if (newLiteral.state != SymbolIs.Unknown)
{
stateChanged = true;
checkedRules.Add(HR);
//Loop through the knowledge table and add the new information at the correct index.
for (int i = 0; i < literalsKey.Length; ++i)
{
if (literalsKey[i] == newLiteral.symbol)
{
if (literalsSolutions[i] == SymbolIs.Unknown)
{
literalsSolutions[i] = newLiteral.state;
}
else if (literalsSolutions[i] != newLiteral.state)
{
throw new Exception("KnowledgeBase is contradictory");
}
}
}
}
}
}
//If the query has been proven, return either true or false based on the outcome.
SymbolIs solution = query.CheckSolved(literalsKey, literalsSolutions);
if (solution == SymbolIs.True)
{
return(1);
}
else if (solution == SymbolIs.False)
{
return(0);
}
} //End of While loop
return(0);
}
public Literal(string Symbol, bool Negated)
{
symbol = Symbol;
if (Negated)
{
state = SymbolIs.False;
}
else
{
state = SymbolIs.True;
}
}
protected void FindDefinitions()
{
for (int i = 0; i < literalsKey.Length; ++i)
{
literalsSolutions[i] = SymbolIs.Unknown;
foreach (HornRule HR in KB)
{
SymbolIs solution = HR.DefinesLiteral(literalsKey[i]);
if (solution != SymbolIs.Unknown)
{
literalsSolutions[i] = solution;
break;
}
}
}
}
public override SymbolIs CheckSolvable(string[] key, SymbolIs[] state)
{
SymbolIs solution = _fact.CheckSolvable(key, state);
if (solution == SymbolIs.False)
{
return(SymbolIs.True);
}
else if (solution == SymbolIs.True)
{
return(SymbolIs.False);
}
else
{
return(SymbolIs.Unknown);
}
}
/// <summary> Using the given knowledge, return the most simple solvable version of this preposition chain. Fully solvable chain will result in True(). </summary>
public virtual Proposition Resolve(string[] key, SymbolIs[] state)
{
SymbolIs solution = CheckSolvable(key, state);
if (solution == SymbolIs.True)
{
return(new True());
}
else if (solution == SymbolIs.False)
{
return(new Not(new True()));
}
else
{
return(this);
}
}
public Literal ProveLiteral(string[] key, SymbolIs[] knowledge)
{
SymbolIs solution = _rule.CheckSolvable(key, knowledge);
if (solution == SymbolIs.True)
{
return(_literalVal);
}
else if (solution == SymbolIs.False)
{
return(new Literal(_literalVal.symbol, _literalVal.Inverse));
}
else
{
return(new Literal(_literalVal.symbol, SymbolIs.Unknown));
}
}
public override SymbolIs CheckSolvable(string[] key, SymbolIs[] state)
{
SymbolIs sol1 = _fact1.CheckSolvable(key, state);
SymbolIs sol2 = _fact2.CheckSolvable(key, state);
if (sol1 == SymbolIs.False && sol2 == SymbolIs.False)
{
return(SymbolIs.False);
}
else if (sol1 == SymbolIs.True || sol2 == SymbolIs.True)
{
return(SymbolIs.True);
}
else
{
return(SymbolIs.Unknown);
}
}
public override SymbolIs CheckSolvable(string[] key, SymbolIs[] state)
{
SymbolIs req = _requirement.CheckSolvable(key, state);
SymbolIs imp = _implication.CheckSolvable(key, state);
if (req == SymbolIs.False)
{
return(SymbolIs.True);
}
else if (imp == SymbolIs.True)
{
return(SymbolIs.True);
}
else if (req == SymbolIs.True && imp == SymbolIs.False)
{
return(SymbolIs.False);
}
else
{
return(SymbolIs.Unknown);
}
}
public override Proposition Resolve(string[] key, SymbolIs[] state)
{
//Resolve child prepositions.
_fact1 = _fact1.Resolve(key, state);
_fact2 = _fact2.Resolve(key, state);
SymbolIs sol1 = _fact1.CheckSolvable(key, state);
SymbolIs sol2 = _fact2.CheckSolvable(key, state);
//If the either fact is Unknown return this, otherwise resolve to True if they are the same, or false if they are different.
if (sol1 == sol2 && sol1 != SymbolIs.Unknown)
{
return(new True());
}
else if (sol1 != SymbolIs.Unknown && sol2 != SymbolIs.Unknown)
{
return(new Not(new True()));
}
else
{
return(this);
}
}
//UNUSED! Simplifies the KB by substituting proven literals into rules. Created to understand how to solve the KB.
public void SolveKB()
{
bool ruleChanged = true;
while (ruleChanged)
{
ruleChanged = false;
foreach (HornRule R in KB)
{
if (R.Resolve(literalsKey, literalsSolutions))
{
ruleChanged = true;
for (int i = 0; i < literalsKey.Length; ++i)
{
SymbolIs solution = R.DefinesLiteral(literalsKey[i]);
if (solution != SymbolIs.Unknown && literalsSolutions[i] == SymbolIs.Unknown)
{
literalsSolutions[i] = solution;
}
}
}
}
}
}
public Literal(string Symbol, SymbolIs State)
{
symbol = Symbol;
state = State;
}
protected override int QueryUsingRule(Rule query)
{
//Initialize
List <string> literalsToSolve = new List <string>();
foreach (string symbol in query.symbols)
{
literalsToSolve.Add(symbol);
}
List <HornRule> rulesToSolve = new List <HornRule>();
List <HornRule> checkedRules = new List <HornRule>();
bool stateChanged = true;
while (stateChanged == true)
{
stateChanged = false;
//Add the the list of rules to solve any rules which are relevant to our query (I.e. are relevant to symbols which are relevant).
//Then add each symbol used by those rules to the list of literals to solve.
foreach (HornRule HR in KB)
{
if (checkedRules.Contains(HR))
{
continue;
}
for (int i = 0; i < literalsToSolve.Count; ++i)
{
if (HR.LiteralIsImplication(literalsToSolve[i]))
{
stateChanged = true;
rulesToSolve.Add(HR);
checkedRules.Add(HR);
foreach (string s in HR.symbols)
{
if (!literalsToSolve.Contains(s))
{
literalsToSolve.Add(s);
}
}
break;
}
}
}
//Try to solve each of the rules given the current knowledge.
//If a rule is solved, remove it from the list, and add any symbols it entails to the KB.
for (int r = 0; r < rulesToSolve.Count; ++r)
{
//Resolve the rule. If it was fully resolved:
rulesToSolve[r].Resolve(literalsKey, literalsSolutions);
if (rulesToSolve[r].IsFullyResolved)
{
//If this rule proves a literal (i.e. doesn't return Unknown), add the literal to the knowledge and remove the rule.
HornRule.Literal newLiteral = rulesToSolve[r].ProveLiteral(literalsKey, literalsSolutions);
if (newLiteral.state != SymbolIs.Unknown)
{
stateChanged = true;
//Loop through the knowledge table and add the new information at the correct index.
for (int i = 0; i < literalsKey.Length; ++i)
{
if (literalsKey[i] == newLiteral.symbol)
{
if (literalsSolutions[i] == SymbolIs.Unknown)
{
literalsSolutions[i] = newLiteral.state;
}
else if (literalsSolutions[i] != newLiteral.state)
{
throw new Exception("KnowledgeBase is contradictory");
}
}
}
//Stop trying to find rules relevant to the proven literal.
literalsToSolve.Remove(newLiteral.symbol);
//Remove the solved rule from the list, and go back one index.
rulesToSolve.RemoveAt(r);
--r;
}
}
}
//If the query has been proven, return either true or false based on the outcome.
SymbolIs solution = query.CheckSolved(literalsKey, literalsSolutions);
if (solution == SymbolIs.True)
{
return(1);
}
else if (solution == SymbolIs.False)
{
return(0);
}
} //End of While loop.
return(0);
}
