occam-verify-cli 1.0.753 → 1.0.758

package/src/context/file/nominal.js

@@ -473,9 +473,9 @@ export default class NominalFileContext extends FileContext {
     filter(metaLemmas, (metaLemma) => {
       const context = this, ///
             topLevelMetaAssertion = metaLemma, ///
-            topLevelMetaAssertionUnifies = reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-      if (topLevelMetaAssertionUnifies) {
+      if (topLevelMetaAssertionCompares) {
         return true;
       }
     });
@@ -502,9 +502,9 @@ export default class NominalFileContext extends FileContext {
     filter(metatheorems, (metatheorem) => {
       const context = this, ///
             topLevelMetaAssertion = metatheorem, ///
-            topLevelMetaAssertionUnifies = reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+            topLevelMetaAssertionCompares = reference.compareTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-      if (topLevelMetaAssertionUnifies) {
+      if (topLevelMetaAssertionCompares) {
         return true;
       }
     });

package/src/context/scoped.js

@@ -101,17 +101,19 @@ class ScopedContext extends Context {
     return proofAssertions;
   }
 
-  getLastProofAssertion() {
-    let lastProofAssertion = null;
+  getLastStep() {
+    let lastStep = null;
 
     const proofAssertions = this.getProofAssertions(),
           proofAssertionsLength = proofAssertions.length;
 
     if (proofAssertionsLength > 0) {
-      lastProofAssertion = last(proofAssertions);
+      const lastProofAssertion = last(proofAssertions);
+
+      lastStep = lastProofAssertion;  ///
     }
 
-    return lastProofAssertion;
+    return lastStep;
   }
 
   hasMetaLevelSubstitutions() {

package/src/context/synthetic.js

@@ -13,6 +13,12 @@ export default class SyntheticContext extends Context {
     return this.contexts;
   }
 
+  addSubstitutions(substitutions) {
+    const context = this.getContext();
+
+    context.addSubstitutions(substitutions);
+  }
+
   findTermByTermNode(termNode) {
     let term = null;
 

package/src/element/assertion/contained.js

@@ -206,7 +206,7 @@ export default define(class ContainedAssertion extends Assertion {
     context.trace(`Validating the '${containedAssertionString}' derived contained assertion...`);
 
     const generalCotnext = null,
-          specificContext = context; ///
+          specificContext = context;  ///
 
     validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
 

package/src/element/assertion/subproof.js

@@ -5,11 +5,11 @@ import { arrayUtilities } from "necessary";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { reconcile } from "../../utilities/context";
 import { instantiate } from "../../utilities/context";
-import { unifyStatement } from "../../process/unify";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
-const { match } = arrayUtilities;
+const { last, front, backwardsEvery } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
   constructor(context, string, node, statements) {
@@ -22,6 +22,26 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
+  getLastStatement() {
+    const lastStatement = last(this.statements);
+
+    return lastStatement;
+  }
+
+  getSupposedStatement(index) {
+    const statement = this.statements[index],
+          supposedStatement = statement;  ///
+
+    return supposedStatement;
+  }
+
+  getSupposedStatements() {
+    const frontStatements = front(this.statements),
+          supposedStatements = frontStatements;  ///
+
+    return supposedStatements;
+  }
+
   getSubproofAssertionNode() {
     const node = this.getNode(),
           subproofAssertionNode = node; ///
@@ -86,33 +106,186 @@ export default define(class SubproofAssertion extends Assertion {
   }
 
   unifySubproof(subproof, generalContext, specificContext) {
-    let subproofUnifies;
+    let subproofUnifies = false;
 
-    const subproofString = subproof.getString(),
-          subproofAssertionString = this.getString();  ///
+    const context = specificContext,  ///
+          subproofString = subproof.getString(),
+          subproofAssertionString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
-    const subproofStatements = subproof.getStatements(),
-          subproofAssertionStatements = this.statements;  ///
+    const lastStep = subproof.getLastStep(),
+          lastStepUnifies = this.unifyLastStep(lastStep, generalContext, specificContext);
 
-    subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
-      const generalStatement = subproofAssertionStatement,  ///
-            specificStatement = subproofStatement,  ///
-            statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
+    if (lastStepUnifies) {
+      const suppositions = subproof.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-      if (statementUnifies) {
-        return true;
+      if (suppositionsUnify) {
+        subproofUnifies = true;
       }
-    });
+    }
 
     if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+      context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
     }
 
     return subproofUnifies;
   }
 
+  unifyLastStep(lastStep, generalContext, specificContext) {
+    let lastStepUnifies = false;
+
+    const lastStatement = this.getLastStatement(),
+          lastStepString = lastStep.getString(),
+          lastStepStatement = lastStep.getStatement(),
+          lastStatementString = lastStatement.getString(),
+          subproofAssertionString = this.getString(), ///
+          lastStepStatementString = lastStepStatement.getString();
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+
+    context = lastStep.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const lastStepStatementUnifies = lastStatement.unifyStatement(lastStepStatement, generalContext, specificContext);
+
+      if (lastStepStatementUnifies) {
+        lastStepUnifies = true;
+      }
+    }, specificContext);
+
+    if (lastStepUnifies) {
+      context.debug(`...unified the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+    }
+
+    return lastStepUnifies;
+  }
+
+  unifyDeduction(deduction, generalContext, specificContext) {
+    let deductionUnifies = false;
+
+    const lastStatement = this.getLastStatement(),
+          deductionString = deduction.getString(),
+          deductionStatement = deduction.getStatement(),
+          lastStatementString = lastStatement.getString(),
+          subproofAssertionString = this.getString(), ///
+          deductionStatementString = deductionStatement.getString();
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+
+    context = deduction.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const deductionStatementUnifies = lastStatement.unifyStatement(deductionStatement, generalContext, specificContext);
+
+      if (deductionStatementUnifies) {
+        deductionUnifies = true;
+      }
+    }, specificContext);
+
+    if (deductionUnifies) {
+      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+    }
+
+    return deductionUnifies;
+  }
+
+  unifySupposition(supposition, index, generalContext, specificContext) {
+    let suppositionUnifies = false;
+
+    const supposedStatement = this.getSupposedStatement(index),
+          suppositionString = supposition.getString(),
+          suppositionStatement = supposition.getStatement(),
+          subproofAssertionString = this.getString(), ///
+          supposedStatementString = supposedStatement.getString(),
+          suppositionStatementString = suppositionStatement.getString();  ///
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement...`)
+
+    context = supposition.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const suppositionStatementUnifies = supposedStatement.unifyStatement(suppositionStatement, generalContext, specificContext);
+
+      if (suppositionStatementUnifies) {
+        suppositionUnifies = true;
+      }
+    }, specificContext);
+
+    if (suppositionUnifies) {
+      context.debug(`...unified the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement.`)
+    }
+
+    return suppositionUnifies;
+  }
+
+  unifySuppositions(suppositions, generalContext, specificContext) {
+    let suppositionsUnify = false;
+
+    const supposedStatements = this.getSupposedStatements(),
+          suppositionsLength = suppositions.length,
+          supposedStatementsLength = supposedStatements.length;
+
+    if (suppositionsLength === supposedStatementsLength) {
+      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
+        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
+
+        if (suppositionUnifies) {
+          return true;
+        }
+      });
+    }
+
+    return suppositionsUnify;
+  }
+
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
+    let topLevelMetaAssertionUnifies = false;
+
+    const context = specificContext,  ///
+          subproofAssertionString = this.getString(),  ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
+
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion...`);
+
+    const deduction = topLevelMetaAssertion.getDeduction(),
+          deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+
+    if (deductionUnifies) {
+      const suppositions = topLevelMetaAssertion.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+
+      if (suppositionsUnify) {
+        topLevelMetaAssertionUnifies = true;
+      }
+    }
+
+    if (topLevelMetaAssertionUnifies) {
+      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return topLevelMetaAssertionUnifies;
+  }
+
   static name = "SubproofAssertion";
 
   static fromJSON(json, context) {

package/src/element/assumption.js

@@ -3,16 +3,15 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
-import { unifyStatementIntrinsically } from "../process/unify";
+import { instantiate, reconcile } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
     super(context, string, node);
 
-    this.statement = statement;
     this.reference = reference;
+    this.statement = statement;
   }
 
   getReference() {
@@ -166,7 +165,7 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenStated(context) {
-    let validatesWhenStated;
+    let validatesWhenStated = false;
 
     const assumptionString = this.getString();  ///
 
@@ -179,15 +178,17 @@ export default define(class Assumption extends Element {
       validatesWhenStated = true;
     } else {
       const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
-            topLevelMetaAssertionsUnify = topLevelMetaAssertions.every((topLevelMetaAssertion) => {
-              const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+            topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
+              const topLevelMetaAssertionCompares = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-              if (topLevelMetaAssertionUnifies) {
+              if (topLevelMetaAssertionCompares) {
                 return true;
               }
             });
 
-      validatesWhenStated = topLevelMetaAssertionsUnify; ///
+      if (topLevelMetaAssertionsCompare) {
+        validatesWhenStated = true;
+      }
     }
 
     if (validatesWhenStated) {
@@ -198,7 +199,7 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived;
+    let validatesWhenDerived = false;
 
     const assumptionString = this.getString();  ///
 
@@ -206,7 +207,9 @@ export default define(class Assumption extends Element {
 
     const topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(this.reference);
 
-    validatesWhenDerived = topLevelMetaAssertionPresent; ///
+    if (topLevelMetaAssertionPresent) {
+      validatesWhenDerived = true;
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${assumptionString}' derived assumption.`);
@@ -215,28 +218,6 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnifies;
-
-    const context = generalContext,  ///
-          statementString = statement.getString(),
-          assumptionStatementString = this.statement.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${assumptionStatementString}' statement...`);
-
-    const generalStatement = this.statement,
-          specificStatement = statement,  ///
-          statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
-
-    statementUnifies = statementUUnifiesIntrinsically;  ///
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${assumptionStatementString}' statement.`);
-    }
-
-    return statementUnifies;
-  }
-
   unifyLabel(label, generalContext, specificContext) {
     let labelUnifiesWithReference;
 
@@ -269,30 +250,18 @@ export default define(class Assumption extends Element {
 
     context = topLevelMetaAssertion.getContext();  ///
 
-    const specificContext = context,  ///
-          labelSubstitutions = [],
-          label = topLevelMetaAssertion.getLabel(),
-          substitutions = labelSubstitutions, ///
-          labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
+    const specificContext = context;  ///
 
-    if (labelUnifies) {
-      const statementSubstitutions = [],
-            statement = topLevelMetaAssertion.getStatement(),
-            substitutions = statementSubstitutions, ///
-            statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const label = topLevelMetaAssertion.getLabel(),
+            labelUnifies = this.unifyLabel(label, generalContext, specificContext);
 
-      if (statementUUnifies) {
-        const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
-
-        if (labelSubstitutionsCorrelateStatementSubstitutions) {
-          topLevelMetaAssertionUnifies = true; ///
-        }
+      if (labelUnifies) {
+        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
       }
-    }
+    }, specificContext);
 
     if (topLevelMetaAssertionUnifies) {
-      context = generalContext; ///
-
       context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
     }
 

package/src/element/conclusion.js

@@ -163,10 +163,3 @@ export  default define(class Conclusion extends Element {
     return conclusion;
   }
 });
-
-function statementFromConclusionNode(conclusionNode, context) {
-  const statementNode = conclusionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/deduction.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, instantiate } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
+import { statementFromDeductionNode } from "../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
 export default define(class Deduction extends Element {
@@ -30,9 +31,9 @@ export default define(class Deduction extends Element {
 
     await this.break(context);
 
-    const duductionString = this.getString();  ///
+    const deductionString = this.getString();  ///
 
-    context.trace(`Verifying the '${duductionString}' duduction...`);
+    context.trace(`Verifying the '${deductionString}' deduction...`);
 
     if (this.statement !== null) {
       const validates = this.validate(context);
@@ -41,11 +42,11 @@ export default define(class Deduction extends Element {
         verifies = true;
       }
     } else {
-      context.debug(`Unable to verify the '${duductionString}' duduction because it is nonsense.`);
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${duductionString}' duduction.`);
+      context.debug(`...verified the '${deductionString}' deduction.`);
     }
 
     return verifies;
@@ -54,9 +55,9 @@ export default define(class Deduction extends Element {
   validate(context) {
     let validates = false;
 
-    const duductionString = this.getString();  ///
+    const deductionString = this.getString();  ///
 
-    context.trace(`Validating the '${duductionString}' duduction...`);
+    context.trace(`Validating the '${deductionString}' deduction...`);
 
     attempt((context) => {
       const statementValidates = this.validateStatement(context);
@@ -69,7 +70,7 @@ export default define(class Deduction extends Element {
     }, context);
 
     if (validates) {
-      context.debug(`...validated the '${duductionString}' duduction.`);
+      context.debug(`...validated the '${deductionString}' deduction.`);
     }
 
     return validates;
@@ -79,9 +80,9 @@ export default define(class Deduction extends Element {
     let statementValidates;
 
     const statementString = this.statement.getString(),
-          duductionnString = this.getString();  ///
+          deductionnString = this.getString();  ///
 
-    context.trace(`Validating the '${duductionnString}' duductionn's '${statementString}' statement...`);
+    context.trace(`Validating the '${deductionnString}' deductionn's '${statementString}' statement...`);
 
     const stated = true,
           statement = this.statement.validate(stated, context);
@@ -91,7 +92,7 @@ export default define(class Deduction extends Element {
     }
 
     if (statementValidates) {
-      context.trace(`...validated the '${duductionnString}' duductionn's '${statementString}' statement.`);
+      context.trace(`...validated the '${deductionnString}' deductionn's '${statementString}' statement.`);
     }
 
     return statementValidates;
@@ -174,23 +175,16 @@ export default define(class Deduction extends Element {
 
     context = ephemeralContext; ///
 
-    const duduction = instantiate((context) => {
+    const deduction = instantiate((context) => {
       const { string } = json,
             deductionNode = instantiateDeduction(string, context),
             node = deductionNode,  ///
             statement = statementFromDeductionNode(deductionNode, context),
-            duduction = new Deduction(context, string, node, statement);
+            deduction = new Deduction(context, string, node, statement);
 
-      return duduction;
+      return deduction;
     }, context);
 
-    return duduction;
+    return deduction;
   }
 });
-
-function statementFromDeductionNode(deductionNode, context) {
-  const statementNode = deductionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/derivation.js

@@ -28,11 +28,12 @@ export default define(class Derivation extends Element {
     return derivationNode;
   }
 
-  getLastProofAssertion() {
+  getLastStep() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
-          lastProofAssertion = lastSubproofOrProofAssertion;  ///
+          lastProofAssertion = lastSubproofOrProofAssertion,  ///
+          lastStep = lastProofAssertion;  ///
 
-    return lastProofAssertion;
+    return lastStep;
   }
 
   async verify(context) {

package/src/element/metavariable.js

@@ -297,6 +297,11 @@ export default define(class Metavariable extends Element {
               substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
         if (substitutionFrameComparesToFrame) {
+          const frameSubstitution = substitution, ///
+                frameSubstitutionString = frameSubstitution.getString();
+
+          context.trace(`The '${frameSubstitutionString}' frame substitution is already present.`);
+
           frameUnifies = true;
         }
       } else {
@@ -333,8 +338,6 @@ export default define(class Metavariable extends Element {
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-
-
     context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const metavariable = this, ///
@@ -356,6 +359,11 @@ export default define(class Metavariable extends Element {
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
         if (substitutionComparesToStatement) {
+          const statementSubstitution = substitution, //
+                statementSubstitutionString = statementSubstitution.getString();
+
+          context.trace(`The '${statementSubstitutionString}' statement substitution is already present.`);
+
           statementUnifies = true;
         }
       } else {
@@ -413,6 +421,11 @@ export default define(class Metavariable extends Element {
               substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
         if (substitutionReferenceComparesToReference) {
+          const referenceSubstitution = substitution, ///
+                referenceSubstitutionString = referenceSubstitution.getString();
+
+          context.trace(`The '${referenceSubstitutionString}' reference substitution is already present.`);
+
           referenceUnifies = true;
         }
       } else {

package/src/element/proof.js

@@ -23,12 +23,12 @@ export default define(class Proof extends Element {
     return proofNode;
   }
 
-  getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
+  getLastStep() { return this.derivation.getLastStep(); }
 
   getStatement() {
-    const lastProofAssertion = this.getLastProofAssertion(),
-          lastProofAssertionStatement = lastProofAssertion.getStatement(),
-          statement = lastProofAssertionStatement; ///
+    const lastStep = this.getLastStep(),
+          lastStepStatement = lastStep.getStatement(),
+          statement = lastStepStatement; ///
 
     return statement;
   }
@@ -40,9 +40,9 @@ export default define(class Proof extends Element {
       const derivationVerifies = await this.derivation.verify(context);
 
       if (derivationVerifies) {
-        const lastProofAssertion = context.getLastProofAssertion();
+        const lastStep = context.getLastStep();
 
-        if (lastProofAssertion !== null) {
+        if (lastStep !== null) {
           const proof = this, ///
                 proofStatement = proof.getStatement(),
                 proofStatementEqualToStatement = proofStatement.isEqualTo(statement);