public static int SortOrder(this Negation f) { WFF i = f.inner; if (i is AtomicWFF) { return(0); } else if (i is Biconditional) { return(2); } else if (i is Conditional) { return(1); } else if (i is Conjunction) { return(((Conjunction)i).arity); } else if (i is Disjunction) { return(1); } else if (i is Negation) { return(1); } else if (i is Quantifier) { return(1); } throw new NotImplementedException(f.GetType().ToString()); }
public static bool Decomposable(this Negation f) { WFF i = f.inner; if (i is AtomicWFF) { return(false); } else if (i is Biconditional) { return(true); } else if (i is Conditional) { return(true); } else if (i is Conjunction) { return(true); } else if (i is Disjunction) { return(true); } else if (i is Negation) { return(true); } else if (i is Quantifier) { return(true); } throw new NotImplementedException(f.GetType().ToString()); }
public override Proof Find(WFF f) { Proof a = assumptions.Find(pl => { return(pl.line.Equals(f)); }); if (a != null) { return(a); } foreach (Proof p in steps) { if (p is Subproof) { continue; } a = p.Find(f); if (a != null) { return(a); } } if (parent == null) { return(null); } return(parent.Find(f)); }
public override Proof Find(WFF f) { if (line.Equals(f)) { return(this); } return(null); }
public MainForm() { InitializeComponent(); Icon = TruthTree2.Properties.Resources.Icon; WFF inn = new Negation(new Predicate("A")); WFF tmp1 = new Negation(inn); WFF tmp2 = inn.GetNegation(); Console.WriteLine("{0}\t{1}", tmp1, tmp2); }
public static bool Decomposable(this WFF f) { if (f is AtomicWFF) { return(Decomposable((AtomicWFF)f)); } else if (f is ComplexWFF) { return(Decomposable((ComplexWFF)f)); } throw new NotImplementedException(f.GetType().ToString()); }
public static int SortOrder(this WFF f) { if (f is AtomicWFF) { return(SortOrder((AtomicWFF)f)); } else if (f is ComplexWFF) { return(SortOrder((ComplexWFF)f)); } throw new NotImplementedException(f.GetType().ToString()); }
private List <WFF> IdentityDecompose(Identity i, WFF f) { if (f is AtomicWFF) { return(IdentityDecompose(i, (AtomicWFF)f)); } else if (f is ComplexWFF) { return(IdentityDecompose(i, (ComplexWFF)f)); } throw new NotImplementedException(f.GetType().ToString()); }
private Decomposition DecomposeWFF(WFF f) { if (f is AtomicWFF) { return(DecomposeWFF((AtomicWFF)f)); } else if (f is ComplexWFF) { return(DecomposeWFF((ComplexWFF)f)); } throw new NotImplementedException(f.GetType().ToString()); }
public Tree(List <WFF> s, Tree p = null, WFF d = null, bool rdup = true) { sentences = new List <WFF>(); parent = p; decomposed = d; children = null; if (parent == null) { sentences.AddRange(s); terms = new HashSet <Term>(); foreach (WFF f in sentences) { if (f == null) { continue; } terms.UnionWith(f.GetTerms()); } } else { List <WFF> all = getAllSentences(); foreach (WFF f in s) { if (f == null) { continue; } if (rdup) { if (!all.Contains(f)) { sentences.Add(f); all.Add(f); } } else { sentences.Add(f); } } terms = new HashSet <Term>(parent.terms); } }
public bool Decompose() { checkForCompletion(); if (State != TreeState.Incomplete) { return(false); } List <WFF> unsatisfied = getAllUnsatisfied(); unsatisfied.Sort((a, b) => { return(a.SortOrder().CompareTo(b.SortOrder())); }); if (unsatisfied.Count < 1) { throw new Exception("How did this even happen?"); } for (int a = 0; a < unsatisfied.Count; a++) { Decomposition dec = DecomposeWFF(unsatisfied[a]); if (dec == null) { continue; } children = dec.getTrees(this); if (children == null) { continue; } decomposed = dec.decomposed; return(true); } return(false); }
internal static void AddTree(this Subproof p, Tree t) { if (t == null) { throw new ArgumentNullException(); } if (t.State != TreeState.Closed) { throw new InvalidOperationException(); } if (t.decomposed == null) { // Something got a contradiction here, find out what List <WFF> all = t.getAllSentences(); WFF c1 = null; WFF c2 = null; for (int a = 0; a < all.Count; a++) { if (all[a] is Negation) { Negation n = (Negation)all[a]; if (n.inner is Identity) { Identity i = (Identity)n.inner; if (i.left.Equals(i.right)) { c1 = all[a]; break; } } } else if (all[a] is Contradiction) { c1 = all[a]; break; } bool found = false; for (int b = a + 1; b < all.Count; b++) { if (all[a].Equals(all[b].GetNegation()) || all[b].Equals(all[a].GetNegation())) { c1 = all[a]; c2 = all[b]; found = true; break; } } if (found) { break; } } Proof p1 = p.Find(c1); if (p1 == null) { throw new InvalidOperationException("p1"); } if (c2 == null) { p.steps.Add(new ProofLine(new Contradiction(), Rule.ContradictionIntro, p1)); } else { Proof p2 = p.Find(c2); if (p2 == null) { throw new InvalidOperationException("p2"); } p.steps.Add(new ProofLine(new Contradiction(), Rule.ContradictionIntro, p1, p2)); } return; } Proof d = p.Find(t.decomposed); if (t.decomposed is Biconditional) { // Add the steps for Equiv Biconditional b = (Biconditional)t.decomposed; Disjunction equ = new Disjunction( new Conjunction(b.left, b.right), new Conjunction(b.left.GetNegation(), b.right.GetNegation())); ProofLine equp = new ProofLine(equ, Rule.Equivalence, d); p.steps.Add(equp); ProofLine plleft = new ProofLine(equ.disjuncts[0], Rule.Assumption); Subproof left = new Subproof(); left.parent = p; left.assumptions.Add(plleft); left.steps.Add(new ProofLine(b.left, Rule.AndElim, plleft)); left.steps.Add(new ProofLine(b.right, Rule.AndElim, plleft)); AddTree(left, t.children[0]); p.steps.Add(left); ProofLine plright = new ProofLine(equ.disjuncts[1], Rule.Assumption); Subproof right = new Subproof(); right.parent = p; right.assumptions.Add(plright); right.steps.Add(new ProofLine(b.left.GetNegation(), Rule.AndElim, plright)); right.steps.Add(new ProofLine(b.right.GetNegation(), Rule.AndElim, plright)); AddTree(right, t.children[1]); p.steps.Add(right); p.steps.Add(new ProofLine(new Contradiction(), Rule.OrElim, equp, left, right)); } else if (t.decomposed is Conditional) { // Add the steps for Impl Conditional c = (Conditional)t.decomposed; Disjunction imp = new Disjunction(c.antecedent.GetNegation(), c.consequent); ProofLine impp = new ProofLine(imp, Rule.Implication, d); p.steps.Add(impp); Proof[] steps = new Proof[t.children.Length + 1]; steps[0] = impp; for (int a = 0; a < t.children.Length; a++) { steps[a + 1] = new Subproof(); Subproof s = (Subproof)steps[a + 1]; s.parent = p; s.assumptions.Add(new ProofLine(t.children[a].sentences[0], Rule.Assumption)); AddTree(s, t.children[a]); p.steps.Add(s); } p.steps.Add(new ProofLine(new Contradiction(), Rule.OrElim, steps)); } else if (t.decomposed is Conjunction) { foreach (WFF f in t.children[0].sentences) { p.steps.Add(new ProofLine(f, Rule.AndElim, d)); } AddTree(p, t.children[0]); } else if (t.decomposed is Disjunction) { Proof[] steps = new Proof[t.children.Length + 1]; steps[0] = d; for (int a = 0; a < t.children.Length; a++) { steps[a + 1] = new Subproof(); Subproof s = (Subproof)steps[a + 1]; s.parent = p; s.assumptions.Add(new ProofLine(t.children[a].sentences[0], Rule.Assumption)); AddTree(s, t.children[a]); p.steps.Add(s); } p.steps.Add(new ProofLine(new Contradiction(), Rule.OrElim, steps)); } else if (t.decomposed is Existential) { Subproof sub = new Subproof(); sub.parent = p; sub.assumptions.Add(new ProofLine(t.children[0].sentences[0], Rule.Assumption)); AddTree(sub, t.children[0]); p.steps.Add(sub); p.steps.Add(new ProofLine(new Contradiction(), Rule.ExistentialElim, d, sub)); } else if (t.decomposed is Identity) { // Need to add some way to find the other source foreach (WFF f in t.children[0].sentences) { p.steps.Add(new ProofLine(f, Rule.EqualsElim, d)); } AddTree(p, t.children[0]); } else if (t.decomposed is Negation) { Negation n = (Negation)t.decomposed; if (n.inner is Biconditional) { // I really hope there is a better way for this one // Add the steps for DeM and Equiv Biconditional b = (Biconditional)n.inner; ProofLine equ = new ProofLine(new Negation(new Conjunction(new Disjunction(b.left.GetNegation(), b.right), new Disjunction(b.left, b.right.GetNegation()))), Rule.Equivalence, d); p.steps.Add(equ); ProofLine dem = new ProofLine(new Disjunction(new Negation(new Disjunction(b.left.GetNegation(), b.right)), new Negation(new Disjunction(b.left, b.right.GetNegation()))), Rule.DeMorgans, equ); p.steps.Add(dem); Subproof left = new Subproof(); left.parent = p; ProofLine plleft = new ProofLine(new Negation(new Disjunction(b.left.GetNegation(), b.right)), Rule.Assumption); left.assumptions.Add(plleft); ProofLine demleft = new ProofLine(new Conjunction(b.left, b.right.GetNegation()), Rule.DeMorgans, plleft); left.steps.Add(demleft); left.steps.Add(new ProofLine(b.left, Rule.AndElim, demleft)); left.steps.Add(new ProofLine(b.right.GetNegation(), Rule.AndElim, demleft)); AddTree(left, t.children[1]); p.steps.Add(left); Subproof right = new Subproof(); right.parent = p; ProofLine plright = new ProofLine(new Negation(new Disjunction(b.left, b.right.GetNegation())), Rule.Assumption); right.assumptions.Add(plright); ProofLine demright = new ProofLine(new Conjunction(b.left.GetNegation(), b.right), Rule.DeMorgans, plright); right.steps.Add(demright); right.steps.Add(new ProofLine(b.left.GetNegation(), Rule.AndElim, demright)); right.steps.Add(new ProofLine(b.right, Rule.AndElim, demright)); AddTree(right, t.children[0]); p.steps.Add(right); p.steps.Add(new ProofLine(new Contradiction(), Rule.OrElim, dem, left, right)); } else if (n.inner is Conditional) { // Add the steps for DeM and Impl Conditional c = (Conditional)n.inner; ProofLine imp = new ProofLine(new Negation(new Disjunction(c.antecedent.GetNegation(), c.consequent)), Rule.Implication, d); p.steps.Add(imp); ProofLine dem = new ProofLine(new Conjunction(c.antecedent, c.consequent.GetNegation()), Rule.DeMorgans, imp); p.steps.Add(dem); p.steps.Add(new ProofLine(c.antecedent, Rule.AndElim, dem)); p.steps.Add(new ProofLine(c.consequent.GetNegation(), Rule.AndElim, dem)); AddTree(p, t.children[0]); } else if (n.inner is Conjunction) { // Add the steps for DeM Conjunction i = (Conjunction)n.inner; List <WFF> neg = new List <WFF>(); foreach (WFF f in i.conjuncts) { neg.Add(f.GetNegation()); } Disjunction dem = new Disjunction(neg.ToArray()); ProofLine demp = new ProofLine(dem, Rule.DeMorgans, d); p.steps.Add(demp); Proof[] steps = new Proof[t.children.Length + 1]; steps[0] = demp; for (int a = 0; a < t.children.Length; a++) { steps[a + 1] = new Subproof(); Subproof s = (Subproof)steps[a + 1]; s.parent = p; s.assumptions.Add(new ProofLine(t.children[a].sentences[0], Rule.Assumption)); AddTree(s, t.children[a]); p.steps.Add(s); } p.steps.Add(new ProofLine(new Contradiction(), Rule.OrElim, steps)); } else if (n.inner is Disjunction) { // Add the steps for DeM Disjunction i = (Disjunction)n.inner; List <WFF> neg = new List <WFF>(); foreach (WFF f in i.disjuncts) { neg.Add(f.GetNegation()); } Conjunction dem = new Conjunction(neg.ToArray()); ProofLine demp = new ProofLine(dem, Rule.DeMorgans, d); p.steps.Add(demp); foreach (WFF f in t.children[0].sentences) { p.steps.Add(new ProofLine(f, Rule.AndElim, demp)); } AddTree(p, t.children[0]); } else if (n.inner is Existential) { // Add the steps for DeM p.steps.Add(new ProofLine(t.children[0].sentences[0], Rule.DeMorgans, d)); AddTree(p, t.children[0]); } else if (n.inner is Negation) { p.steps.Add(new ProofLine(t.children[0].sentences[0], Rule.NotElim, d)); AddTree(p, t.children[0]); } else if (n.inner is Universal) { // Add the steps for DeM p.steps.Add(new ProofLine(t.children[0].sentences[0], Rule.DeMorgans, d)); AddTree(p, t.children[0]); } } else if (t.decomposed is Universal) { foreach (WFF f in t.children[0].sentences) { p.steps.Add(new ProofLine(f, Rule.UniversalElim, d)); } AddTree(p, t.children[0]); } }
public Universal(Variable v, WFF s) { variable = v; scope = s; }
public Existential(Variable v, WFF s) { variable = v; scope = s; }
internal Decomposition(WFF d, params List <WFF>[] c) { decomposed = d; decomposition = c; }
public ProofLine(WFF l, Rule r, params Proof[] s) { line = l; rule = r; reasons = new List <Proof>(s); }
private void bParse_Click(object sender, EventArgs e) { premises = new List <WFF>(); rtbPremisesOut.Text = ""; foreach (string l in rtbPremisesIn.Text.Trim().Split('\n')) { if (l.Length < 1) { continue; } WFF f = Parser.parseString(l.Trim()); if (f != null) { premises.Add(f); rtbPremisesOut.AppendText(f + "\n"); } else { MessageBox.Show(string.Format("Error parsing premise {{{0}}}", l.Trim())); rtbPremisesOut.Text = ""; return; } } conclusion = Parser.parseString(rtbConclusionIn.Text); if (conclusion == null) { MessageBox.Show(string.Format("Error parsing conclusion {{{0}}}", rtbConclusionIn.Text)); rtbPremisesOut.Text = ""; return; } rtbConclusionOut.Text = String.Format("{0}", conclusion); List <WFF> sentences = new List <WFF>(premises); sentences.Add(conclusion.GetNegation()); worker = new Worker <Tree>( () => { Tree t = new Tree(sentences); t.Satisfy(); return(t); }); worker.WorkFinished += workComplete; tree = null; proof = null; setStatus("Initialized"); setEnabled(bParse, true); setEnabled(bSatisfy, true); setEnabled(bStop, false); setEnabled(bShowTree, false); setEnabled(bShowProof, false); setEnabled(bSaveTree, false); setEnabled(bSaveProof, false); setTab(1); }
public abstract Proof Find(WFF f);