occam-verify-cli 1.0.800 → 1.0.806

package/src/context.js

@@ -80,9 +80,16 @@ export default class Context extends ContextBase {
     return assumptions;
   }
 
+  getMetavariables() {
+    const context = this.getContext(),
+          metavariables = context.getMetavariables();
+
+    return metavariables;
+  }
+
   getSubstitutions() {
     const context = this.getContext(),
-          substitutions = context.getSubstitutions();
+      substitutions = context.getSubstitutions();
 
     return substitutions;
   }
@@ -94,13 +101,6 @@ export default class Context extends ContextBase {
     return equivalences;
   }
 
-  getVariables(includeRelease) {
-    const context = this.getContext(),
-          variables = context.getVariables(includeRelease);
-
-    return variables;
-  }
-
   getCombinators(includeRelease) {
     const context = this.getContext(),
           combinators = context.getCombinators(includeRelease);
@@ -115,11 +115,18 @@ export default class Context extends ContextBase {
     return constructors;
   }
 
-  getMetavariables(includeRelease) {
+  getDeclaredVariables(includeRelease) {
     const context = this.getContext(),
-          metavariables = context.getMetavariables(includeRelease);
+          declaredVariables = context.getDeclaredVariables(includeRelease);
 
-    return metavariables;
+    return declaredVariables;
+  }
+
+  getDeclaredMetavariables(includeRelease) {
+    const context = this.getContext(),
+          declaredMetavariables = context.getDeclaredMetavariables(includeRelease);
+
+    return declaredMetavariables;
   }
 
   getSubproofOrProofAssertions() {
@@ -225,9 +232,9 @@ export default class Context extends ContextBase {
     return reference;
   }
 
-  findAssumptionByAssumptionNode(assumptionNode, metaLevel = false) {
+  findAssumptionByAssumptionNode(assumptionNode) {
     const context = this.getContext(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel);
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode);
 
     return assumption;
   }
@@ -274,9 +281,9 @@ export default class Context extends ContextBase {
     return type;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
+  findVariableByVariableNode(variableNode) {
     const context = this.getContext(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+          variable = context.findVariableByVariableNode(variableNode);
 
     return variable;
   }
@@ -288,11 +295,11 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
+  findDeclaredMetavariableByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
 
-    return metavariable;
+    return declaredMetavariable;
   }
 
   findSubstitutionByVariableIdentifier(variableIdentifier) {
@@ -426,9 +433,9 @@ export default class Context extends ContextBase {
     return judgementPresent;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
+  isDeclaredMetavariablePresentByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
+          metavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
 
     return metavariablePresent;
   }
@@ -488,6 +495,60 @@ export default class Context extends ContextBase {
     context.addTerms(terms);
   }
 
+  addFrames(frames) {
+    const context = this.getContext();
+
+    context.addFrames(frames);
+  }
+
+  addEqualities(equalities) {
+    const context = this.getContext();
+
+    context.addEqualities(equalities);
+  }
+
+  addJudgements(judgements) {
+    const context = this.getContext();
+
+    context.addJudgements(judgements);
+  }
+
+  addAssertions(assertions) {
+    const context = this.getContext();
+
+    context.addAssertions(assertions);
+  }
+
+  addStatements(statements) {
+    const context = this.getContext();
+
+    context.addStatements(statements);
+  }
+
+  addReferences(references) {
+    const context = this.getContext();
+
+    context.addReferences(references);
+  }
+
+  addAssumptions(assumptions) {
+    const context = this.getContext();
+
+    context.addAssumptions(assumptions);
+  }
+
+  addMetavariables(metavariables) {
+    const context = this.getContext();
+
+    context.addMetavariables(metavariables);
+  }
+
+  addSubstitutions(substitutions) {
+    const context = this.getContext();
+
+    context.addSubstitutions(substitutions);
+  }
+
   addTerm(term) {
     const context = this.getContext();
 

package/src/element/assertion/defined.js

@@ -249,8 +249,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   const context = specificContext;  ///
 
   if (term !== null) {
-    const variableIdentifier = term.getVariableIdentifier(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier),
+    const variableNode = term.getVariableNode(),
+          variable = context.findVariableByVariableNode(variableNode),
           variableDefined = isVariableDefined(variable, context);
 
     if (!negated && variableDefined) {
@@ -264,8 +264,8 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
 
   if (frame!== null) {
     const metavariableName = frame.getMetavariableName(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName),
-          metavariableDefined = isMetavariableDefined(metavariable, context);
+          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName),
+          metavariableDefined = isMetavariableDefined(declaredMetavariable, context);
 
     if (!negated && metavariableDefined) {
       validatesWhenDerived = true;

package/src/element/assumption/metaLevel.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { instantiateMetaLevelAssumption } from "../../process/instantiate";
 import { metaLevelAssumptionFromMetaLevelAssumptionNode } from "../../utilities/element";
 import { metaLevelAssumptionStringFromStatementAndReference } from "../../utilities/string";
-import { attempt, descend, serialise, unserialise, instantiate } from "../../utilities/context";
+import { ablate, attempt, descend, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelAssumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -236,12 +236,14 @@ export default define(class MetaLevelAssumption extends Element {
   static fromStatementAndReference(statement, reference, context) {
     let metaLevelAssumption;
 
-    instantiate((context) => {
-      const metaLevelAssumptionString = metaLevelAssumptionStringFromStatementAndReference(statement, reference),
-            string = metaLevelAssumptionString,  ///
-            metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const metaLevelAssumptionString = metaLevelAssumptionStringFromStatementAndReference(statement, reference),
+              string = metaLevelAssumptionString,  ///
+              metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context);
 
-      metaLevelAssumption = metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
+        metaLevelAssumption = metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
+      }, context);
     }, context);
 
     return metaLevelAssumption;

package/src/element/combinator.js

@@ -38,10 +38,12 @@ export default define(class Combinator extends Element {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        context.commit(this);
-
         validates = true;
       }
+
+      if (validates) {
+        context.commit(this);
+      }
     }, context)
 
     if (validates) {

package/src/element/conclusion.js

@@ -62,10 +62,12 @@ export default define(class Conclusion extends Element {
         const statementValidates = this.validateStatement(context);
 
         if (statementValidates) {
-          context.commit(this);
-
           validates = true;
         }
+
+        if (validates) {
+          context.commit(this);
+        }
       }, context);
     }, context);
 

package/src/element/constructor.js

@@ -64,10 +64,12 @@ export default define(class Constructor extends Element {
       const termValidates = this.validateTerm(context);
 
       if (termValidates) {
-        context.commit(this);
-
         validates = true;
       }
+
+      if (validates) {
+        context.commit(this);
+      }
     }, context);
 
     if (validates) {

package/src/element/declaration/metavariable.js

@@ -37,7 +37,9 @@ export default define(class MetavariableDeclaration extends Declaration {
       const metaTypeVerifies = this.verifyMetaType();
 
       if (metaTypeVerifies) {
-        context.addMetavariable(this.metavariable);
+        const declaredMetavariable = this.metavariable; ///
+
+        context.addDeclaredMetavariable(declaredMetavariable);
 
         verifies = true;
       }
@@ -57,12 +59,12 @@ export default define(class MetavariableDeclaration extends Declaration {
           metaTypeString = this.metaType.getString(),
           metaTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${metaTypeDeclarationString}' variable declaration's '${metaTypeString}' metaType...`);
+    context.trace(`Verifying the '${metaTypeDeclarationString}' metavariable declaration's '${metaTypeString}' metaType...`);
 
     this.metavariable.setMetaType(this.metaType);
 
     if (metaTypeVerifies) {
-      context.debug(`...verified the '${metaTypeDeclarationString}' variable declaration's '${metaTypeString}' metaType.`);
+      context.debug(`...verified the '${metaTypeDeclarationString}' metavariable declaration's '${metaTypeString}' metaType.`);
     }
 
     return metaTypeVerifies;
@@ -75,19 +77,19 @@ export default define(class MetavariableDeclaration extends Declaration {
           metavariableString = this.metavariable.getString(),
           metavariableDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${metavariableDeclarationString}' variable declaration's '${metavariableString}' metavariable...`);
+    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's '${metavariableString}' metavariable...`);
 
     const metavariableName = this.metavariable.getName(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
+          declaredMetavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
 
-    if (!metavariablePresent) {
+    if (!declaredMetavariablePresent) {
       metavariableVerifies = this.metavariable.verify(context);
     } else {
-      context.debug(`The '${metavariableName}' metavariable is already present.`);
+      context.debug(`The '${metavariableName}' declared metavariable is already present.`);
     }
 
     if (metavariableVerifies) {
-      context.debug(`...verified the '${metavariableDeclarationString}' variable declaration's '${metavariableString}' metavariable.`);
+      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration's '${metavariableString}' metavariable.`);
     }
 
     return metavariableVerifies;

package/src/element/declaration/variable.js

@@ -49,7 +49,9 @@ export default define(class VariableDeclaration extends Declaration {
       const variableVerifies = this.verifyVariable();
 
       if (variableVerifies) {
-        context.addVariable(this.variable);
+        const declaredVariable = this.variable;
+
+        context.addDeclaredVariable(declaredVariable);
 
         verifies = true;
       }
@@ -65,9 +67,8 @@ export default define(class VariableDeclaration extends Declaration {
   verifyType() {
     let typeVerifies = false;
 
-    const context = this.getContext();
-
-    const typeString = this.type.getString(),
+    const context = this.getContext(),
+          typeString = this.type.getString(),
           variableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${typeString}' type...`);
@@ -109,10 +110,10 @@ export default define(class VariableDeclaration extends Declaration {
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${variableString}' variable...`);
 
     const variableIdentifier = this.variable.getIdentifier(),
-          variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
+          declaredVariablePresent = context.isDeclaredVariablePresentByVariableIdentifier(variableIdentifier);
 
-    if (variablePresent) {
-      context.debug(`The '${variableString}' variable is already present.`);
+    if (declaredVariablePresent) {
+      context.debug(`The '${variableString}' declared variable is already present.`);
     } else {
       variableVerifies = true;
     }

package/src/element/deduction.js

@@ -62,10 +62,12 @@ export default define(class Deduction extends Element {
         const statementValidates = this.validateStatement(context);
 
         if (statementValidates) {
-          context.commit(this);
-
           validates = true;
         }
+
+        if (validates) {
+          context.commit(this);
+        }
       }, context);
     }, context);
 

package/src/element/label.js

@@ -6,7 +6,7 @@ import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
 import { labelFromLabelNode } from "../utilities/element";
 import { metavariableFromLabelNode } from "../utilities/element";
-import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
+import { ablate, attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Label extends Element {
   constructor(context, string, node, metavariable) {
@@ -90,10 +90,12 @@ export default define(class Label extends Element {
       const metavariableValidates = this.validateMetavariable(context);
 
       if (metavariableValidates) {
-        context.commit(this);
-
         validates = true;
       }
+
+      if (validates) {
+        context.commit(this);
+      }
     }, context);
 
     if (validates) {
@@ -162,11 +164,13 @@ export default define(class Label extends Element {
   static fromLabelString(labelString, context) {
     let label;
 
-    instantiate((context) => {
-      const string = labelString,  ///
-            labelNode = instantiateLabel(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const string = labelString,  ///
+              labelNode = instantiateLabel(string, context);
 
-      label = labelFromLabelNode(labelNode, context);
+        label = labelFromLabelNode(labelNode, context);
+      }, context);
     }, context);
 
     return label;

package/src/element/metavariable.js

@@ -58,8 +58,8 @@ export default define(class Metavariable extends Element {
 
   isDeclared(context) {
     const metavariableName = this.getMetavariableName(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName),
-          declared = (metavariable !== null);
+          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName),
+          declared = (declaredMetavariable !== null);
 
     return declared;
   }
@@ -259,11 +259,11 @@ export default define(class Metavariable extends Element {
       context.trace(`Validating the '${metavariableString}' metavariable's '${termString}' term...`);
 
       const metavariableName = this.getMetavariableName(),
-            metavariable = context.findMetavariableByMetavariableName(metavariableName);
+            declaredMetavaraible = context.findDeclaredMetavariableByMetavariableName(metavariableName);
 
       let term = null;
 
-      if (metavariable !== null) {
+      if (declaredMetavaraible !== null) {
         const type = metavariable.getType();
 
         if (type !== null) {
@@ -301,10 +301,10 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Validating the '${metavariableString}' metavariable's '${metavariableName}' name...`);
 
-    const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    const declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
 
-    if (metavariable !== null) {
-      const metaType = metavariable.getMetaType(),
+    if (declaredMetavariable !== null) {
+      const metaType = declaredMetavariable.getMetaType(),
             metaTypeString = metaType.getString();
 
       this.metaType = metaType;
@@ -522,8 +522,8 @@ export default define(class Metavariable extends Element {
 
         if (frameSingular) {
           const frameMetavariableName = frame.getMetavariableName(),
-                frameMetavariable = context.findMetavariableByMetavariableName(frameMetavariableName),
-                frameMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(frameMetavariable, generalContext, specificContext);
+                frameDeclaredMetavariable = context.findDeclaredMetavariableByMetavariableName(frameMetavariableName),
+                frameMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(frameDeclaredMetavariable, generalContext, specificContext);
 
           if (frameMetavariableUnifiesIntrinsically) {
             frameMetavariableUnifies = true;
@@ -597,8 +597,8 @@ export default define(class Metavariable extends Element {
 
         if (statementSingular) {
           const statementMetavariableName = statement.getMetavariableName(),
-                statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
-                statementMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(statementMetavariable, generalContext, specificContext);
+                statementDeclaredMetavariable = context.findDeclaredMetavariableByMetavariableName(statementMetavariableName),
+                statementMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(statementDeclaredMetavariable, generalContext, specificContext);
 
           if (statementMetavariableUnifiesIntrinsically) {
             statementMetavariableUnifies = true;

package/src/element/proofAssertion/premise.js

@@ -66,8 +66,6 @@ export default define(class Premise extends ProofAssertion {
           const statementValidates = this.validateStatement(context);
 
           if (statementValidates) {
-            context.commit(this);
-
             validates = true;
           }
         }
@@ -76,11 +74,13 @@ export default define(class Premise extends ProofAssertion {
           const procedureCallValidates = this.validateProcedureCall(context);
 
           if (procedureCallValidates) {
-            context.commit(this);
-
             validates = true;
           }
         }
+
+        if (validates) {
+          context.commit(this);
+        }
       }, context);
     }, context);
 

package/src/element/proofAssertion/step.js

@@ -112,12 +112,14 @@ export default define(class Step extends ProofAssertion {
             const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
             if (satisfiesAssertioValidates) {
-              context.commit(this);
-
               validates = true;
             }
           }
         }
+
+        if (validates) {
+          context.commit(this);
+        }
       }, context);
     }, context);
 

package/src/element/reference.js

@@ -6,7 +6,7 @@ import { define } from "../elements";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { referenceFromReferenceNode } from "../utilities/element";
-import { attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
+import { ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
@@ -354,11 +354,13 @@ export default define(class Reference extends Element {
   static fromReferenceString(referenceString, context) {
     let reference;
 
-    instantiate((context) => {
-      const string = referenceString,  ///
-            referenceNode = instantiateReference(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const string = referenceString,  ///
+              referenceNode = instantiateReference(string, context);
 
-      reference = referenceFromReferenceNode(referenceNode, context);
+        reference = referenceFromReferenceNode(referenceNode, context);
+      }, context);
     }, context);
 
     return reference;

package/src/element/statement.js

@@ -26,6 +26,20 @@ export default define(class Statement extends Element {
     return metavariableName;
   }
 
+  getTermSubstitutionNode() {
+    const statementNode = this.getNode(),
+          termSubstitutionNode = statementNode.getTermSubstitutionNode();
+
+    return termSubstitutionNode;
+  }
+
+  getFrameSubstitutionNode() {
+    const statementNode = this.getNode(),
+          frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
+
+    return frameSubstitutionNode;
+  }
+
   isSingular() {
     const statementNode = this.getStatementNode(),
           singular = statementNode.isSingular();