occam-verify-cli 1.0.747 → 1.0.757

package/src/element/statement.js

@@ -4,12 +4,12 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { literally } 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() {
@@ -319,7 +385,7 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   static fromJSON(json, context) {
-    const statement = literally((context) => {
+    const statement = instantiate((context) => {
       const { string } = json,
             statementNode = instantiateStatement(string, context),
             node = statementNode; ///

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

@@ -3,7 +3,7 @@
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 
 const { asyncEvery } = asynchronousUtilities;
 
@@ -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;
@@ -63,7 +63,7 @@ export default define(class Subproof extends Element {
   async verify(context) {
     let verifies = false;
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const suppositionsVerify = await this.verifySuppositions(context);
 
       if (suppositionsVerify) {

package/src/element/substitution/frame.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
@@ -121,7 +121,7 @@ export default define(class FrameSubstitution extends Substitution {
           targetFrameString = this.targetFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame...`);
 
     const targetFrameSingular = this.targetFrame.isSingular();
 
@@ -135,11 +135,11 @@ export default define(class FrameSubstitution extends Substitution {
         targetFrameValidates = true;
       }
     } else {
-      context.debug(`The '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame is not singular.`);
+      context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
     }
 
     if (targetFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame...`);
     }
 
     return targetFrameValidates;
@@ -152,7 +152,7 @@ export default define(class FrameSubstitution extends Substitution {
           replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
 
     const stated = true,
           replacementFrame = this.replacementFrame.validate(stated, context);
@@ -164,7 +164,7 @@ export default define(class FrameSubstitution extends Substitution {
     }
 
     if (replacementFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame.`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);
     }
 
     return replacementFrameValidates;
@@ -178,7 +178,7 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               frameSubstitutionNode = instantiateFrameSubstitution(string, context),
               node = frameSubstitutionNode,  ///
@@ -202,7 +202,7 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    return literally((context) => {
+    return instantiate((context) => {
       const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
             string = frameSubstitutionString,  ///
             frameSubstitutionNode = instantiateFrameSubstitution(string, context),

package/src/element/substitution/metaLevel.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateMetaLevelSubstitution } from "../../process/instantiate";
 import { metaLevelSubstitutionFromMetaLevelSubstitutionNode } from "../../utilities/element";
 import { metaLevelSubstitutionStringFromStatementAndReference } from "../../utilities/string";
@@ -111,7 +111,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
           targetReferenceString = this.targetReference.getString(),
           metaLevelSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level subtitution's '${targetReferenceString}' target reference...`);
+    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution's '${targetReferenceString}' target reference...`);
 
     const targetReference = this.targetReference.validate(context);
 
@@ -120,7 +120,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
     }
 
     if (targetReferenceValidates) {
-      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level subtitution's '${targetReferenceString}' target reference...`);
+      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level substitution's '${targetReferenceString}' target reference...`);
     }
 
     return targetReferenceValidates;
@@ -133,7 +133,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
           replacementStatementString = this.replacementStatement.getString(),
           metaLevelSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level subtitution's '${replacementStatementString}' replacement statement...`);
+    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement...`);
 
     const stated = true,
       replacementStatement = this.replacementStatement.validate(stated, context);
@@ -143,7 +143,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
     }
 
     if (replacementStatementValidates) {
-      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level subtitution's '${replacementStatementString}' replacement statement.`);
+      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement.`);
     }
 
     return replacementStatementValidates;
@@ -176,7 +176,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
 
     context = ephemeralContext; ///
 
-    const metaLevelSubstitution = literally((context) => {
+    const metaLevelSubstitution = instantiate((context) => {
       const { string } = json,
             metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
             targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
@@ -191,7 +191,7 @@ export default define(class MetaLevelSubstitution extends Substitution {
   }
 
   static fromStatementAndReference(statement, reference, context) {
-    return literally((context) => {
+    return instantiate((context) => {
       const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
             string = metaLevelSubstitutionString,  ///
             metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),

package/src/element/substitution/reference.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
@@ -121,7 +121,7 @@ export default define(class ReferenceSubstitution extends Substitution {
           targetReferenceString = this.targetReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
 
     const targetReference = this.targetReference.validate(context);
 
@@ -130,7 +130,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     }
 
     if (targetReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
     }
 
     return targetReferenceValidates;
@@ -143,7 +143,7 @@ export default define(class ReferenceSubstitution extends Substitution {
           replacementReferenceString = this.replacementReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference...`);
 
     const replacementReference = this.replacementReference.validate(context);
 
@@ -152,7 +152,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     }
 
     if (replacementReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference.`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference.`);
     }
 
     return replacementReferenceValidates;
@@ -166,7 +166,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
               node = referenceSubstitutionNode,  ///
@@ -183,7 +183,7 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
-    return literally((context) => {
+    return instantiate((context) => {
       const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
             string = referenceSubstitutionString,  ///
             referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),