occam-verify-cli 1.0.787 → 1.0.796

package/src/element/parameter.js

@@ -30,20 +30,20 @@ export default define(class Parameter extends Element {
     return parameterNode;
   }
 
-  findPrimitive(substitutions) {
+  findPrimitive(substitutions, context) {
     let primitive = null;
 
     const parameter = this, ///
           substitution = substitutions.find((substitution) => {
-            const substitutionComparesToParamter = substitution.compareParameter(parameter);
+            const substitutionComparesToParameter = substitution.compareParameter(parameter);
 
-            if (substitutionComparesToParamter) {
+            if (substitutionComparesToParameter) {
               return true;
             }
           }) || null;
 
     if (substitution !== null) {
-      primitive = substitution.getPrimitive();
+      primitive = substitution.getPrimitive(context);
     }
 
     return primitive;

package/src/element/procedureCall.js

@@ -38,7 +38,7 @@ export default define(class ProcedureCall extends Element {
   findPrimitives(context) {
     const substitutions = context.getSubstitutions(),
           primitives = this.parameters.map((parameter) => {
-            const primitive = parameter.findPrimitive(substitutions);
+            const primitive = parameter.findPrimitive(substitutions, context);
 
             return primitive;
           });

package/src/element/proofAssertion/step.js

@@ -137,7 +137,7 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
 
-      const reference = this.reference.validate();
+      const reference = this.reference.validate(context);
 
       if (reference === null) {
         referenceValidates = false;

package/src/element/reference.js

@@ -123,60 +123,79 @@ export default define(class Reference extends Element {
     return topLevelMetaAssertionCompares;
   }
 
-  validate() {
-    let referennce = null;
+  findValidReference(context) {
+    const referenceNode = this.getReferenceNode(),
+          reference = context.findReferenceByReferenceNode(referenceNode),
+          validReference = reference;  ///
 
-    const context = this.getContext(),
-          referenceString = this.getString(); ///
+    return validReference;
+  }
+
+  validate(context) {
+    let reference = null;
+
+    const referenceString = this.getString(); ///
 
     context.trace(`Validating the '${referenceString}' reference...`);
 
-    let validates;
+    let validates = false;
 
-    attempt((context) => {
-      const metavariableValidates = this.validateMetavariable(context);
+    const validReference = this.findValidReference(context);
 
-      if (metavariableValidates) {
-        const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
-              referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
-              metaType = this.metavariable.getMetaType();
+    if (validReference) {
+      reference = validReference;  ///
 
-        if (metaType === null) {
-          const reference = this, ///
-                labelPresent = context.isLabelPresentByReference(reference);
+      context.debug(`...the '${referenceString}' reference is already valid.`);
+    } else {
+      const context = this.getContext();
 
-          if (labelPresent) {
-            validates = true;
-          } else {
-            context.debug(`There is no label for the '${referenceString}' reference.`);
-          }
-        } else {
-          const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
+      attempt((context) => {
+        const metavariableValidates = this.validateMetavariable(context);
+
+        if (metavariableValidates) {
+          const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
+                referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
+                metaType = this.metavariable.getMetaType();
 
-          if (metavariableMetaTypeEqualToReferenceMetaType) {
-            validates = true;
+          if (metaType === null) {
+            const reference = this, ///
+                  labelPresent = context.isLabelPresentByReference(reference);
+
+            if (labelPresent) {
+              validates = true;
+            } else {
+              context.debug(`There is no label for the '${referenceString}' reference.`);
+            }
           } else {
-            const metaTypeString = metaType.getString(),
-                  metavariableString = this.metavariable.getString(),
-                  referenceMetaTypeString = referenceMetaType.getString();
+            const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
+
+            if (metavariableMetaTypeEqualToReferenceMetaType) {
+              validates = true;
+            } else {
+              const metaTypeString = metaType.getString(),
+                    metavariableString = this.metavariable.getString(),
+                    referenceMetaTypeString = referenceMetaType.getString();
 
-            context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${referenceMetaTypeString}' meta-type.`);
+              context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${referenceMetaTypeString}' meta-type.`);
+            }
           }
         }
-      }
 
-      if (validates) {
-        context.commit(this);
-      }
-    }, context);
+        if (validates) {
+          context.commit(this);
+        }
+      }, context);
+    }
 
     if (validates) {
-      referennce = this;  ///
+      reference = this;  ///
+
+      context.addReference(reference);
 
       context.debug(`...validated the '${referenceString}' reference.`);
     }
 
-    return referennce;
+    return reference;
   }
 
   validateMetavariable(context) {
@@ -338,5 +357,3 @@ export default define(class Reference extends Element {
     return reference;
   }
 });
-
-let counter = 0;

package/src/element/substitution/frame.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { descend, instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
+import { attempt, descend, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -78,34 +78,43 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
-    const validSubstitution = this.findValidSubstiution(context);
+    let validates = false;
+
+    const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
       frameSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
     } else {
-      let validates = false;
+      const context = this.getContext(),
+            specificContext = context;  ///
 
-      const targetFrameValidates = this.validateTargetFrame(generalContext, specificContext);
+      attempt((specificContext) => {
+        const 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) {
-        const substitution = this;  ///
+        if (validates) {
+          specificContext.commit(this);
+        }
+      }, specificContext);
+    }
+
+    if (validates) {
+      const substitution = this;  ///
 
-        frameSubstitution = substitution; ///
+      frameSubstitution = substitution; ///
 
-        context.addSubstitution(substitution);
+      context.addSubstitution(substitution);
 
-        context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
-      }
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
     }
 
     return frameSubstitution;
@@ -146,7 +155,7 @@ export default define(class FrameSubstitution extends Substitution {
   validateReplacementFrame(generalContext, specificContext) {
     let replacementFrameValidates = false;
 
-    const context = this.getContext(),
+    const context = specificContext,  ///
           replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
@@ -184,8 +193,6 @@ export default define(class FrameSubstitution extends Substitution {
               targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
               replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
-        context = null;
-
         frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
       }, context);
     }

package/src/element/substitution/reference.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { attempt, instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
@@ -70,6 +70,23 @@ export default define(class ReferenceSubstitution extends Substitution {
     return comparesToParameter;
   }
 
+  compareSubstitution(substitution) {
+    let substitutionCompares = false;
+
+    const substitutionReferenceSubstitution = (substitution instanceof ReferenceSubstitution);
+
+    if (substitutionReferenceSubstitution) {
+      const substitutionNode = substitution.getNode(),
+            substitutionNodeMatches = this.matchNode(substitutionNode);
+
+      if (substitutionNodeMatches) {
+        substitutionCompares = true;
+      }
+    }
+
+    return substitutionCompares;
+  }
+
   validate(generalContext, specificContext) {
     let referenceSubstitution = null;
 
@@ -78,34 +95,43 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
 
-    const validSubstitution = this.findValidSubstiution(context);
+    let validates = false;
+
+    const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
       referenceSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
     } else {
-      let validates = false;
+      const context = this.getContext(),
+            specificContext = context;  ///
 
-      const targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
+      attempt((specificContext) => {
+        const 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) {
-        const subsitution = this;  ///
+        if (validates) {
+          specificContext.commit(this);
+        }
+      }, specificContext);
+    }
 
-        referenceSubstitution = subsitution;  ///
+    if (validates) {
+      const substitution = this;  ///
 
-        context.addSubstitution(subsitution);
+      referenceSubstitution = substitution;  ///
 
-        context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
-      }
+      context.addSubstitution(substitution);
+
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
     }
 
     return referenceSubstitution;
@@ -114,17 +140,15 @@ export default define(class ReferenceSubstitution extends Substitution {
   validateTargetReference(generalContext, specificContext) {
     let targetReferenceValidates = false;
 
-    const context = specificContext, ///
+    const context = generalContext, ///
           targetReferenceString = this.targetReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
 
-    const targetReference = this.targetReference.validate();
+    const targetReference = this.targetReference.validate(context);
 
     if (targetReference !== null) {
-      context.addReference(targetReference);
-
       targetReferenceValidates = true;
     }
 
@@ -138,17 +162,15 @@ export default define(class ReferenceSubstitution extends Substitution {
   validateReplacementReference(generalContext, specificContext) {
     let replacementReferenceValidates = false;
 
-    const context = this.getContext(),
+    const context = specificContext,  ///
           replacementReferenceString = this.replacementReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference...`);
 
-    const replacementReference = this.replacementReference.validate();
+    const replacementReference = this.replacementReference.validate(context);
 
     if (replacementReference !== null) {
-      context.addReference(replacementReference);
-
       replacementReferenceValidates = true;
     }
 
@@ -174,8 +196,6 @@ export default define(class ReferenceSubstitution extends Substitution {
               targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
               replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
 
-        context = null;
-
         referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
       }, context);
     }
@@ -196,6 +216,22 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     return referenceSubstitution;
   }
+
+  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);
+
+      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    }, context);
+
+    return referenceSubstitution;
+  }
 });
 
 function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {

package/src/element/substitution/statement.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
-import { join, descend, reconcile, instantiate } from "../../utilities/context";
+import { join, attempt, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
@@ -113,39 +113,80 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution...`);
 
-    const validSubstitution = this.findValidSubstiution(context);
+    let validates = false;
+
+    const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
       statementSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
     } else {
-      let validates = false;
+      const context = this.getContext(),
+            specificContext = context;  ///
+
+      attempt((specificContext) => {
+        const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
+
+        if (targetStatementValidates) {
+          const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
 
-      const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
+          if (replacementStatementValidates) {
+            const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
 
-      if (targetStatementValidates) {
-        const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
+            if (substitutionValidates) {
+              validates = true;
+            }
+          }
+        }
 
-        if (replacementStatementValidates) {
-          validates = true;
+        if (validates) {
+          specificContext.commit(this);
         }
-      }
+      }, specificContext);
+    }
 
-      if (validates) {
-        const substitution = this;  ///
+    if (validates) {
+      const substitution = this;  ///
 
-        statementSubstitution = substitution; ///
+      statementSubstitution = substitution; ///
 
-        context.addSubstitution(substitution);
+      context.addSubstitution(substitution);
 
-        context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
-      }
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
     }
 
     return statementSubstitution;
   }
 
+  validateSubstitution(generalContext, specificContext) {
+    let substitutionValidates = true;
+
+    if (this.substitution !== null) {
+      const context = specificContext,  ///
+            substitutionString = this.substitution.getString(),
+            statementSubstitutionString = this.getString();
+
+      context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
+
+      specificContext = generalContext; ///
+
+      const substitution = this.substitution.validate(generalContext, specificContext);
+
+      if (substitution !== null) {
+        this.substitution = substitution;
+
+        substitutionValidates = true;
+      }
+
+      if (substitutionValidates) {
+        context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
+      }
+    }
+
+    return substitutionValidates;
+  }
+
   validateTargetStatement(generalContext, specificContext) {
     let targetStatementValidates = false;
 
@@ -179,7 +220,7 @@ export default define(class StatementSubstitution extends Substitution {
   validateReplacementStatement(generalContext, specificContext) {
     let replacementStatementValidates = false;
 
-    const context = this.getContext(),
+    const context = specificContext,  ///
           replacementStatementString = this.replacementStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
@@ -353,8 +394,6 @@ export default define(class StatementSubstitution extends Substitution {
               targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
               replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
-        context = null;
-
         statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
       }, context);
     }

package/src/element/substitution/term.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { attempt, instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
@@ -81,34 +81,43 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution...`);
 
-    const validSubstitution = this.findValidSubstiution(context);
+    let validates = false;
+
+    const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
       termSubstitution = validSubstitution; ///
 
       context.debug(`...the '${termSubstitutionString}' term substitution is already valid.`);
     } else {
-      let validates = false;
+      const context = this.getContext(),
+            specificContext = context;  ///
 
-      const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
+      attempt((specificContext) => {
+        const 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) {
-        const substitution = this;  ///
+        if (validates) {
+          specificContext.commit(this);
+        }
+      }, specificContext);
+    }
+
+    if (validates) {
+      const substitution = this;  ///
 
-        termSubstitution = substitution;  ///
+      termSubstitution = substitution;  ///
 
-        context.addSubstitution(substitution);
+      context.addSubstitution(substitution);
 
-        context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
-      }
+      context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
     }
 
     return termSubstitution;
@@ -151,7 +160,7 @@ export default define(class TermSubstitution extends Substitution {
   validateReplacementTerm(generalContext, specificContext) {
     let replacementTermValidates = false;
 
-    const context = this.getContext(),
+    const context = specificContext,  ///
           replacementTermString = this.replacementTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
@@ -191,8 +200,6 @@ export default define(class TermSubstitution extends Substitution {
               targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
               replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context);
 
-        context = null;
-
         termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
       }, context);
     }

package/src/element/substitution.js

@@ -6,9 +6,8 @@ import { primitiveUtilities } from "occam-furtle";
 const { primitiveFromNode } =primitiveUtilities;
 
 export default class Substitution extends Element {
-  getPrimitive() {
-    const context = this.getContext(),
-          replacementNode = this.getReplacementNode(),
+  getPrimitive(context) {
+    const replacementNode = this.getReplacementNode(),
           node = replacementNode, ///
           primitive = primitiveFromNode(node, context);
 
@@ -30,7 +29,7 @@ export default class Substitution extends Element {
     return substitutionNodeMatches;
   }
 
-  findValidSubstiution(context) {
+  findValidSubstitution(context) {
     const substitutionNode = this.getSubstitutionNode(),
           substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),
           validSubstitution = substitution;  ///