public void TestReorder()
{
for (int i = 0; i < Start.Length; ++i)
{
Assert.AreEqual(Expected[i], ReorderClause(ClauseParser.Parse(Start[i])).ToString());
}
}
public void Setup()
{
Root = ClauseParser.Parse("a&b");
OtherRoot = ClauseParser.Parse("c||d");
Assert.AreEqual("a&b", Root.ToString());
Assert.AreEqual("c||d", OtherRoot.ToString());
}
public void TestCNFClause()
{
CNFClause clause1 = new CNFClause(ClauseParser.Parse("a&b&c||d")),
clause2 = new CNFClause(ClauseParser.Parse("a=>(b&c||d&e)"));
Console.WriteLine("{0}\n{1}", clause1.ToString(), clause2.ToString());
}
public override string Prove(KnowledgeBase kb, string ask)
{
if (!Symbols.UniqueValues.Contains(ask))
{
return("NO");
}
base.Prove(kb, ask);
return(KBEntails(ClauseParser.Parse(ask)) ? $"YES: {TruthCount}" : "NO");
}
public void TestClauseInit()
{
Clause clause1 = ClauseParser.ParseToClause("a&b&c||d"),
clause2 = ClauseParser.ParseToClause("a=>(b&c||d&e)");
Assert.AreEqual("((a&b)&c)||d", clause1.ToString());
Assert.AreEqual(7, clause1.Length);
Assert.AreEqual("a=>((b&c)||(d&e))", clause2.ToString());
Assert.AreEqual(9, clause2.Length);
}
public void TestDeMorgan()
{
RephraserType r1 = new DeMorgan(),
r2 = new DeMorgan(),
r3 = new DeMorgan();
r1.AddLeftBlock(ClauseParser.Parse("~(a&b)"));
r2.AddLeftBlock(ClauseParser.Parse("(~a||~b)"));
r3.AddRightBlock(ClauseParser.Parse("~(~(a&c)&~b)"));
Assert.AreEqual("(~a||~b)", r1.Translate().ToString());
Assert.AreEqual("~(a&b)", r2.Translate().ToString());
Assert.AreEqual("((a&c)||b)", r3.Translate().ToString());
}
public void TestModusPonens()
{
RephraserType r1 = new ModusPonens(),
r2 = new ModusPonens(),
r3 = new ModusPonens();
r1.AddLeftBlock(new Block("a")).AddRightBlock(new Block("b"));
r2.AddLeftBlock(ClauseParser.Parse("(a&b)")).AddRightBlock(new Block("c"));
r3.AddLeftBlock(ClauseParser.Parse("(a&b)")).AddRightBlock(ClauseParser.Parse("(c||d)"));
Assert.AreEqual("~a||b", r1.Translate().ToString());
Assert.AreEqual("~(a&b)||c", r2.Translate().ToString());
Assert.AreEqual("~(a&b)||(c||d)", r3.Translate().ToString());
}
public void TestBiconditionalElimination()
{
RephraserType r1 = new BiconditionalElimination(),
r2 = new BiconditionalElimination(),
r3 = new BiconditionalElimination();
r1.AddLeftBlock(new Block("a")).AddRightBlock(new Block("b"));
r2.AddLeftBlock(ClauseParser.Parse("(a&b)")).AddRightBlock(new Block("c"));
r3.AddLeftBlock(ClauseParser.Parse("(a&b)")).AddRightBlock(ClauseParser.Parse("(c||d)"));
Assert.AreEqual("(~a||b)&(a||~b)", r1.Translate().ToString());
Assert.AreEqual("(~(a&b)||c)&((a&b)||~c)", r2.Translate().ToString());
Assert.AreEqual("(~(a&b)||(c||d))&((a&b)||~(c||d))", r3.Translate().ToString());
}
public KnowledgeBase(string tell)
{
// accessing a clause without any whitespaces
string noWhitespaceKB = Regex.Replace(tell, @"\s+", (_) => "");
Knowledges = new List <Block>();
// clauses in tell are separated by ';'
foreach (var clause in noWhitespaceKB.Split(';'))
{
if (clause.Length != 0)
{
Knowledges.Add(ClauseParser.Parse(clause));
}
}
}
public override string GetResult(KnowledgeBase kb, string ask)
{
var askSymbol = ClauseParser.Parse(ask);
var clauses = new List <Block> {
askSymbol.SetNegation(!askSymbol.IsNegated)
};
foreach (var normalClause in kb.Knowledges)
{
clauses.AddRange(new CNFClause(normalClause).Conjunctions);
}
kb.Knowledges.Clear();
kb.Knowledges.AddRange(clauses);
return(base.GetResult(kb, "unsatisfiable").Trim().Trim(':'));
}
public void TestTruthfulTheorems()
{
RephraserType r1 = new TruthfulTheorems(),
r2 = new TruthfulTheorems(),
r3 = new TruthfulTheorems();
r1.AddLeftBlock(new Block("a"))
.AddLogic(PropositionalLogic.Disjunction)
.AddRightBlock(new Block("c"));
r2.AddLeftBlock(new Block("a"))
.AddLogic(PropositionalLogic.Conjunction)
.AddRightBlock(new Block("false"));
r3.AddLeftBlock(ClauseParser.Parse("a"))
.AddLogic(PropositionalLogic.Disjunction)
.AddRightBlock(ClauseParser.Parse("true"));
Assert.AreEqual("a||c", r1.Translate().ToString());
Assert.AreEqual("false", r2.Translate().ToString());
Assert.AreEqual("true", r3.Translate().ToString());
}
public void TestDistribution()
{
RephraserType r1 = new Distribution(),
r2 = new Distribution(),
r3 = new Distribution();
r1.AddLeftBlock(new Block("a"))
.AddLogic(PropositionalLogic.Conjunction)
.AddRightBlock(new Block("b"));
r2.AddLeftBlock(new Block("a"))
.AddLogic(PropositionalLogic.Disjunction)
.AddRightBlock(ClauseParser.Parse("(b&(c||d))"));
r3.AddLeftBlock(ClauseParser.Parse("(b&d)"))
.AddLogic(PropositionalLogic.Disjunction)
.AddRightBlock(new Block("c"));
Assert.AreEqual("a&b", r1.Translate().ToString());
Assert.AreEqual("(a||b)&(a||(c||d))", r2.Translate().ToString());
Assert.AreEqual("(c||b)&(c||d)", r3.Translate().ToString());
}
public override string Prove(KnowledgeBase kb, string ask)
{
HornClauses = new HornClauses(kb.Knowledges);
base.Prove(kb, ask);
return(KBEntails(ClauseParser.Parse(ask)) ? $"YES: {string.Join(", ", Path)}" : "NO");
}
/// <summary>
/// Remove any symbols inside clause, guarantee to also remove its trailing connective.
/// <para>Eg: a||b||c into b||c if removing a or a||c if removing b</para>
/// </summary>
/// <param name="clauses"></param>
/// <param name="symbol"></param>
/// <returns></returns>
private List <Block> RemoveSymbol(List <Block> clauses, Block symbol, bool newList = true)
{
// must specify a fresh copy on demand here because blocks are also objects
// that have memory addresses
var result = !newList ? clauses :
clauses.Select((b) => ClauseParser.Parse(b.ToString())).ToList();
string rawSymbol = symbol.GetContent(true).ToString();
for (int i = 0; i < result.Count; ++i)
{
var root = result[i];
if (root == null)
{
continue;
}
// remove either a symbol or the whole rootBlock
BlockIterator.TerminableForEach(root, (currentBlock) =>
{
if (currentBlock.GetContent(true).ToString() == rawSymbol)
{
// remove the whole clause if it contains the exact content of the symbol
// passed through in this method
// (true in a disjunctive clause means true as a whole)
if (currentBlock.IsNegated == symbol.IsNegated)
{
result.RemoveAt(i--);
return(false);
}
// remove only this symbol if it does not have the same negation
// because when this happens, the symbol within stored list turns out to be false
// which is removable in a sea of disjunctions
bool isEOL = currentBlock.NextBlock == root;
var unaffectedBlock = isEOL ?
currentBlock.PreviousBlock.PreviousBlock :
currentBlock.NextBlock.NextBlock;
// block list contains only 1 block
if (unaffectedBlock == currentBlock)
{
currentBlock.Isolate(true);
result[i] = null;
return(false);
}
if (isEOL)
{
// a||b into b if remove a
unaffectedBlock.RemoveBack(true);
unaffectedBlock.RemoveBack(true);
}
else
{
// a||b||c into a||c if remove b
unaffectedBlock.RemoveFront(true);
unaffectedBlock.RemoveFront(true);
}
if (root == currentBlock)
{
result[i] = unaffectedBlock;
return(false);
}
}
return(true);
});
}
return(result);
}
/// <summary> /// Basic building block of rephraser /// </summary> /// <param name="clause"></param> /// <returns></returns> public Block RephraseIntoBlock(string clause) => RephraseIntoBlock(ClauseParser.Parse(clause));
/// <summary> /// Basic building block of rephraser /// </summary> /// <param name="clause"></param> /// <returns></returns> public string Rephrase(string clause) => Rephrase(ClauseParser.Parse(clause));
