occam-verify-cli 1.0.753 → 1.0.758

package/src/element/proofAssertion/premise.js

@@ -167,21 +167,18 @@ export default define(class Premise extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           premiseContext = this.getContext(), ///
           generalContext = premiseContext, ///
-          specificContext = proofAssertionContext,
-          statementUnifies = reconcile((specificContext) => {
-            const statement = proofAssertion.getStatement(),
-                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          specificContext = proofAssertionContext;  ///
 
-            if (statementUnifies) {
-              specificContext.commit(context);
+    reconcile((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-              return true;
-            }
-          }, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+        proofAssertionUnifies = true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
@@ -193,19 +190,11 @@ export default define(class Premise extends ProofAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const premiseString = this.getString(),
+    const premiseString = this.getString(), ///
           subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
@@ -213,15 +202,16 @@ export default define(class Premise extends ProofAssertion {
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              assertionNode = subproofAssertionNode,  ///
-              assertion = context.findAssertionByAssertionNode(assertionNode)
+        const specificContext = context;  ///
 
-        if (assertion !== null) {
-          const subproofAssertion = assertion;  ///
+        context = this.getContext();
 
-          subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
-        }
+        const generalContext = context, ///
+              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+
+        context = specificContext;  ///
+
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
       }
     }
 

package/src/element/proofAssertion/supposition.js

@@ -121,14 +121,14 @@ export default define(class Supposition extends ProofAssertion {
     let suppositionUnifies;
 
     const context = specificContext,  ///
-      specificSupposition = supposition,  ///
-      generalSuppositionString = this.getString(), ///
-      specificSuppositionString = specificSupposition.getString();
+          specificSupposition = supposition,  ///
+          generalSuppositionString = this.getString(), ///
+          specificSuppositionString = specificSupposition.getString();
 
     context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
 
     const statement = specificSupposition.getStatement(),
-      statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
     suppositionUnifies = statementUnifies;  ///
 
@@ -189,20 +189,18 @@ export default define(class Supposition extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           suppositionContext = this.getContext(),
           generalContext = suppositionContext, ///
-          specificContext = proofAssertionContext,
-          statementUnifies = reconcile((specificContext) => {
-            const statement = proofAssertion.getStatement(),
-                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          specificContext = proofAssertionContext;
 
-            if (statementUnifies) {specificContext.commit(context);
+    reconcile((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-              return true;
-            }
-          }, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+        proofAssertionUnifies = true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
@@ -214,19 +212,11 @@ export default define(class Supposition extends ProofAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const suppositionString = this.getString(),
-          subproofString = subproof.getString();
+    const subproofString = subproof.getString(),
+          suppositionString = this.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
@@ -234,15 +224,16 @@ export default define(class Supposition extends ProofAssertion {
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              assertionNode = subproofAssertionNode,  ///
-              assertion = context.findAssertionByAssertionNode(assertionNode)
+        const specificContext = context;  ///
 
-        if (assertion !== null) {
-          const subproofAssertion = assertion;  ///
+        context = this.getContext();
 
-          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-        }
+        const generalContext = context, ///
+              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+
+        context = specificContext;  ///
+
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
       }
     }
 

package/src/element/reference.js

@@ -249,25 +249,27 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionUnifies;
+  compareTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionCompares = false;
 
     const reference = this, ///
           referenceString = reference.getString(),
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
+    context.trace(`Comparing the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference...`);
 
     const label = topLevelMetaAssertion.getLabel(),
           labelUnifies = this.unifyLabel(label, context);
 
-    topLevelMetaAssertionUnifies = labelUnifies;  ///
+    if (labelUnifies) {
+      topLevelMetaAssertionCompares = true;
+    }
 
-    if (topLevelMetaAssertionUnifies) {
-      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
+    if (topLevelMetaAssertionCompares) {
+      context.trace(`...compared the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference.`);
     }
 
-    return topLevelMetaAssertionUnifies;
+    return topLevelMetaAssertionCompares;
   }
 
   toJSON() {

package/src/element/statement.js

@@ -4,12 +4,12 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
+import { reconcile, instantiate } from "../utilities/context";
 
-const { match, backwardsSome } = arrayUtilities;
+const { backwardsSome } = arrayUtilities;
 
 export default define(class Statement extends Element {
   getStatementNode() {
@@ -33,6 +33,14 @@ export default define(class Statement extends Element {
     return singular;
   }
 
+  isEqualTo(statement) {
+    const statementNode = statement.getNode(),
+          statementNodeMatches = this.matchStatementNode(statementNode),
+          equalTo = statementNodeMatches;  ///
+
+    return equalTo;
+  }
+
   matchStatementNode(statementNode) {
     const node = statementNode, ///
           nodeMatches = this.matchNode(node),
@@ -41,6 +49,48 @@ export default define(class Statement extends Element {
     return statementNodeMatches;
   }
 
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const parameterName = parameter.getName();
+
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
+
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
+      }
+    }
+
+    return comparesToParamter;
+  }
+
+  compareMetavariable(metavariable) {
+    let comparesToMetavariableName;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      let metavariableName;
+
+      metavariableName = metavariable.getName();
+
+      const metavariableNameA = metavariableName; ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    }
+
+    return comparesToMetavariableName;
+  }
+
   compareMetavariableName(metavariableName) {
     let comparesToMetavariableName = false;
 
@@ -59,6 +109,21 @@ export default define(class Statement extends Element {
     return comparesToMetavariableName;
   }
 
+  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
+    let comparesToSubproofOrProofAssertions;
+
+    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+      const statement = this, ///
+            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
+
+      if (subproofOrProofAssertionComparesToStatement) {
+        return true;
+      }
+    });
+
+    return comparesToSubproofOrProofAssertions;
+  }
+
   findValidStatment(context) {
     const statementNode = this.getStatementNode(),
           statement = context.findStatementByStatementNode(statementNode),
@@ -67,14 +132,6 @@ export default define(class Statement extends Element {
     return validStatement;
   }
 
-  isEqualTo(statement) {
-    const statementNode = statement.getNode(),
-          statementNodeMatches = this.matchStatementNode(statementNode),
-          equalTo = statementNodeMatches;  ///
-
-    return equalTo;
-  }
-
   isTermContained(term, context) {
     let termContained;
 
@@ -127,48 +184,6 @@ export default define(class Statement extends Element {
     return frameContained;
   }
 
-  compareParameter(parameter) {
-    let comparesToParamter = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const parameterName = parameter.getName();
-
-      if (parameterName !== null) {
-        const metavariableName = this.getMetavariableName();
-
-        if (parameterName === metavariableName) {
-          comparesToParamter = true;
-        }
-      }
-    }
-
-    return comparesToParamter;
-  }
-
-  compareMetavariable(metavariable) {
-    let comparesToMetavariableName;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      let metavariableName;
-
-      metavariableName = metavariable.getName();
-
-      const metavariableNameA = metavariableName; ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
-    }
-
-    return comparesToMetavariableName;
-  }
-
   validate(stated, context) {
     let statement = null;
 
@@ -208,40 +223,60 @@ export default define(class Statement extends Element {
     let subproofUnifies = false;
 
     const statementNode = this.getStatementNode(),
-          subproofAssertionNode = statementNode.getSubproofAssertionNode(),
-          assertionNode = subproofAssertionNode;  ///
+          subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
-    if (assertionNode !== null) {
+    if (subproofAssertionNode !== null) {
       const context = generalContext, ///
-            assertion = context.findAssertionByAssertionNode(assertionNode),
-            subproofAssertion = assertion;  ///
+            subproofString = subproof.getString(),
+            statementString = this.getString();
 
-      const subproofString = subproof.getString(),
-            subproofAssertionString = subproofAssertion.getString();
+      context.trace(`Unifying the '${subproofString}' subproof with the '${statementString}' statement...`);
 
-      context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+      const subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
 
-      const subproofStatements = subproof.getStatements(),
-            subproofAssertionStatements = subproofAssertion.getStatements();
-
-      subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
-        const generalStatement = subproofAssertionStatement,  ///
-              specificStatement = subproofStatement,  ///
-              statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
-
-        if (statementUnifies) {
-          return true;
-        }
-      });
+      subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
 
       if (subproofUnifies) {
-        context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+        context.debug(`...unified the '${subproofString}' subproof with the '${statementString}' statement.`);
       }
     }
 
     return subproofUnifies;
   }
 
+  unifyDeduction(deduction, generalContext, specificContext) {
+    let deductionUnifies = false;
+
+    const statementString = this.getString(),  ///
+          deductionString = deduction.getString(),
+          deductionStatement = deduction.getStatement(),
+          deductionStatementString = deductionStatement.getString();
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement...`);
+
+    context = deduction.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const deductionStatementUnfies = this.unifyStatement(deductionStatement, generalContext, specificContext);
+
+      if (deductionStatementUnfies) {
+        deductionUnifies = true;
+      }
+    }, specificContext);
+
+    if (deductionUnifies) {
+      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${statementString}' statement.`);
+    }
+
+    return deductionUnifies;
+  }
+
   unifyStatement(statement, generalContext, specificContext) {
     let statementUnifies;
 
@@ -274,13 +309,22 @@ export default define(class Statement extends Element {
           definedAssertionNode = statementNode.getDefinedAssertionNode(),
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
-    if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {
+    if (definedAssertionNode !== null) {
+      const context = generalContext, ///
+            definedAssertion = context.findAssertionByAssertionNode(definedAssertionNode),
+            definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(generalContext, specificContext);
+
+      if (definedAssertionUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (containedAssertionNode !== null) {
       const context = generalContext, ///
-            assertionNode = (definedAssertionNode || containedAssertionNode),
-            assertion = context.findAssertionByAssertionNode(assertionNode),
-            assertionUnifiesIndependently = assertion.unifyIndependently(generalContext, specificContext);
+            containedAssertion = context.findAssertionByAssertionNode(containedAssertionNode),
+            containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(generalContext, specificContext);
 
-      if (assertionUnifiesIndependently) {
+      if (containedAssertionUnifiesIndependently) {
         unifiesIndependently = true;
       }
     }
@@ -292,19 +336,41 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
-    let comparesToSubproofOrProofAssertions;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
+    let topLevelMetaAssertionUnifies = false;
 
-    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-      const statement = this, ///
-            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
+    const context = specificContext,  ///
+          statementString = this.getString(), ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-      if (subproofOrProofAssertionComparesToStatement) {
-        return true;
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement...`);
+
+    const topLevelMetaAssertionUnconditional = topLevelMetaAssertion.isUnconditional();
+
+    if (topLevelMetaAssertionUnconditional) {
+      const deduction = topLevelMetaAssertion.getDeduction(),
+            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+
+      if (deductionUnifies) {
+        topLevelMetaAssertionUnifies = true;
       }
-    });
+    } else {
+      const statementNode = this.getStatementNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
-    return comparesToSubproofOrProofAssertions;
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+
+        topLevelMetaAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
+      }
+    }
+
+    if (topLevelMetaAssertionUnifies) {
+      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement.`);
+    }
+
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/subDerivation.js

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

package/src/element/subproof.js

@@ -30,19 +30,19 @@ export default define(class Subproof extends Element {
     return subproofNode;
   }
 
-  getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
+  getLastStep() { return this.subDerivation.getLastStep(); }
 
   getStatements() {
-    const lastProofAssertion = this.getLastProofAssertion(),
+    const lastStep = this.getLastStep(),
           suppositionStatements = this.suppositions.map((supposition) => {
             const suppositionStatement = supposition.getStatement();
 
             return suppositionStatement;
           }),
-          lastProofAssertionStatement = lastProofAssertion.getStatement(),
+          lastStepStatement = lastStep.getStatement(),
           statements = [
             ...suppositionStatements,
-            lastProofAssertionStatement
+            lastStepStatement
           ];
 
     return statements;