occam-verify-cli 1.0.211 → 1.0.219

package/src/dom/axiom.js

@@ -1,14 +1,10 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import LocalContext from "../context/local";
 import TopLevelAssertion  from "./topLevelAssertion";
 
 import { domAssigned } from "../dom";
 
-const { match } = arrayUtilities;
-
 export default domAssigned(class Axiom extends TopLevelAssertion {
   isSatisfiable() {
     const signature = this.getSignature(),
@@ -60,7 +56,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return signatureVerified;
   }
 
-  matchSignature(signature, substitutions, generalContext, specificContext) {
+  matchSignature(signature, substitutions, context) {
     let signatureMatches = false;
 
     const satisfiable = this.isSatisfiable();
@@ -72,138 +68,179 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
       const signatureB = signature; ///
 
+      const fileContext = this.getFileContext(),
+            localContext = LocalContext.fromFileContext(fileContext),
+            generalContext = localContext,  ///
+            specificContext = context;  ///
+
       signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
     }
 
     return signatureMatches;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    const deduction = this.getDeduction(),
-          statementUnified = deduction.unifyStatement(statement, substitutions, generalContext, specificContext);
+  unifyStep(step, substitutions, generalContext, specificContext) {
+    let stepUnified = false;
 
-    return statementUnified;
+    const context = specificContext,  ///
+          stepString = step.getString(),
+          axiomString = this.string;  ///
+
+    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
+
+    const statement = step.getStatement(),
+          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      stepUnified = true;
+    }
+
+    if (stepUnified) {
+      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
+    }
+
+    return stepUnified;
   }
 
-  unifyDeduction(generalDeduction, specificDeduction, substitutions, generalContext, specificContext) {
-    let deductionUnified;
+  unifyLastStep(lastStep, substitutions, generalContext, specificContext) {
+    let lastStepUnified = false;
 
     const context = specificContext,  ///
-          generalDeductionString = generalDeduction.getString(),
-          specificDeductionString = specificDeduction.getString();
+          axiomString = this.string,  ///
+          lastStepString = lastStep.getString();
 
-    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
+    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`)
 
-    const statement = specificDeduction.getStatement(),
-          statementUnified = generalDeduction.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const step = lastStep,  ///
+          stepUnified = this.unifyStep(step, substitutions, generalContext, specificContext);
 
-    deductionUnified = statementUnified;  ///
+    if (stepUnified) {
+      lastStepUnified = true;
+    }
 
-    if (deductionUnified) {
-      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);
+    if (lastStepUnified) {
+      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`)
     }
 
-    return deductionUnified;
+    return lastStepUnified;
   }
 
-  unifySupposition(generalSupposition, specificSupposition, substitutions, generalContext, specificContext) {
-    let suppositionUnified;
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnified = false;
 
     const context = specificContext,  ///
-          generalSuppositionString = generalSupposition.getString(),
-          specificSuppositionString = specificSupposition.getString();
+          axiomString = this.string,  ///
+          subproofString = subproof.getString();
 
-    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
 
-    const statement = specificSupposition.getStatement(),
-          statementUnified = generalSupposition.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const lastStep = subproof.getLastStep(),
+          lastStepUnified = this.unifyLastStep(lastStep, substitutions, generalContext, specificContext);
 
-    suppositionUnified = statementUnified;  ///
+    if (lastStepUnified) {
+      const suppositions = subproof.getSuppositions(),
+            suppositionsUnified = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-    if (suppositionUnified) {
-      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
+      if (suppositionsUnified) {
+        subproofUnified = true;
+      }
     }
 
-    return suppositionUnified;
+    if (subproofUnified) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
+    }
+
+    return subproofUnified;
   }
 
-  unifySuppositions(generalSuppositions, specificSuppositions, substitutions, generalContext, specificContext) {
-    let suppositionsUnified;
+  unifyDeduction(deduction, substitutions, generalContext, specificContext) {
+    let deductionUnified;
 
-    const suppositionsMatch = match(generalSuppositions, specificSuppositions, (generalSupposition, specificSupposition) => {
-      const suppositionUnified = this.unifySupposition(generalSupposition, specificSupposition, substitutions, generalContext, specificContext);
+    const specificDeduction = deduction;  ///
 
-      if (suppositionUnified) {
-        return true;
-      }
-    });
+    deduction = this.getDeduction();
 
-    suppositionsUnified = suppositionsMatch;  ///
+    const generalDeduction = deduction; ///
 
-    return suppositionsUnified;
-  }
+    deduction = specificDeduction;  ///
 
-  unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context) {
-    let axiomLemmaTheoremConjectureUnified = false;
+    deductionUnified = generalDeduction.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
-    const axiomString = this.getString(),
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
+    return deductionUnified;
+  }
 
-    context.trace(`Unifying the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
+  unifySupposition(supposition, index, substitutions, generalContext, specificContext) {
+    let suppositionUnified;
 
-    const fileContext = this.getFileContext(),
-          generalContext = fileContext, ///
-          specificContext = context;  ///
+    const specificSupposition = supposition;  ///
 
-    let deduction;
+    supposition = this.getSupposition(index);
 
-    deduction = this.getDeduction();
+    const generalSupposition = supposition; ///
 
-    const generalDeduction = deduction; ///
+    supposition = specificSupposition;  ///
 
-    deduction = axiomLemmaTheoremConjecture.getDeduction();
+    suppositionUnified = generalSupposition.unifySupposition(supposition, substitutions, generalContext, specificContext);
 
-    const specificDeduction = deduction,  ///
-          deductionUnified = this.unifyDeduction(generalDeduction, specificDeduction, substitutions, generalContext, specificContext);
+    return suppositionUnified;
+  }
 
-    if (deductionUnified) {
-      let suppositions;
+  unifySuppositions(suppositions, substitutions, generalContext, specificContext) {
+    let suppositionsUnified = false;
 
-      suppositions = this.getSuppositions();
+    const specificSuppositions = suppositions;  ///
 
-      const generalSuppositions = suppositions; ///
+    suppositions = this.getSuppositions();
 
-      suppositions = axiomLemmaTheoremConjecture.getSuppositions();
+    const generalSuppositions = suppositions, ///
+          generalSuppositionsLength = generalSuppositions.length,
+          specificSuppositionsLength = specificSuppositions.length;
 
-      const specificSuppositions = suppositions,  ///
-            suppositionsUnified = this.unifySuppositions(generalSuppositions, specificSuppositions, substitutions, generalContext, specificContext);
+    if (generalSuppositionsLength === specificSuppositionsLength) {
+      suppositions = specificSuppositions;  ///
 
-      axiomLemmaTheoremConjectureUnified = suppositionsUnified; ///
-    }
+      const suppositionsMatch = suppositions.every((supposition, index) => {
+        const suppositionUnified = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
 
-    if (axiomLemmaTheoremConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
+        if (suppositionUnified) {
+          return true;
+        }
+      });
+
+      if (suppositionsMatch) {
+        suppositionsUnified = true;
+      }
     }
 
-    return axiomLemmaTheoremConjectureUnified;
+    return suppositionsUnified;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
-    let statementAndStepsOrSubproofsUnified = false;
+  unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context) {
+    let axiomLemmaTheoremConjectureUnified = false;
 
-    const satisfiable = this.isSatisfiable();
+    const axiomString = this.getString(),
+          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
 
-    if (satisfiable) {
-      const string = this.getString(),
-            axiomString = string, ///
-            statementString = statement.getString();
+    context.trace(`Unifying the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
+
+    const deduction = axiomLemmaTheoremConjecture.getDeduction(),  ///
+          fileContext = this.getFileContext(),
+          generalContext = fileContext, ///
+          specificContext = context,  ///
+          deductionUnified = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
-      context.debug(`The '${statementString}' statement cannot be unified with the '${axiomString}' axiom because the latter is satisfiable.`);
-    } else {
-      statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+    if (deductionUnified) {
+      const suppositions = axiomLemmaTheoremConjecture.getSuppositions(),
+            suppositionsUnified = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
+
+      axiomLemmaTheoremConjectureUnified = suppositionsUnified; ///
+    }
+
+    if (axiomLemmaTheoremConjectureUnified) {
+      context.debug(`...unified the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
     }
 
-    return statementAndStepsOrSubproofsUnified;
+    return axiomLemmaTheoremConjectureUnified;
   }
 
   static name = "Axiom";

package/src/dom/deduction.js

@@ -61,6 +61,28 @@ export default domAssigned(class Deduction {
     return statementUnified;
   }
 
+  unifyDeduction(deduction, substitutions, generalContext, specificContext) {
+    let deductionUnified;
+
+    const context = specificContext,  ///
+          specificDeduction = deduction,  ///
+          generalDeductionString = this.string, ///
+          specificDeductionString = specificDeduction.getString();
+
+    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
+
+    const statement = specificDeduction.getStatement(),
+          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    deductionUnified = statementUnified;  ///
+
+    if (deductionUnified) {
+      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);
+    }
+
+    return deductionUnified;
+  }
+
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///

package/src/dom/metavariable.js

@@ -430,7 +430,7 @@ export default domAssigned(class Metavariable {
           typeJSON = typeToTypeJSON(this.type),
           type = typeJSON,  ///
           metaType = metaTypeJSON,  ///
-          string = this.string,
+          string = this.string, ///
           json = {
             string,
             type,

package/src/dom/rule.js

@@ -119,7 +119,7 @@ export default domAssigned(class Rule {
     if (premiseUnifiedIndependently) {
       stepsOrSubproofsUnifiedWithPremise = true;
     } else {
-      const step = extract(stepsOrSubproofs, (stepOrSubproof) => {
+      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
         const stepOrSubproofUnified = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
         if (stepOrSubproofUnified) {
@@ -127,7 +127,7 @@ export default domAssigned(class Rule {
         }
       }) || null;
 
-      if (step !== null) {
+      if (stepOrSubproof !== null) {
         stepsOrSubproofsUnifiedWithPremise = true;
       }
     }

package/src/dom/step.js

@@ -2,6 +2,7 @@
 
 import dom from "../dom";
 import unifyMixins from "../mixins/step/unify";
+import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
@@ -75,7 +76,7 @@ export default domAssigned(class Step {
   verify(substitutions, assignments, context) {
     let verified = false;
 
-    const stepString = this.string;
+    const stepString = this.string; ///
 
     context.trace(`Verifying the '${stepString}' step...`);
 
@@ -107,13 +108,15 @@ export default domAssigned(class Step {
   unifyStatement(statement, context) {
     let statementUnified;
 
-    const specificContext = context, ///
+    const substitutions = Substitutions.fromNothing(),
           generalContext = context, ///
-          substitutions = Substitutions.fromNothing();
+          specificContext = context; ///
 
     statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
+      substitutions.removeTrivialSubstitutions();
+
       const equivalences = context.getEquivalences(),
             substitutionsUnified = equivalences.unifySubstitutions(substitutions);
 
@@ -123,6 +126,37 @@ export default domAssigned(class Step {
     return statementUnified;
   }
 
+  unifySatisfiesAssertion(satisfiesAssertion, context) {
+    let unifySatisfiesAssertion = false;
+
+    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;
+          }
+        }
+      }
+    }
+
+    return unifySatisfiesAssertion;
+  }
+
   static name = "Step";
 
   static fromStatement(statement, context) {

package/src/dom/subproof.js

@@ -54,32 +54,10 @@ export default domAssigned(class Subproof {
     return sStep;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified;
-
-    const specificContext = context, ///
-          generalContext = context, ///
-          substitutions = Substitutions.fromNothing(),
-          subproof = this;
-
-    const subproofUnified = statement.unifySubproof(subproof, substitutions, generalContext, specificContext);
-
-    statementUnified = subproofUnified; ///
-
-    if (statementUnified) {
-      const equivalences = context.getEquivalences(),
-            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
-
-      statementUnified = substitutionsUnified;  ///
-    }
-
-    return statementUnified;
-  }
-
   unify(substitutions, context) {
     let unified;
 
-    unified = true;
+    unified = true; ///
 
     return unified;
   }
@@ -110,6 +88,60 @@ export default domAssigned(class Subproof {
     return subproofVerified;
   }
 
+  unifyStatement(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;
+        }
+      }
+    }
+
+    return statementUnified;
+  }
+
+  unifySatisfiesAssertion(satisfiesAssertion, context) {
+    let unifySatisfiesAssertion = false;
+
+    const reference = satisfiesAssertion.getReference(),
+          axiom = context.findAxiomByReference(reference);
+
+    if (axiom !== null) {
+      const axiomUnconditional = axiom.isUnconditional();
+
+      if (!axiomUnconditional) {
+        const subproof = this,
+              fileContext = axiom.getFileContext(),
+              localContext = LocalContext.fromFileContext(fileContext),
+              substitutions = Substitutions.fromNothing(),
+              generalContext = localContext,  ///
+              specificContext = context,  ///
+              statementUnified = axiom.unifySubproof(subproof, substitutions, generalContext, specificContext);
+
+        if (statementUnified) {
+          const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+
+          if (substitutionsMatch) {
+            unifySatisfiesAssertion = true;
+          }
+        }
+      }
+    }
+
+    return unifySatisfiesAssertion;
+  }
+
   static name = "Subproof";
 
   static fromStepOrSubproofNode(sStepOrSubproofNode, fileContext) {

package/src/dom/substitution/term.js

@@ -24,6 +24,14 @@ export default domAssigned(class TermSubstitution extends Substitution {
     return this.variable;
   }
 
+  isTrivial() {
+    const termString = this.term.getString(),
+          variableString = this.variable.getString(),
+          trivial = (termString === variableString);
+
+    return trivial;
+  }
+
   isTermEqualTo(term, context) {
     term = stripBracketsFromTerm(term); ///
 

package/src/dom/substitution.js

@@ -74,6 +74,12 @@ export default class Substitution {
     return complex;
   }
 
+  isTrivial() {
+    const trivial = false;
+
+    return trivial;
+  }
+
   isEqualTo(substitution) {
     const substitutionString = substitution.getString(),
           equalTo = (substitutionString === this.string);

package/src/dom/supposition.js

@@ -72,6 +72,28 @@ export default domAssigned(class Supposition {
     return verified;
   }
 
+  unifySupposition(supposition, substitutions, generalContext, specificContext) {
+    let suppositionUnified;
+
+    const context = specificContext,  ///
+          specificSupposition = supposition,  ///
+          generalSuppositionString = this.string, ///
+          specificSuppositionString = specificSupposition.getString();
+
+    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
+
+    const statement = specificSupposition.getStatement(),
+          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    suppositionUnified = statementUnified;  ///
+
+    if (suppositionUnified) {
+      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
+    }
+
+    return suppositionUnified;
+  }
+
   unifyIndependently(substitutions, context) {
     let unifiedIndependently;
 

package/src/dom/term.js

@@ -176,7 +176,7 @@ export default domAssigned(class Term {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string,
+          string = this.string, ///
           type = typeJSON,  ///
           json = {
             type,

package/src/dom/topLevelAssertion.js

@@ -58,6 +58,19 @@ export default class TopLevelAssertion {
 
   getStatement() { return this.deduction.getStatement(); }
 
+  getSupposition(index) {
+    const supposition = this.suppositions[index] || null;
+
+    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);
@@ -179,7 +192,7 @@ export default class TopLevelAssertion {
   }
 
   unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiedWithSupposition  =false;
+    let stepsOrSubproofsUnifiedWithSupposition = false;
 
     const context = specificContext,  ///
           suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, context);
@@ -187,15 +200,15 @@ export default class TopLevelAssertion {
     if (suppositionUnifiedIndependently) {
       stepsOrSubproofsUnifiedWithSupposition = true;
     } else {
-      const step = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepUnified = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
+        const stepOrSubproofUnified = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
-        if (stepUnified) {
+        if (stepOrSubproofUnified) {
           return true;
         }
       }) || null;
 
-      if (step !== null) {
+      if (stepOrSubproof !== null) {
         stepsOrSubproofsUnifiedWithSupposition = true;
       }
     }