occam-verify-cli 1.0.800 → 1.0.806

package/src/element/substitution/frame.js

@@ -3,10 +3,10 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { attempt, instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
+import { join, ablate, descend, attempt, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
   constructor(context, string, node, targetFrame, replacementFrame) {
@@ -87,24 +87,26 @@ export default define(class FrameSubstitution extends Substitution {
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
     } else {
-      const context = this.getContext(),
-            specificContext = context;  ///
+      const context = this.getContext();
 
-      attempt((specificContext) => {
-        const targetFrameValidates = this.validateTargetFrame(generalContext, specificContext);
+      join((context) => {
+        attempt((context) => {
+          const specificContext = context,  ///,
+                targetFrameValidates = this.validateTargetFrame(generalContext, specificContext);
 
-        if (targetFrameValidates) {
-          const replacementFrameValidates = this.validateReplacementFrame(generalContext, specificContext);
+          if (targetFrameValidates) {
+            const replacementFrameValidates = this.validateReplacementFrame(generalContext, specificContext);
 
-          if (replacementFrameValidates) {
-            validates = true;
+            if (replacementFrameValidates) {
+              validates = true;
+            }
           }
-        }
 
-        if (validates) {
-          specificContext.commit(this);
-        }
-      }, specificContext);
+          if (validates) {
+            context.commit(this);
+          }
+        }, context);
+      }, specificContext, context);
     }
 
     if (validates) {
@@ -132,13 +134,15 @@ export default define(class FrameSubstitution extends Substitution {
     const targetFrameSingular = this.targetFrame.isSingular();
 
     if (targetFrameSingular) {
-      const tragetFrame = this.targetFrame.validate(context);
+      descend((context) => {
+        const tragetFrame = this.targetFrame.validate(context);
 
-      if (tragetFrame !== null) {
-        this.targetFrame = tragetFrame;
+        if (tragetFrame !== null) {
+          this.targetFrame = tragetFrame;
 
-        targetFrameValidates = true;
-      }
+          targetFrameValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
     }
@@ -159,13 +163,15 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
 
-    const replacementFrame = this.replacementFrame.validate(context);
+    descend((context) => {
+      const replacementFrame = this.replacementFrame.validate(context);
 
-    if (replacementFrame !== null) {
-      this.replacementFrame = replacementFrame;
+      if (replacementFrame !== null) {
+        this.replacementFrame = replacementFrame;
 
-      replacementFrameValidates = true;
-    }
+        replacementFrameValidates = true;
+      }
+    }, context);
 
     if (replacementFrameValidates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);
@@ -197,8 +203,15 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromStatement(statement, context) {
-    const statementNode = statement.getNode(),
-          frameSubstitution = frameSubstitutionFromStatementNode(statementNode, context);
+    let frameSubstitution = null;
+
+    const frameSubstitutionNode = statement.getFrameSubstitutionNode();
+
+    if (frameSubstitutionNode !== null) {
+      ablate((context) => {
+        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+      }, context);
+    }
 
     return frameSubstitution;
   }
@@ -206,12 +219,14 @@ export default define(class FrameSubstitution extends Substitution {
   static fromFrameAndMetavariable(frame, metavariable, context) {
     let frameSubstitution
 
-    instantiate((context) => {
-      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-            string = frameSubstitutionString,  ///
-            frameSubstitutionNode = instantiateFrameSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+              string = frameSubstitutionString,  ///
+              frameSubstitutionNode = instantiateFrameSubstitution(string, context);
 
-      frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+      }, context);
     }, context);
 
     return frameSubstitution;

package/src/element/substitution/reference.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { attempt, instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
+import { join, descend, ablate, attempt, instantiate } from "../../utilities/context";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
@@ -104,24 +104,26 @@ export default define(class ReferenceSubstitution extends Substitution {
 
       context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
     } else {
-      const context = this.getContext(),
-            specificContext = context;  ///
+      const context = this.getContext();
 
-      attempt((specificContext) => {
-        const targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
+      join((context) => {
+        attempt((context) => {
+          const specificContext = context,  ///
+                targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
 
-        if (targetReferenceValidates) {
-          const replacementReferenceValidates = this.validateReplacementReference(generalContext, specificContext);
+          if (targetReferenceValidates) {
+            const replacementReferenceValidates = this.validateReplacementReference(generalContext, specificContext);
 
-          if (replacementReferenceValidates) {
-            validates = true;
+            if (replacementReferenceValidates) {
+              validates = true;
+            }
           }
-        }
 
-        if (validates) {
-          specificContext.commit(this);
-        }
-      }, specificContext);
+          if (validates) {
+            context.commit(this);
+          }
+        }, context);
+      }, specificContext, context);
     }
 
     if (validates) {
@@ -146,11 +148,13 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
 
-    const targetReference = this.targetReference.validate(context);
+    descend((context) => {
+      const targetReference = this.targetReference.validate(context);
 
-    if (targetReference !== null) {
-      targetReferenceValidates = true;
-    }
+      if (targetReference !== null) {
+        targetReferenceValidates = true;
+      }
+    }, context);
 
     if (targetReferenceValidates) {
       context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
@@ -168,11 +172,13 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference...`);
 
-    const replacementReference = this.replacementReference.validate(context);
+    descend((context) => {
+      const replacementReference = this.replacementReference.validate(context);
 
-    if (replacementReference !== null) {
-      replacementReferenceValidates = true;
-    }
+      if (replacementReference !== null) {
+        replacementReferenceValidates = true;
+      }
+    }, context);
 
     if (replacementReferenceValidates) {
       context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference.`);
@@ -206,12 +212,14 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromReferenceAndMetavariable(reference, metavariable, context) {
     let referenceSubstitution;
 
-    instantiate((context) => {
-      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
-            string = referenceSubstitutionString,  ///
-            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+              string = referenceSubstitutionString,  ///
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
 
-      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+        referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+      }, context);
     }, context);
 
     return referenceSubstitution;
@@ -220,14 +228,16 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromAssumptionAndMetaLevelAssumption(assumption, metaLevelAssumption, context) {
     let referenceSubstitution;
 
-    instantiate((context) => {
-      const reference = metaLevelAssumption.getReference(),
-            metavariable = assumption.getMetavariable(),
-            referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
-            string = referenceSubstitutionString,  ///
-            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const reference = metaLevelAssumption.getReference(),
+              metavariable = assumption.getMetavariable(),
+              referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+              string = referenceSubstitutionString,  ///
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
 
-      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+        referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+      }, context);
     }, context);
 
     return referenceSubstitution;

package/src/element/substitution/statement.js

@@ -6,8 +6,8 @@ import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
-import { join, attempt, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
+import { join, ablate, attempt, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -122,28 +122,30 @@ export default define(class StatementSubstitution extends Substitution {
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
     } else {
-      const context = this.getContext(),
-            specificContext = context;  ///
+      const context = this.getContext();
 
-      attempt((specificContext) => {
-        const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
+      join((context) => {
+        attempt((context) => {
+          const specificContext = context,  ///
+                targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
 
-        if (targetStatementValidates) {
-          const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
+          if (targetStatementValidates) {
+            const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
 
-          if (replacementStatementValidates) {
-            const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
+            if (replacementStatementValidates) {
+              const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
 
-            if (substitutionValidates) {
-              validates = true;
+              if (substitutionValidates) {
+                validates = true;
+              }
             }
           }
-        }
 
-        if (validates) {
-          specificContext.commit(this);
-        }
-      }, specificContext);
+          if (validates) {
+            context.commit(this);
+          }
+        }, context);
+      }, specificContext, context);
     }
 
     if (validates) {
@@ -169,9 +171,9 @@ export default define(class StatementSubstitution extends Substitution {
 
       context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
 
-      specificContext = generalContext; ///
-
-      const substitution = this.substitution.validate(generalContext, specificContext);
+      const generalContext = context, ///
+            specificContext = context,  ///
+            substitution = this.substitution.validate(generalContext, specificContext);
 
       if (substitution !== null) {
         this.substitution = substitution;
@@ -190,7 +192,7 @@ export default define(class StatementSubstitution extends Substitution {
   validateTargetStatement(generalContext, specificContext) {
     let targetStatementValidates = false;
 
-    const context = generalContext, ///
+    const context = generalContext,  ///
           targetStatementString = this.targetStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
@@ -344,38 +346,41 @@ export default define(class StatementSubstitution extends Substitution {
     let resolved = false;
 
     const context = specificContext,  ///
-          substitutionString = this.getString(); ///
-
-    context.trace(`Resolving the ${substitutionString} substitution...`);
-
-    const metavariableName = this.getMetavariableName(),
+          metavariableName = this.getMetavariableName(),
           simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
     if (simpleSubstitution !== null) {
+      const substitutionString = this.getString(); ///
+
+      context.trace(`Resolving the ${substitutionString} substitution...`);
+
       const substitution = this.unifyWithSimpleSubstitution(simpleSubstitution, generalContext, specificContext); ///
 
       if (substitution !== null) {
-        const complexSubstitution = this, ///
-              simpleSubstitutionContext = simpleSubstitution.getContext(),
-              complexSubstitutionContext = complexSubstitution.getContext();
-
-        join((context) => {
-          const substitutionContext = this.substitution.getContext(),
-                generalContext = substitutionContext, ///
-                specificContext = context,  ///
-                substitutionUnifies = this.unifySubstitution(substitution, generalContext, specificContext);
-
-          if (substitutionUnifies) {
-            resolved = true;
-          }
-        }, complexSubstitutionContext, simpleSubstitutionContext, context);
-      }
-    }
+        let context;
+
+        context = substitution.getContext();
+
+        const specificContext = context;  ///
 
-    if (resolved) {
-      this.resolved = true;
+        context = this.substitution.getContext();
 
-      context.debug(`...resolved the '${substitutionString}' substitution.`);
+        const generalContext = context; ///
+
+        context = specificContext;  ///
+
+        const substitutionUnifies = this.unifySubstitution(substitution, generalContext, specificContext);
+
+        if (substitutionUnifies) {
+          resolved = true;
+        }
+
+        if (resolved) {
+          this.resolved = true;
+
+          context.debug(`...resolved the '${substitutionString}' substitution.`);
+        }
+      }
     }
   }
 
@@ -406,12 +411,14 @@ export default define(class StatementSubstitution extends Substitution {
 
     let statementSubstitution;
 
-    instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
 
     return statementSubstitution;
@@ -422,12 +429,14 @@ export default define(class StatementSubstitution extends Substitution {
 
     let statementSubstitution;
 
-    instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
 
     return statementSubstitution;

package/src/element/substitution/term.js

@@ -3,11 +3,11 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { attempt, instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
+import { termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
-import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
+import { join, ablate, descend, attempt, instantiate } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, targetTerm, replacementTerm) {
@@ -90,24 +90,26 @@ export default define(class TermSubstitution extends Substitution {
 
       context.debug(`...the '${termSubstitutionString}' term substitution is already valid.`);
     } else {
-      const context = this.getContext(),
-            specificContext = context;  ///
+      const context = this.getContext();
 
-      attempt((specificContext) => {
-        const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
+      join((context) => {
+        attempt((context) => {
+          const specificContext = context,  ///
+                targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
 
-        if (targetTermValidates) {
-          const replacementTermValidates = this.validateReplacementTerm(generalContext, specificContext);
+          if (targetTermValidates) {
+            const replacementTermValidates = this.validateReplacementTerm(generalContext, specificContext);
 
-          if (replacementTermValidates) {
-            validates = true;
+            if (replacementTermValidates) {
+              validates = true;
+            }
           }
-        }
 
-        if (validates) {
-          specificContext.commit(this);
-        }
-      }, specificContext);
+          if (validates) {
+            context.commit(this);
+          }
+        }, context);
+      }, specificContext, context);
     }
 
     if (validates) {
@@ -135,17 +137,19 @@ export default define(class TermSubstitution extends Substitution {
     const targetTermSingular = this.targetTerm.isSingular();
 
     if (targetTermSingular) {
-      const targetTerm = this.targetTerm.validate(context, (targetTerm) => {
-        const validatesForwards = true;
+      descend((context) => {
+        const targetTerm = this.targetTerm.validate(context, (targetTerm) => {
+          const validatesForwards = true;
 
-        return validatesForwards;
-      });
+          return validatesForwards;
+        });
 
-      if (targetTerm !== null) {
-        this.targetTerm = targetTerm;
+        if (targetTerm !== null) {
+          this.targetTerm = targetTerm;
 
-        targetTermValidates = true;
-      }
+          targetTermValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${termSubstitutionString}' term substitution's '${targetTermString}' target term is not singular.`);
     }
@@ -166,17 +170,19 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
 
-    const replacementTerm = this.replacementTerm.validate(context, (replacementTerm) => {
-      const validatesForwards = true;
+    descend((context) => {
+      const replacementTerm = this.replacementTerm.validate(context, (replacementTerm) => {
+        const validatesForwards = true;
 
-      return validatesForwards;
-    });
+        return validatesForwards;
+      });
 
-    if (replacementTerm !== null) {
-      this.replacementTerm = replacementTerm;
+      if (replacementTerm !== null) {
+        this.replacementTerm = replacementTerm;
 
-      replacementTermValidates = true;
-    }
+        replacementTermValidates = true;
+      }
+    }, context);
 
     if (replacementTermValidates) {
       context.debug(`...validated the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
@@ -208,8 +214,15 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   static fromStatement(statement, context) {
-    const statementNode = statement.getNode(),
-          termSubstitution = termSubstitutionFromStatementNode(statementNode, context);
+    let termSubstitution = null;
+
+    const termSubstitutionNode = statement.getTermSubstitutionNode();
+
+    if (termSubstitutionNode !== null) {
+      ablate((context) => {
+        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+      }, context);
+    }
 
     return termSubstitution;
   }
@@ -219,12 +232,14 @@ export default define(class TermSubstitution extends Substitution {
 
     let termSubstitution;
 
-    instantiate((context) => {
-      const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
-            string = termSubstitutionString,  ///
-            termSubstitutionNode = instantiateTermSubstitution(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
+              string = termSubstitutionString,  ///
+              termSubstitutionNode = instantiateTermSubstitution(string, context);
 
-      termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+      }, context);
     }, context);
 
     return termSubstitution;

package/src/element/variable.js

@@ -77,12 +77,11 @@ export default define(class Variable extends Element {
 
     let validates = false;
 
-    const variableIdentifier = this.identifier;
+    const variableIdentifier = this.identifier, ///
+          declaredVariable = context.findDeclaredVariableByVariableIdentifier(variableIdentifier);
 
-    variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-    if (variable !== null) {
-      const type = variable.getType(),
+    if (declaredVariable !== null) {
+      const type = declaredVariable.getType(),
             typeString = type.getString(),
             variableString = this.getString();  ///
 
@@ -138,9 +137,9 @@ export default define(class Variable extends Element {
 
       context = generalContext;  ///
 
-      const variableIdentifier = variable.getIdentifier();
+      const variableNode = variable.getIdentifier();
 
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+      variable = context.findVariableByVariableNode(variableNode);
 
       context = specificContext;  ///
 

package/src/preamble.js

@@ -36,7 +36,6 @@ import Constructor from "./element/constructor";
 import Supposition from "./element/proofAssertion/supposition";
 import Metatheorem from "./element/topLevelMetaAssertion/metatheorem";
 import Equivalence from "./element/equivalence";
-import Equivalences from "./element/equivalences";
 import Metavariable from "./element/metavariable";
 import ProcedureCall from "./element/procedureCall";
 import SubDerivation from "./element/subDerivation";