occam-verify-cli 1.0.220 → 1.0.223

package/src/dom/rule.js

@@ -222,7 +222,7 @@ export default domAssigned(class Rule {
           labels = labelsFromJSON(json, fileContext),
           premises = premisesFromJSON(json, fileContext),
           conclusion = conclusionFromJSON(json, fileContext),
-          string = stringFromLabelsAndConclusion(labels, conclusion);
+          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion);
 
     rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
@@ -234,7 +234,7 @@ export default domAssigned(class Rule {
           labels = labelsFromRuleNode(ruleNode, fileContext),
           premises = premisesFromRuleNode(ruleNode, fileContext),
           conclusion = conclusionFromRuleNode(ruleNode, fileContext),
-          string = stringFromLabelsAndConclusion(labels, conclusion),
+          string = stringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
           rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
@@ -281,10 +281,25 @@ function conclusionFromRuleNode(ruleNode, fileContext) {
   return conclusion;
 }
 
-function stringFromLabelsAndConclusion(labels, conclusion) {
-  const conclusionString = conclusion.getString(),
+function premisesStringFromPremises(premises) {
+  const premisesString = premises.reduce((premisesString, premise) => {
+    const premiseString = premise.getString();
+
+    premisesString = (premisesString !== null) ?
+                       `${premisesString}, ${premiseString}` :
+                         premiseString;  ///
+
+    return premisesString;
+  }, null);
+
+  return premisesString;
+}
+
+function stringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
+  const premisesString = premisesStringFromPremises(premises),
+        conclusionString = conclusion.getString(),
         labelsString = labelsStringFromLabels(labels),
-        string = `${labelsString} :: ${conclusionString}`;
+        string = `${labelsString} :: [${premisesString}] ... ${conclusionString}`;
 
   return string;
 }

package/src/dom/statement.js

@@ -224,19 +224,19 @@ export default domAssigned(class Statement {
     return unifiedIndependently;
   }
 
-  unifyWithStepsOrSubproofs(stepsOrSubproofs, context) {
-    let unifiedWithSteps;
+  equateWithStepsOrSubproofs(stepsOrSubproofs, context) {
+    let equateDdWithStepsOrSubproofs;
 
-    unifiedWithSteps = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    equateDdWithStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
       const statement = this, ///
-            statementUnified = stepOrSubproof.unifyStatement(statement, context);
+            statementUnified = stepOrSubproof.equateWithStatement(statement, context);
 
       if (statementUnified) {
         return true;
       }
     });
 
-    return unifiedWithSteps;
+    return equateDdWithStepsOrSubproofs;
   }
 
   toJSON() {

package/src/dom/step.js

@@ -2,8 +2,8 @@
 
 import dom from "../dom";
 import unifyMixins from "../mixins/step/unify";
-import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
+import equationalUnifier from "../unifier/equantional";
 
 import { domAssigned } from "../dom";
 import { propertyAssertionFromStatement } from "../utilities/context";
@@ -105,55 +105,49 @@ export default domAssigned(class Step {
     return verified;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified;
+  equateWithStatement(statement, context) {
+    let statementEquated;
 
-    const substitutions = Substitutions.fromNothing(),
-          generalContext = context, ///
-          specificContext = context; ///
+    const statementA = statement,  ///
+          statementB = this.statement,  ///
+          statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          statementsEquated = equationalUnifier.equateStatements(statementANode, statementBNode, context);
 
-    statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+    statementEquated = statementsEquated;  ///
 
-    if (statementUnified) {
-      substitutions.removeTrivialSubstitutions();
-
-      const equivalences = context.getEquivalences(),
-            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
-
-      statementUnified = substitutionsUnified;  ///
-    }
-
-    return statementUnified;
+    return statementEquated;
   }
 
   unifySatisfiesAssertion(satisfiesAssertion, context) {
     let unifySatisfiesAssertion = false;
 
+    const stepString = this.string, ///
+          satisfiesAssertionString = satisfiesAssertion.getString();
+
+    context.trace(`Unifying hte '${satisfiesAssertionString}' with the '${stepString}' step...`);
+
     const reference = satisfiesAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const axiomUnconditional = axiom.isUnconditional();
-
-      if (axiomUnconditional) {
-        const step = this,  ///
-              fileContext = axiom.getFileContext(),
-              localContext = LocalContext.fromFileContext(fileContext),
-              substitutions = Substitutions.fromNothing(),
-              generalContext = localContext,  ///
-              specificContext = context,  ///
-              statementUnified = axiom.unifyStep(step, substitutions, generalContext, specificContext);
-
-        if (statementUnified) {
-          const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
-
-          if (substitutionsMatch) {
-            unifySatisfiesAssertion = true;
-          }
+      const step = this,  ///
+            substitutions = Substitutions.fromNothing(),
+            statementUnified = axiom.unifyStep(step, substitutions, context);
+
+      if (statementUnified) {
+        const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+
+        if (substitutionsMatch) {
+          unifySatisfiesAssertion = true;
         }
       }
     }
 
+    if (unifySatisfiesAssertion) {
+      context.debug(`...unified hte '${satisfiesAssertionString}' with the '${stepString}' step.`);
+    }
+
     return unifySatisfiesAssertion;
   }
 

package/src/dom/subproof.js

@@ -88,25 +88,10 @@ export default domAssigned(class Subproof {
     return subproofVerified;
   }
 
-  unifyStatement(statement, context) {
+  equateWithStatement(statement, context) {
     let statementUnified = false;
 
-    const subproof = this,
-          substitutions = Substitutions.fromNothing(),
-          generalContext = context, ///
-          specificContext = context, ///
-          subproofUnified = statement.unifySubproof(subproof, substitutions, generalContext, specificContext);
-
-    if (subproofUnified) {
-      if (statementUnified) {
-        const equivalences = context.getEquivalences(),
-              substitutionsUnified = equivalences.unifySubstitutions(substitutions);
-
-        if (substitutionsUnified) {
-          statementUnified = true;
-        }
-      }
-    }
+    debugger
 
     return statementUnified;
   }
@@ -114,20 +99,21 @@ export default domAssigned(class Subproof {
   unifySatisfiesAssertion(satisfiesAssertion, context) {
     let unifySatisfiesAssertion = false;
 
+    const subproofString = this.string, ///
+          satisfiesAssertionString = satisfiesAssertion.getString();
+
+    context.trace(`Unifying the '${satisfiesAssertionString}' satisfies assertion with the '${subproofString}' subproof...`)
+
     const reference = satisfiesAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const axiomUnconditional = axiom.isUnconditional();
+      const axiomSatisfiable = axiom.isSatisfiable();
 
-      if (!axiomUnconditional) {
-        const subproof = this,
-              fileContext = axiom.getFileContext(),
-              localContext = LocalContext.fromFileContext(fileContext),
+      if (axiomSatisfiable) {
+        const subproof = this,  ///
               substitutions = Substitutions.fromNothing(),
-              generalContext = localContext,  ///
-              specificContext = context,  ///
-              statementUnified = axiom.unifySubproof(subproof, substitutions, generalContext, specificContext);
+              statementUnified = axiom.unifySubproof(subproof, substitutions, context);
 
         if (statementUnified) {
           const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
@@ -139,6 +125,10 @@ export default domAssigned(class Subproof {
       }
     }
 
+    if (unifySatisfiesAssertion) {
+      context.debug(`...unified the '${satisfiesAssertionString}' satisfies assertion with the '${subproofString}' subproof.`)
+    }
+
     return unifySatisfiesAssertion;
   }
 

package/src/dom/substitution/term.js

@@ -33,7 +33,7 @@ export default domAssigned(class TermSubstitution extends Substitution {
   }
 
   isTermEqualTo(term, context) {
-    term = stripBracketsFromTerm(term); ///
+    term = stripBracketsFromTerm(term, context); ///
 
     const termEqualTo = this.term.isEqualTo(term);
 
@@ -51,24 +51,6 @@ export default domAssigned(class TermSubstitution extends Substitution {
 
   matchName(name) { return this.variable.matchName(name); }
 
-  unifyWithEquivalence(equivalence) {
-    let unifiedWithEquivalence;
-
-    const termNode = this.term.getNode(),
-          equivalenceMatchesTermNode = equivalence.matchTermNode(termNode);
-
-    if (equivalenceMatchesTermNode) {
-      const variableNode = this.variable.getNode(),
-            equivalenceMatchesVariableNode = equivalence.matchVariableNode(variableNode);
-
-      if (equivalenceMatchesVariableNode) {
-          unifiedWithEquivalence = true;
-        }
-    }
-
-    return unifiedWithEquivalence;
-  }
-
   static fromStatementNode(statementNode, context) {
     let termSubstitution = null;
 

package/src/dom/substitution.js

@@ -153,10 +153,4 @@ export default class Substitution {
 
     return replacementNode;
   }
-
-  unifyWithEquivalence(equivalence) {
-    let unifiedWithEquivalence = false;
-
-    return unifiedWithEquivalence;
-  }
 }

package/src/dom/topLevelAssertion.js

@@ -64,13 +64,6 @@ export default class TopLevelAssertion {
     return supposition;
   }
 
-  isUnconditional() {
-    const suppositionsLength = this.suppositions.length,
-          unconditional = (suppositionsLength === 0);
-
-    return unconditional;
-  }
-
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = this.labels.some((label) => {
       const metavariableNameMatches = label.matchMetavariableName(metavariableName);
@@ -131,35 +124,6 @@ export default class TopLevelAssertion {
     return labelsVerified;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified;
-
-    const statementString = statement.getString(),
-          axiomLemmaTheoremConjecture = this, ///
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
-
-    const suppositions = this.getSuppositions(),
-          suppositionsLength = suppositions.length;
-
-    if (suppositionsLength === 0) {
-      const substitutions = Substitutions.fromNothing(),
-            localContext = LocalContext.fromFileContext(this.fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
-            statementUnifiedWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
-
-      statementUnified = statementUnifiedWithDeduction;  ///
-    }
-
-    if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);
-    }
-
-    return statementUnified;
-  }
-
   unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext) {
     let deductionUnified;
 
@@ -255,7 +219,7 @@ export default class TopLevelAssertion {
           suppositions = suppositionsFromJSON(json, fileContext),
           signature = signatureFromJSON(json, fileContext),
           proof = null,
-          string = stringFromLabelsAndDeduction(labels, deduction),
+          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
@@ -273,7 +237,7 @@ export default class TopLevelAssertion {
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           signature = signatureFromSignatureNode(signatureNode, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
+          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
@@ -342,12 +306,27 @@ export function labelsStringFromLabels(labels) {
   return labelsString;
 }
 
-export function stringFromLabelsAndDeduction(labels, deduction) {
-  const deductionString = deduction.getString(),
+export function suppositionsStringFromSuppositions(suppositions) {
+  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
+    const suppositionString = supposition.getString();
+
+    suppositionsString = (suppositionsString !== null) ?
+                           `${suppositionsString}, ${suppositionString}` :
+                             suppositionString;  ///
+
+    return suppositionsString;
+  }, null);
+
+  return suppositionsString;
+}
+
+export function stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
         labelsString = labelsStringFromLabels(labels),
         string = (labelsString === null) ?
                    deductionString : ///
-                    `${labelsString} :: ${deductionString}`;
+                    `${labelsString} :: [${suppositionsString}] ... ${deductionString}`;
 
   return string;
 }

package/src/dom/topLevelMetaAssertion.js

@@ -128,7 +128,7 @@ export default class TopLevelMetaAssertion {
           suppositions = suppositionsFromJSON(json, fileContext),
           substitutions = substitutionsFromJSON(json, fileContext),
           proof = null,
-          string = stringFromLabelAndDeduction(label, deduction),
+          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
@@ -145,7 +145,7 @@ export default class TopLevelMetaAssertion {
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           substitutions = Substitutions.fromNothing(),
-          string = stringFromLabelAndDeduction(label, deduction),
+          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
@@ -172,12 +172,27 @@ function labelStringFromLabel(label) {
   return labelsString;
 }
 
-function stringFromLabelAndDeduction(label, deduction) {
-  const deductionString = deduction.getString(),
+function suppositionsStringFromSuppositions(suppositions) {
+  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
+    const suppositionString = supposition.getString();
+
+    suppositionsString = (suppositionsString !== null) ?
+                          `${suppositionsString}, ${suppositionString}` :
+                            suppositionString;  ///
+
+    return suppositionsString;
+  }, null);
+
+  return suppositionsString;
+}
+
+function stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
         labelString = labelStringFromLabel(label),
         string = (labelString === null) ?
                     deductionString : ///
-                     `${labelString} :: ${deductionString}`;
+                     `${labelString} :: [${suppositionsString}] ... ${deductionString}`;
 
   return string;
 }

package/src/dom/variable.js

@@ -124,8 +124,9 @@ export default domAssigned(class Variable {
           substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
 
     if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByVariable(variable),
-            substitutionTermEqualToTerm = substitution.isTermEqualTo(term);
+      const context = specificContext,  ///
+            substitution = substitutions.findSubstitutionByVariable(variable),
+            substitutionTermEqualToTerm = substitution.isTermEqualTo(term, context);
 
       if (substitutionTermEqualToTerm) {
         termUnified = true;

package/src/equivalence.js

@@ -1,7 +1,11 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import { stripBracketsFromTermNode } from "./utilities/brackets";
 
+const { compress } = arrayUtilities;
+
 export default class Equivalence {
   constructor(terms) {
     this.terms = terms;
@@ -15,9 +19,23 @@ export default class Equivalence {
     const termString = term.getString(),
           equivalenceString = this.asString(); ///
 
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
+    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence....`);
 
-    this.terms.push(term);
+    const termA = term, ///
+          termPresent = this.someTerm((term) => {
+            const termB = term, ///
+                  termAEqualToTermB = termA.isEqualTo(termB);
+
+            if (termAEqualToTermB) {
+              return true;
+            }
+          });
+
+    if (!termPresent) {
+      this.terms.push(term);
+
+      context.debug(`...added the '${termString}' term to the '${equivalenceString}' equivalence.`);
+    }
   }
 
   getType() {
@@ -40,19 +58,6 @@ export default class Equivalence {
     return type;
   }
 
-  matchType(type) {
-    const typeA = type; ///
-
-    type = this.getType();
-
-    const typeB = type; ///
-
-    const typeAEqualToTypeB = typeA.isEqualTo(typeB),
-          typeMatches = typeAEqualToTypeB;  ///
-
-    return typeMatches;
-  }
-
   equateTerm(term) {
     const termA = term, ///
           termEquates = this.someTerm((term) => {
@@ -112,8 +117,45 @@ export default class Equivalence {
     return variableNodeMatches;
   }
 
+  isDisjointFrom(equivalence) {
+    const disjointFrom = equivalence.everyTerm((term) => {
+      const termEquates = this.equateTerm(term);
+
+      if (!termEquates) {
+        return true;
+      }
+    });
+
+    return disjointFrom;
+  }
+
+  mergedWith(equivalence) {
+    const equivalenceA = this,
+          equivalenceB = equivalence, ///
+          equivalenceATerms = equivalenceA.getTerms(),
+          equivalenceTermsB = equivalenceB.getTerms(),
+          terms = [
+            ...equivalenceATerms,
+            ...equivalenceTermsB
+          ];
+
+    compress(terms, (termA, termB) => {
+      const termAEqualToTermB = termA.isEqualTo(termB);
+
+      if (termAEqualToTermB) {
+        return true;
+      }
+    });
+
+    equivalence = new Equivalence(terms);
+
+    return equivalence;
+  }
+
   someTerm(callback) { return this.terms.some(callback); }
 
+  everyTerm(callback) { return this.terms.every(callback); }
+
   someOtherTerm(term, callback) {
     const termA = term, ///
           terms = this.terms.filter((term) => {
@@ -201,43 +243,24 @@ export default class Equivalence {
   }
 
   asString() {
-    let string;
-
-    string = this.terms.reduce((string, term) => {
-      const termString = term.getString();
-
-      string = (string === null) ?
-                 termString :
-                    `${string} = ${termString}`;
-
-      return string;
-    }, null);
-
     const type = this.getType(),
-          typeString = type.getString();
-
-    string = `${string}:${typeString}`;
+          typeString = type.getString(),
+          termsString = this.terms.reduce((termsString, term) => {
+            const termString = term.getString();
 
-    return string;
-  }
+            termsString = (termsString === null) ?
+                            termString :
+                             `${termsString} = ${termString}`;
 
-  static merge(leftEquivalence, rightEquivalence) {
-    const leftEquivalenceTerms = leftEquivalence.getTerms(),
-          rightEquivalenceTerms = rightEquivalence.getTerms(),
-          terms = [
-            ...leftEquivalenceTerms,
-            ...rightEquivalenceTerms
-          ],
-          equivalence = new Equivalence(terms);
+            return termsString;
+          }, null),
+          string = `${termsString}:${typeString}`;
 
-    return equivalence;
+    return string;
   }
 
-  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
-    const terms = [
-            leftTerm,
-            rightTerm
-          ],
+  static fromEquality(equality) {
+    const terms = equality.getTerms(),
           equivalence = new Equivalence(terms);
 
     return equivalence;