occam-verify-cli 1.0.762 → 1.0.768

package/src/context/nominal.js

@@ -14,7 +14,7 @@ const { nominalLexerFromNothing } = lexersUtilities,
 const nominalLexer = nominalLexerFromNothing(NominalLexer),
       nominalParser = nominalParserFromNothing(NominalParser); ///
 
-class NominalContext extends Context {
+export default class NominalContext extends Context {
   constructor(context, lexer, parser) {
     super(context);
 
@@ -30,11 +30,7 @@ class NominalContext extends Context {
     return this.parser;
   }
 
-  findMetaTypeByMetaTypeName(metaTypeName) {
-    const metaType = findMetaTypeByMetaTypeName(metaTypeName);
-
-    return metaType;
-  }
+  findMetaTypeByMetaTypeName(metaTypeName) { return findMetaTypeByMetaTypeName(metaTypeName); }
 
   static fromNothing() {
     const context = null,
@@ -45,7 +41,3 @@ class NominalContext extends Context {
     return nominalContext;
   }
 }
-
-const nominalContext = NominalContext.fromNothing();
-
-export default nominalContext;

package/src/context.js

@@ -136,23 +136,47 @@ export default class Context extends ContextBase {
     return ephemeralContext;
   }
 
-  findRuleByReference(reference) {
-    const context = this.getContext(),
-          rule = context.findRuleByReference(reference);
+  findMetavariable(metavariable, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context; ///
+
+    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
+
+    return metavariable;
+  }
+
+  findRuleByReference(reference, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context, ///
+          rule = parentContext.findRuleByReference(reference, childContext);
 
     return rule;
   }
 
-  findTopLevelAssertionByReference(reference) {
-    const context = this.getContext(),
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+  findTopLevelAssertionByReference(reference, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context, ///
+          topLevelAssertion = parentContext.findTopLevelAssertionByReference(reference, childContext);
 
     return topLevelAssertion;
   }
 
-  findTopLevelMetaAssertionsByReference(reference) {
-    const context = this.getContext(),
-          topLevelMetaAssertion = context.findTopLevelMetaAssertionsByReference(reference);
+  findTopLevelMetaAssertionsByReference(reference, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context, ///
+          topLevelMetaAssertion = parentContext.findTopLevelMetaAssertionsByReference(reference, childContext);
 
     return topLevelMetaAssertion;
   }
@@ -171,18 +195,6 @@ export default class Context extends ContextBase {
     return metaType;
   }
 
-  findMetavariable(metavariable, context) {
-    const childContext = context; ///
-
-    context = this.getContext();
-
-    const parentContext = context; ///
-
-    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
-
-    return metavariable;
-  }
-
   findTermByTermNode(termNode) {
     const context = this.getContext(),
           term = context.findTermByTermNode(termNode);
@@ -325,20 +337,38 @@ export default class Context extends ContextBase {
   }
 
   isMetavariablePresent(metavariable, context) {
-    metavariable = this.findMetavariable(metavariable, context);  ///
+    const childContext = context; ///
+
+    context = this.getContext();
 
-    const metavariablePresent = (metavariable !== null);
+    const parentContext = context,  ///
+          metavariablePresent = parentContext.isMetavariablePresent(metavariable, childContext);
 
     return metavariablePresent;
   }
 
-  isLabelPresentByReference(reference) {
-    const context = this.getContext(),
-          labelPresent = context.isLabelPresentByReference(reference);
+  isLabelPresentByReference(reference, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context, ///
+          labelPresent = parentContext.isLabelPresentByReference(reference, childContext);
 
     return labelPresent;
   }
 
+  isTopLevelMetaAssertionPresentByReference(reference, context) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context, ///
+          topLevelMetaAssertionPresent = parentContext.isTopLevelMetaAssertionPresentByReference(reference, childContext);
+
+    return topLevelMetaAssertionPresent;
+  }
+
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
           termPresent = context.isTermPresentByTermNode(termNode);
@@ -437,6 +467,12 @@ export default class Context extends ContextBase {
     return metaLevelSubstitutions;
   }
 
+  addTerms(terms) {
+    const context = this.getContext();
+
+    context.addTerms(terms);
+  }
+
   addTerm(term) {
     const context = this.getContext();
 
@@ -449,22 +485,40 @@ export default class Context extends ContextBase {
     context.addFrame(frame);
   }
 
+  addEquality(equality) {
+    const context = this.getContext();
+
+    context.addEquality(equality);
+  }
+
+  addJudgement(judgement) {
+    const context = this.getContext();
+
+    context.addJudgement(judgement);
+  }
+
   addStatement(statement) {
     const context = this.getContext();
 
     context.addStatement(statement);
   }
 
+  addAssertion(assertion) {
+    const context = this.getContext();
+
+    context.addAssertion(assertion);
+  }
+
   addReference(reference) {
     const context = this.getContext();
 
     context.addReference(reference);
   }
 
-  addJudgement(judgement) {
+  addAssumption(assumption) {
     const context = this.getContext();
 
-    context.addJudgement(judgement);
+    context.addAssumption(assumption);
   }
 
   addAssignment(assignment) {

package/src/element/assertion/satisfies.js

@@ -96,7 +96,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's '${referenceString}' reference...`);
 
-    const axiom = context.findAxiomByReference(this.reference, context);
+    const axiom = context.findAxiomByReference(this.reference);
 
     if (axiom !== null) {
       const axiomSatisfiable = axiom.isSatisfiable();

package/src/element/assumption.js

@@ -87,12 +87,12 @@ export default define(class Assumption extends Element {
     } else {
       let validates = false;
 
-      const referenceValidates = this.validateReference(stated, context);
+      const statementValidates = this.validateStatement(stated, context);
 
-      if (referenceValidates) {
-        const statementValidates = this.validateStatement(stated, context);
+      if (statementValidates) {
+        const referenceValidates = this.validateReference(stated, context);
 
-        if (statementValidates) {
+        if (referenceValidates) {
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -131,7 +131,25 @@ export default define(class Assumption extends Element {
     const reference = this.reference.validate(context);
 
     if (reference !== null) {
-      referenceValidates = true;
+      const metavariable = this.reference.getMetavariable(),
+            metavariablePresent = context.isMetavariablePresent(metavariable, context);
+
+      if (metavariablePresent) {
+        referenceValidates = true;
+      } else {
+        const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference, context),
+              topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
+                const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+
+                if (topLevelMetaAssertionUnifies) {
+                  return true;
+                }
+              });
+
+        if (topLevelMetaAssertionsCompare) {
+          referenceValidates = true;
+        }
+      }
     }
 
     if (referenceValidates) {
@@ -165,31 +183,13 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenStated(context) {
-    let validatesWhenStated = false;
+    let validatesWhenStated;
 
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' stated assumption...`);
 
-    const metavariable = this.reference.getMetavariable(),
-          metavariablePresent = context.isMetavariablePresent(metavariable, context);
-
-    if (metavariablePresent) {
-      validatesWhenStated = true;
-    } else {
-      const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
-            topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
-              const topLevelMetaAssertionCompares = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-
-              if (topLevelMetaAssertionCompares) {
-                return true;
-              }
-            });
-
-      if (topLevelMetaAssertionsCompare) {
-        validatesWhenStated = true;
-      }
-    }
+    validatesWhenStated = true
 
     if (validatesWhenStated) {
       context.debug(`...validated the '${assumptionString}' stated assumption.`);
@@ -199,17 +199,13 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived = false;
+    let validatesWhenDerived;
 
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' derived assumption...`);
 
-    const topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(this.reference);
-
-    if (topLevelMetaAssertionPresent) {
-      validatesWhenDerived = true;
-    }
+    validatesWhenDerived = true;
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${assumptionString}' derived assumption.`);
@@ -258,6 +254,8 @@ export default define(class Assumption extends Element {
 
       if (labelUnifies) {
         topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
+
+        specificContext.commit(context);
       }
     }, specificContext);
 

package/src/element/conclusion.js

@@ -5,7 +5,6 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, instantiate } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
-import { statementFromConclusionNode } from "../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
@@ -161,3 +160,10 @@ export  default define(class Conclusion extends Element {
     }, context);
   }
 });
+
+function statementFromConclusionNode(conclusionNode, context) {
+  const statementNode = conclusionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}

package/src/element/deduction.js

@@ -5,7 +5,6 @@ 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 {
@@ -186,3 +185,10 @@ export default define(class Deduction extends Element {
     }, context);
   }
 });
+
+function statementFromDeductionNode(deductionNode, context) {
+  const statementNode = deductionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}

package/src/element/equivalence.js

@@ -4,11 +4,11 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
+import { instantiate, sanitisedContextFromContext } from "../utilities/context";
 
 const { compress } = arrayUtilities;
 
@@ -246,6 +246,10 @@ export default define(class Equivalence extends Element {
   static name = "Equivalence";
 
   static fromEquality(equality, context) {
+    const santisedContext = sanitisedContextFromContext(context);
+
+    context = santisedContext;  ///
+
     return instantiate((context) => {
       const terms = equality.getTerms(),
             equivalenceString = equivalenceStringFromTerms(terms),

package/src/element/frame.js

@@ -316,7 +316,7 @@ export default define(class Frame extends Element {
 
       context.trace(`Validating the '${frameString}' frame's '${metavariableString}' metavariable...`);
 
-      const metavariable = this.metavariable.validate(context),  ///
+      const metavariable = this.metavariable.validate(context),
             metaTypeName = FRAME_META_TYPE_NAME,
             frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
             metavariableMetaTypeEqualToFrameMetaType = metavariable.isMetaTypeEqualTo(frameMetaType);

package/src/element/judgement.js

@@ -5,8 +5,8 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateJudgement } from "../process/instantiate";
+import { reconcile, instantiate } from "../utilities/context";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -75,6 +75,10 @@ export default define(class Judgement extends Element {
     } else {
       let validates = false;
 
+      reconcile((context) => {
+
+      }, context);
+
       const frameValidates = this.validateFrame(stated, context);
 
       if (frameValidates) {
@@ -179,7 +183,7 @@ export default define(class Judgement extends Element {
 
     const metavariable = this.assumption.getMetavariable(),
           reference = referenceFromMetavariable(metavariable, context),
-          topLevelMetaAssertion = context.findTopLevelMetaAssertionByReference(reference),
+          topLevelMetaAssertion = context.findTopLevelMetaAssertionByReference(reference, context),
           substitutions = topLevelMetaAssertion.getSubstitutions(),
           frameComparesToSubstitutions = this.frame.compareSubstitutions(substitutions, context);
 

package/src/element/label.js

@@ -156,8 +156,8 @@ export default define(class Label extends Element {
     return instantiate((context) => {
       const { string } = json,
             labelNode = instantiateLabel(string, context),
-            metavariable = metavariableFromLabelNode(labelNode, context),
             node = labelNode, ///
+            metavariable = metavariableFromLabelNode(labelNode, context),
             label = new Label(context, string, node, metavariable);
 
       return label;

package/src/element/proofAssertion/supposition.js

@@ -4,8 +4,8 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
+import { procedureCallFromSuppositionNode } from "../../utilities/element";
 import { join, attempt, reconcile, instantiate } from "../../utilities/context";
-import { statementFromSuppositionNode, procedureCallFromSuppositionNode } from "../../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
 
 export default define(class Supposition extends ProofAssertion {
@@ -327,3 +327,9 @@ export default define(class Supposition extends ProofAssertion {
   }
 });
 
+function statementFromSuppositionNode(suppositionNode, context) {
+  const statementNode = suppositionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}

package/src/element/reference.js

@@ -130,7 +130,7 @@ export default define(class Reference extends Element {
 
         if (metaType === null) {
           const reference = this, ///
-                labelPresent = context.isLabelPresentByReference(reference);
+                labelPresent = context.isLabelPresentByReference(reference, context);
 
           if (labelPresent) {
             validates = true;

package/src/element/statement.js

@@ -266,6 +266,8 @@ export default define(class Statement extends Element {
       const deductionStatementUnfies = this.unifyStatement(deductionStatement, generalContext, specificContext);
 
       if (deductionStatementUnfies) {
+        specificContext.commit();
+
         deductionUnifies = true;
       }
     }, specificContext);

package/src/element/subproof.js

@@ -121,7 +121,7 @@ export default define(class Subproof extends Element {
     context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
 
     const reference = satisfiesAssertion.getReference(),
-          axiom = context.findAxiomByReference(reference);
+          axiom = context.findAxiomByReference(reference, context);
 
     if (axiom !== null) {
       const axiomSatisfiable = axiom.isSatisfiable();

package/src/element/substitution/frame.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -73,11 +73,8 @@ export default define(class FrameSubstitution extends Substitution {
   validate(generalContext, specificContext) {
     let frameSubstitution = null;
 
-    const context = this.getContext();
-
-    specificContext = context;  ///
-
-    const frameSubstitutionString = this.getString();  ///
+    const context = specificContext,  ///
+          frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
@@ -146,9 +143,9 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   validateReplacementFrame(generalContext, specificContext) {
-    let replacementFrameValidates;
+    let replacementFrameValidates = false;
 
-    const context = specificContext, ///
+    const context = this.getContext(),
           replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
@@ -204,6 +201,10 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
+    const santisedContext = sanitisedContextFromContext(context);
+
+    context = santisedContext;  ///
+
     return instantiate((context) => {
       const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
             string = frameSubstitutionString,  ///

package/src/element/substitution/metaLevel.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
 import { instantiateMetaLevelSubstitution } from "../../process/instantiate";
+import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { metaLevelSubstitutionFromMetaLevelSubstitutionNode } from "../../utilities/element";
 import { metaLevelSubstitutionStringFromStatementAndReference } from "../../utilities/string";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
@@ -65,11 +65,8 @@ export default define(class MetaLevelSubstitution extends Substitution {
   validate(generalContext, specificContext) {
     let metaLevelSubstitution = null;
 
-    const context = this.getContext();
-
-    specificContext = context;  ///
-
-    const metaLevelSubstitutionString = this.getString();  ///
+    const context = specificContext,  ///
+          metaLevelSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution...`);
 
@@ -127,9 +124,9 @@ export default define(class MetaLevelSubstitution extends Substitution {
   }
 
   validateReplacementStatement(generalContext, specificContext) {
-    let replacementStatementValidates;
+    let replacementStatementValidates = false;
 
-    const context = specificContext,  ///
+    const context = this.getContext(),
           replacementStatementString = this.replacementStatement.getString(),
           metaLevelSubstitutionString = this.getString();  ///
 
@@ -179,9 +176,9 @@ export default define(class MetaLevelSubstitution extends Substitution {
     return instantiate((context) => {
       const { string } = json,
             metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
+            node = metaLevelSubstitutionNode, ///
             targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
             replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-            node = metaLevelSubstitutionNode,
             metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
 
       return metaLevelSubstitution;
@@ -189,6 +186,10 @@ export default define(class MetaLevelSubstitution extends Substitution {
   }
 
   static fromStatementAndReference(statement, reference, context) {
+    const santisedContext = sanitisedContextFromContext(context);
+
+    context = santisedContext;  ///
+
     return instantiate((context) => {
       const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
             string = metaLevelSubstitutionString,  ///

package/src/element/substitution/reference.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
+import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
@@ -73,11 +73,8 @@ export default define(class ReferenceSubstitution extends Substitution {
   validate(generalContext, specificContext) {
     let referenceSubstitution = null;
 
-    const context = this.getContext();
-
-    specificContext = context;  ///
-
-    const referenceSubstitutionString = this.getString();  ///
+    const context = specificContext,  ///
+          referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
 
@@ -139,7 +136,7 @@ export default define(class ReferenceSubstitution extends Substitution {
   validateReplacementReference(generalContext, specificContext) {
     let replacementReferenceValidates = false;
 
-    const context = specificContext,  ///
+    const context = this.getContext(),
           replacementReferenceString = this.replacementReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
@@ -185,6 +182,10 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
+    const santisedContext = sanitisedContextFromContext(context);
+
+    context = santisedContext;  ///
+
     return instantiate((context) => {
       const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
             string = referenceSubstitutionString,  ///