occam-verify-cli 1.0.956 → 1.0.973

package/src/element/substitution/statement.js

@@ -7,7 +7,7 @@ import { breakPointFromJSON } from "../../utilities/breakPoint";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, ablates, manifest, attempts, sequester, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -173,7 +173,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (targetStatementSingular) {
       manifest((context) => {
-        sequester((context) => {
+        elide((context) => {
           const targetStatement = this.targetStatement.validate(context);
 
           if (targetStatement !== null) {
@@ -202,7 +202,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution's replacement statement...`);
 
-    sequester((context) => {
+    elide((context) => {
       const replacementStatement = this.replacementStatement.validate(context);
 
       if (replacementStatement !== null) {
@@ -236,17 +236,15 @@ export default define(class StatementSubstitution extends Substitution {
           generalStatement = generalSubstitutionTargetStatement, ///
           specificStatement = specificSubstitutionTargetStatement; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (statementUnifies) {
-          specificContext.commit(context);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-          targetStatemnentUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        targetStatemnentUnifies = true;
+      }
+    }, specificContext);
 
     if (targetStatemnentUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's target statement with the '${generalSubstitutionString}' substitution's target statement.`);
@@ -274,17 +272,15 @@ export default define(class StatementSubstitution extends Substitution {
           generalStatement = generalSubstitutionReplacementStatement, ///
           specificStatement = specificSubstitutionReplacementStatement; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (statementUnifies) {
-          specificContext.commit(context);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-          replacementStatemnentUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        replacementStatemnentUnifies = true;
+      }
+    }, specificContext);
 
     if (replacementStatemnentUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement statement with the '${generalSubstitutionString}' substitution's replacement statement.`);
@@ -358,27 +354,24 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialises((json, generalContext, specificContext) => {
-        const context = specificContext;  ///
-
-        instantiate((context) => {
+      instantiate((context) => {
+        unserialises((json, generalContext, specificContext) => {
           const { string } = json,
                 statementSubstitutionNode = instantiateStatementSubstitution(string, context),
                 node = statementSubstitutionNode, ///
                 breakPoint = breakPointFromJSON(json),
                 resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context),
                 substitution = substitutionFromStatementSubstitutionNode(statementSubstitutionNode, generalContext, specificContext),
-                targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-                replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-                specificContext = context,  ///
+                targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, generalContext),
+                replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, specificContext),
                 contexts = [
                   generalContext,
                   specificContext
                 ];
 
           statementSubstitutionn = new StatementSubstitution(contexts, string, node, breakPoint, resolved, substitution, targetStatement, replacementStatement);
-        }, context);
-      }, json, context);
+        }, json, context);
+      }, context);
     }
 
     return statementSubstitutionn;
@@ -444,16 +437,16 @@ function substitutionFromStatementSubstitutionNode(statementSubstitutionNode, co
   return substitution;
 }
 
-function targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+function targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, generalContext) {
   const targetStatementNode = statementSubstitutionNode.getTargetStatementNode(),
-        targetStatement = context.findStatementByStatementNode(targetStatementNode);
+        targetStatement = generalContext.findStatementByStatementNode(targetStatementNode);
 
   return targetStatement;
 }
 
-function replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+function replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, specificContext) {
   const replacementStatementNode = statementSubstitutionNode.getReplacementStatementNode(),
-        replacementStatement = context.findStatementByStatementNode(replacementStatementNode);
+        replacementStatement = specificContext.findStatementByStatementNode(replacementStatementNode);
 
   return replacementStatement;
 }

package/src/element/substitution/term.js

@@ -8,7 +8,7 @@ import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
-import { join, ablate, ablates, manifest, attempts, reconcile, sequester, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablate, manifest, attempts, reconcile, ablates, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, breakPoint, targetTerm, replacementTerm) {
@@ -139,7 +139,7 @@ export default define(class TermSubstitution extends Substitution {
 
     if (targetTermSingular) {
       manifest((context) => {
-        sequester((context) => {
+        elide((context) => {
           const targetTerm = this.targetTerm.validate(context, (targetTerm, context) => {
             const validatesForwards = true;
 
@@ -174,7 +174,7 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution's replacement term...`);
 
-    sequester((context) => {
+    elide((context) => {
       const replacementTerm = this.replacementTerm.validate(context, (replacementTerm, context) => {
         const validatesForwards = true;
 
@@ -245,24 +245,21 @@ export default define(class TermSubstitution extends Substitution {
           generalTerm = generalSubstitutionTargetTerm, ///
           specificTerm = specificSubstitutionTargetTerm; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const generalTermNode = generalTerm.getNode(),
-              generalVariable = variableFromTermNode(generalTermNode, generalContext);
+    reconcile((specificContext) => {
+      const termNode = generalTerm.getNode(),
+            variable = variableFromTermNode(termNode, generalContext);
 
-        if (generalVariable !== null) {
-          const term = specificTerm,  ///
-                variable = generalVariable, ///
-                termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+      if (variable !== null) {
+        const term = specificTerm,  ///
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
 
-          if (termUnifies) {
-            specificContext.commit(context);
+        if (termUnifies) {
+          specificContext.commit(context);
 
-            targetTermUnifies = true;
-          }
+          targetTermUnifies = true;
         }
-      }, specificContext);
-    }, specificContext, context);
+      }
+    }, specificContext);
 
     if (targetTermUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's target term with the '${generalSubstitutionString}' substitution's target term.`);
@@ -290,24 +287,21 @@ export default define(class TermSubstitution extends Substitution {
           generalTerm = generalSubstitutionReplacementTerm, ///
           specificTerm = specificSubstitutionReplacementTerm; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const generalTermNode = generalTerm.getNode(),
-              generalVariable = variableFromTermNode(generalTermNode, generalContext);
+    reconcile((specificContext) => {
+      const termNode = generalTerm.getNode(),
+            variable = variableFromTermNode(termNode, generalContext);
 
-        if (generalVariable !== null) {
-          const term = specificTerm,  ///
-                variable = generalVariable, ///
-                termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+      if (variable !== null) {
+        const term = specificTerm,  ///
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
 
-          if (termUnifies) {
-            specificContext.commit(context);
+        if (termUnifies) {
+          specificContext.commit(context);
 
-            replacementTermUnifies = true;
-          }
+          replacementTermUnifies = true;
         }
-      }, specificContext);
-    }, specificContext, context);
+      }
+    }, specificContext);
 
     if (replacementTermUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement term with the '${generalSubstitutionString}' substitution's replacement term.`);
@@ -324,25 +318,22 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialises((json, generalContext, specificContext) => {
-        const context = specificContext;  ///
-
-        instantiate((context) => {
+      instantiate((context) => {
+        unserialises((json, generalContext, specificContext) => {
           const { string } = json,
                 termSubstitutionNode = instantiateTermSubstitution(string, context),
                 node = termSubstitutionNode,  ///
                 breakPoint = breakPointFromJSON(json),
-                targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
-                replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context),
-                specificContext = context,  ///
+                targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, generalContext),
+                replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, specificContext),
                 contexts = [
                   generalContext,
                   specificContext
                 ];
 
           termSubstitutionn = new TermSubstitution(contexts, string, node, breakPoint, targetTerm, replacementTerm);
-        }, context);
-      }, json, context);
+        }, json, context);
+      }, context);
     }
 
     return termSubstitutionn;
@@ -389,28 +380,28 @@ export default define(class TermSubstitution extends Substitution {
   }
 });
 
-function variableFromTermNode(termNode, context) {
+function variableFromTermNode(termNode, generalContext) {
   let variable = null;
 
   const variableNode = termNode.getVariableNode();
 
   if (variableNode !== null) {
-    variable = context.findVariableByVariableNode(variableNode);
+    variable = generalContext.findVariableByVariableNode(variableNode);
   }
 
   return variable;
 }
 
-function targetTermFromTermSubstitutionNode(termSubstitutionNode, context) {
+function targetTermFromTermSubstitutionNode(termSubstitutionNode, generalContext) {
   const targetTermNode = termSubstitutionNode.getTargetTermNode(),
-        targetTerm = context.findTermByTermNode(targetTermNode);
+        targetTerm = generalContext.findTermByTermNode(targetTermNode);
 
   return targetTerm;
 }
 
-function replacementTermFromTermSubstitutionNode(termSubstitutionNode, context) {
+function replacementTermFromTermSubstitutionNode(termSubstitutionNode, specificContext) {
   const replacementTermNode = termSubstitutionNode.getReplacementTermNode(),
-        replacementTerm = context.findTermByTermNode(replacementTermNode);
+        replacementTerm = specificContext.findTermByTermNode(replacementTermNode);
 
   return replacementTerm;
 }

package/src/element/term.js

@@ -5,7 +5,7 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
-import { validateTerms } from "../utilities/validation";
+import { validateTerms } from "../process/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { variablesFromTerm } from "../utilities/equivalence";
 import { unifyTermIntrinsically } from "../process/unify";

package/src/element/topLevelAssertion/axiom.js

@@ -5,7 +5,7 @@ import { asynchronousUtilities } from "occam-languages";
 import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
-import { join, reconcile } from "../../utilities/context";
+import { reconcile } from "../../utilities/context";
 
 const { asyncMatch } = asynchronousUtilities;
 
@@ -86,11 +86,9 @@ export default define(class Axiom extends TopLevelAssertion {
 
     signature = this.getSignature();
 
-    const generalSignature = signature, ///
-          specificContext = context,  ///
-          generalContext = null;
+    const generalSignature = signature; ///
 
-    signatureUnifies = generalSignature.unifySignature(specificSignature, generalContext, specificContext);
+    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
 
     if (signatureUnifies) {
       context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
@@ -112,31 +110,29 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context.trace(`Unifying the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction...`);
 
-    const specificDeductionContext = specificDeduction.getContext(),
-          generalDeductionContext = generalDeduction.getContext(),
-          specificContext = specificDeductionContext,  ///
-          generalContext = generalDeductionContext; ///
+    const generalDeductionContext = generalDeduction.getContext(),
+          specificDeductionContext = specificDeduction.getContext(),
+          generalContext = generalDeductionContext, ///
+          specificContext = specificDeductionContext; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        let statement;
+    reconcile((specificContext) => {
+      let statement;
 
-        statement = specificDeduction.getStatement();
+      statement = specificDeduction.getStatement();
 
-        const specificStatement = statement;  ///
+      const specificStatement = statement;  ///
 
-        statement = generalDeduction.getStatement();
+      statement = generalDeduction.getStatement();
 
-        const generalStatement = statement, ///
-              statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
+      const generalStatement = statement, ///
+            statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (statementUnifies) {
-          specificContext.commit();
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-          deductionUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        deductionUnifies = true;
+      }
+    }, specificContext);
 
     if (deductionUnifies) {
       context.debug(`...unified the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction.`);
@@ -159,31 +155,29 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
 
-    const specificSuppositionContext = specificSupposition.getContext(),
-          generalSuppositionContext = generalSupposition.getContext(),
-          specificContext = specificSuppositionContext,  ///
-          generalContext = generalSuppositionContext; ///
+    const generalSuppositionContext = generalSupposition.getContext(),
+          specificSuppositionContext = specificSupposition.getContext(),
+          generalContext = generalSuppositionContext, ///
+          specificContext = specificSuppositionContext; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        let statement;
+    reconcile((specificContext) => {
+      let statement;
 
-        statement = specificSupposition.getStatement();
+      statement = specificSupposition.getStatement();
 
-        const specificStatement = statement;  ///
+      const specificStatement = statement;  ///
 
-        statement = generalSupposition.getStatement();
+      statement = generalSupposition.getStatement();
 
-        const generalStatement = statement, ///
-              statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
+      const generalStatement = statement, ///
+            statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (statementUnifies) {
-          specificContext.commit();
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-          suppositionUnifies = true;
-        }
-      }, specificContext);
-    }, specificContext, context);
+        suppositionUnifies = true;
+      }
+    }, specificContext);
 
     if (suppositionUnifies) {
       context.debug(`...unified the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
@@ -225,11 +219,15 @@ export default define(class Axiom extends TopLevelAssertion {
           deductionUnifies = await this.unifyDeduction(deduction, context);
 
     if (deductionUnifies) {
-      const suppositions = topLevelAssertion.getSuppositions(),
-            suppositionsUnify = await this.unifySuppositions(suppositions, context);
+      const hypothesesDischarged = await topLevelAssertion.dischargeHypotheses(context);
+
+      if (hypothesesDischarged) {
+        const suppositions = topLevelAssertion.getSuppositions(),
+              suppositionsUnify = await this.unifySuppositions(suppositions, context);
 
-      if (suppositionsUnify) {
-        topLevelAssertionUnifies = true;
+        if (suppositionsUnify) {
+          topLevelAssertionUnifies = true;
+        }
       }
     }
 

package/src/element/topLevelAssertion.js

@@ -18,7 +18,7 @@ import { labelsFromJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
 const { reverse } = arrayUtilities,
-      { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
+      { asyncEvery, asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelAssertion extends Element {
   constructor(context, string, node, breakPoint, labels, suppositions, deduction, proof, signature, hypotheses) {
@@ -257,6 +257,38 @@ export default class TopLevelAssertion extends Element {
     return suppositionsVerify;
   }
 
+  async dischargeHypothesis(hypothesis, context) {
+    let hypothesisDischarged;
+
+    await this.break(context);
+
+    const hypothesisString = hypothesis.getString(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Discharding the '${topLevelAssertionString}' top level assertion's '${hypothesisString}' hypothesis... `);
+
+    hypothesisDischarged = hypothesis.discharge(context);
+
+    if (hypothesisDischarged) {
+      context.trace(`...discharged the '${topLevelAssertionString}' top level assertion's '${hypothesisString}' hypothesis. `);
+    }
+
+    return hypothesisDischarged;
+  }
+
+  async dischargeHypotheses(context) {
+    const hypotheses = this.getHypotheses(),
+          hypothesesDischarged = await asyncEvery(hypotheses, async (hypothesis) => {
+            const hypothesisDischarged = await this.dischargeHypothesis(hypothesis, context);
+
+            if (hypothesisDischarged) {
+              return true;
+            }
+          });
+
+    return hypothesesDischarged;
+  }
+
   async unifyStepWithDeduction(step, context) {
     let stepUnifiesWithDeduction = false;
 
@@ -286,13 +318,17 @@ export default class TopLevelAssertion extends Element {
     const stepUnifiesWithDeduction = await this.unifyStepWithDeduction(step, context);
 
     if (stepUnifiesWithDeduction) {
-      const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
+      const hypothesesDischarged = await this.dischargeHypotheses(context);
 
-      if (subproofOrProofAssertionsUnifiesWithSuppositions) {
-        const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
+      if (hypothesesDischarged) {
+        const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
-        if (derivedSubstitutionsResolved) {
-          stepAndSubproofOrProofAssertionsUnify = true;
+        if (subproofOrProofAssertionsUnifiesWithSuppositions) {
+          const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
+
+          if (derivedSubstitutionsResolved) {
+            stepAndSubproofOrProofAssertionsUnify = true;
+          }
         }
       }
     }

package/src/element/topLevelMetaAssertion.js

@@ -2,7 +2,7 @@
 
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { enclose } from "../utilities/context";
+import { encapsulate } from "../utilities/context";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
 import { labelFromJSON,
@@ -103,7 +103,7 @@ export default class TopLevelMetaAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion...`);
 
-    await enclose(async (context) => {
+    await encapsulate(async (context) => {
       const labelVerifies = this.verifyLabel(context);
 
       if (labelVerifies) {

package/src/process/discharge.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import elements from "../elements";
+
+function dischargeStatementAsTypeAssertion(statement, context) {
+  let dischargesStatementAsTypeAssertion = false;
+
+  const { TypeAssertion } = elements;
+
+  const typeAssertion = TypeAssertion.fromStatement(statement, context);
+
+  if (typeAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a type assertion...`);
+
+    const discharges = typeAssertion.discharge(context);  ///
+
+    if (discharges !== null) {
+      dischargesStatementAsTypeAssertion = true;
+    }
+
+    if (dischargesStatementAsTypeAssertion) {
+      context.debug(`...discharged the '${statementString}' statement as a type assertion.`);
+    }
+  }
+
+  return dischargesStatementAsTypeAssertion;
+}
+
+export const dischargeStatements = [
+  dischargeStatementAsTypeAssertion
+];