occam-verify-cli 1.0.950 → 1.0.955

package/src/element/proofAssertion/step.js

@@ -127,9 +127,10 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    const qualified = this.isQualified();
+    const qualified = this.isQualified(),
+          stated = qualified; ///
 
-    (qualified ? declare : derive)((context) => {
+    (stated ? declare : derive)((context) => {
       attempt((context) => {
         const statementValidates = this.validateStatement(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 { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { join, ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
+import { join, posit, ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { referenceFromReferenceNode, metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
@@ -340,12 +340,14 @@ export default define(class Reference extends Element {
   static fromReferenceString(referenceString, context) {
     let reference;
 
-    ablate((context) => {
-      instantiate((context) => {
-        const string = referenceString,  ///
-              referenceNode = instantiateReference(string, context);
+    posit((context) => {
+      ablate((context) => {
+        instantiate((context) => {
+          const string = referenceString,  ///
+                referenceNode = instantiateReference(string, context);
 
-        reference = referenceFromReferenceNode(referenceNode, context);
+          reference = referenceFromReferenceNode(referenceNode, context);
+        }, context);
       }, context);
     }, context);
 

package/src/element/signature.js

@@ -6,7 +6,7 @@ import { arrayUtilities } from "necessary";
 import { define } from "../elements";
 import { signatureFromSignatureNode } from "../utilities/element";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { join, ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
+import { join, posit, ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match } = arrayUtilities;
 
@@ -276,12 +276,14 @@ export default define(class Signature extends Element {
   static fromSignatureString(signatureString, context) {
     let signature;
 
-    ablate((context) => {
-      instantiate((context) => {
-        const string = signatureString,  ///
-              signatureNode = instantiateSignature(string, context);
+    posit((context) => {
+      ablate((context) => {
+        instantiate((context) => {
+          const string = signatureString,  ///
+                signatureNode = instantiateSignature(string, context);
 
-        signature = signatureFromSignatureNode(signatureNode, context);
+          signature = signatureFromSignatureNode(signatureNode, context);
+        }, context);
       }, context);
     }, context);
 

package/src/element/substitution/frame.js

@@ -3,11 +3,12 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { join, reconcile } from "../../utilities/context";
 import { breakPointFromJSON } from "../../utilities/breakPoint";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { ablate, ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablate, ablates, manifest, attempts, sequester, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class FrameSubstitution extends Substitution {
   constructor(contexts, string, node, breakPoint, targetFrame, replacementFrame) {
@@ -136,7 +137,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     if (targetFrameSingular) {
       manifest((context) => {
-        descend((context) => {
+        sequester((context) => {
           const tragetFrame = this.targetFrame.validate(context);
 
           if (tragetFrame !== null) {
@@ -167,7 +168,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's replacement frame...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementFrame = this.replacementFrame.validate(context);
 
       if (replacementFrame !== null) {
@@ -184,6 +185,127 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementFrameValidates;
   }
 
+  unifySubstitution(substitution, context) {
+    let substitutionUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+
+    reconcile((context) => {
+      const replacementFrameUnifies = this.unifyReplacementFrame(substitution, context);
+
+      if (replacementFrameUnifies) {
+        const targetFrameUnifies = this.unifyTargetFrame(substitution, context);
+
+        if (targetFrameUnifies) {
+          context.commit();
+
+          substitutionUnifies = true;
+        }
+      }
+    }, context);
+
+    if (substitutionUnifies) {
+      context.debug(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+    }
+
+    return substitutionUnifies;
+  }
+
+  unifyTargetFrame(substitution, context) {
+    let targetFrameUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame...`);
+
+    const generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          generalSubstitutionTargetFrame = generalSubstitution.getTargetFrame(),
+          specificSubstitutionTargetFrame = specificSubstitution.getTargetFrame(),
+          generalContext = generalSubstitutionGeneralContext,  ///
+          specificContext = specificSubstitutionGeneralContext,  ///
+          generalFrame = generalSubstitutionTargetFrame, ///
+          specificFrame = specificSubstitutionTargetFrame; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalFrameNode = generalFrame.getNode(),
+              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+
+        if (generalMetavariable !== null) {
+          const frame = specificFrame,  ///
+                metavariable = generalMetavariable, ///
+                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+          if (frameUnifies) {
+            specificContext.commit(context);
+
+            targetFrameUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (targetFrameUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame.`);
+    }
+
+    return targetFrameUnifies;
+  }
+
+  unifyReplacementFrame(substitution, context) {
+    let replacementFrameUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame...`);
+
+    const generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext(),
+          generalSubstitutionReplacementFrame = generalSubstitution.getReplacementFrame(),
+          specificSubstitutionReplacementFrame = specificSubstitution.getReplacementFrame(),
+          generalContext = generalSubstitutionSpecificContext,  ///
+          specificContext = specificSubstitutionSpecificContext,  ///
+          generalFrame = generalSubstitutionReplacementFrame, ///
+          specificFrame = specificSubstitutionReplacementFrame; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalFrameNode = generalFrame.getNode(),
+              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+
+        if (generalMetavariable !== null) {
+          const frame = specificFrame,  ///
+                metavariable = generalMetavariable, ///
+                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+          if (frameUnifies) {
+            specificContext.commit(context);
+
+            replacementFrameUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (replacementFrameUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame.`);
+    }
+
+    return replacementFrameUnifies;
+  }
+
   static name = "FrameSubstitution";
 
   static fromJSON(json, context) {
@@ -253,6 +375,18 @@ export default define(class FrameSubstitution extends Substitution {
   }
 });
 
+function metavariableFromFrameNode(frameNode, context) {
+  let metavariable = null;
+
+  const metavariableNode = frameNode.getMetavariableNode();
+
+  if (metavariableNode !== null) {
+    metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
+  }
+
+  return metavariable;
+}
+
 function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = context.findFrameByFrameNode(targetFrameNode);

package/src/element/substitution/reference.js

@@ -7,7 +7,7 @@ import { breakPointFromJSON } from "../../utilities/breakPoint";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
-import { ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablates, manifest, attempts, sequester, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class ReferenceSubstitution extends Substitution {
   constructor(context, string, node, breakPoint, targetReference, replacementReference) {
@@ -150,7 +150,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's target reference...`);
 
     manifest((context) => {
-      descend((context) => {
+      sequester((context) => {
         const targetReference = this.targetReference.validate(context);
 
         if (targetReference !== null) {
@@ -174,7 +174,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's replacement reference...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementReference = this.replacementReference.validate(context);
 
       if (replacementReference !== null) {

package/src/element/substitution/statement.js

@@ -3,12 +3,11 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { unifySubstitution } from "../../process/unify";
-import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { breakPointFromJSON } from "../../utilities/breakPoint";
+import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, ablates, manifest, attempts, descend, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { join, ablates, manifest, attempts, sequester, reconcile, instantiate, unserialises } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -174,7 +173,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (targetStatementSingular) {
       manifest((context) => {
-        descend((context) => {
+        sequester((context) => {
           const targetStatement = this.targetStatement.validate(context);
 
           if (targetStatement !== null) {
@@ -203,7 +202,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution's replacement statement...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementStatement = this.replacementStatement.validate(context);
 
       if (replacementStatement !== null) {
@@ -218,132 +217,134 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatementValidates;
   }
 
-  unifySimpleSubstitution(simpleSubstitution, context) {
-    let simpleSubstitutionUnifies;
+  unifyTargetStatement(substitution, context) {
+    let targetStatemnentUnifies = false;
 
-    const substitutionString = this.substitution.getString(),
-          simpleSubstitutionString = simpleSubstitution.getString();
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
 
-    context.trace(`Unifying the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution...`);
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's target statement with the '${generalSubstitutionString}' substitution's target statement...`);
 
-    const specificSubstitution = simpleSubstitution,  ///
-          generalSubstitution = this.substitution, ///
-          specificContexts = specificSubstitution.getContexts(),  ///
-          generalContexts = generalSubstitution.getContexts();
+    const generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          generalSubstitutionTargetStatement = generalSubstitution.getTargetStatement(),
+          specificSubstitutionTargetStatement = specificSubstitution.getTargetStatement(),
+          generalContext = generalSubstitutionGeneralContext,  ///
+          specificContext = specificSubstitutionGeneralContext,  ///
+          generalStatement = generalSubstitutionTargetStatement, ///
+          specificStatement = specificSubstitutionTargetStatement; ///
 
     join((specificContext) => {
-      join((generalContext) => {
-        reconcile((specificContext) => {
-          simpleSubstitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+      reconcile((specificContext) => {
+        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-          if (simpleSubstitutionUnifies) {
-            specificContext.commit(context);
-          }
-        }, specificContext)
-      }, ...generalContexts);
-    }, ...specificContexts, context);
+        if (statementUnifies) {
+          specificContext.commit(context);
 
-    if (simpleSubstitutionUnifies) {
-      context.trace(`...unified the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution.`);
+          targetStatemnentUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (targetStatemnentUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's target statement with the '${generalSubstitutionString}' substitution's target statement.`);
     }
 
-    return simpleSubstitutionUnifies;
+    return targetStatemnentUnifies;
   }
 
-  unifyComplexSubstitution(complexSubstitution, context) {
-    let substitution = null;
-
-    const simpleSubstitutionString = this.getString(),  ///
-          complexSubstitutionString = complexSubstitution.getString();  ///
-
-    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
+  unifyReplacementStatement(substitution, context) {
+    let replacementStatemnentUnifies = false;
 
-    const simpleSubstitution = this,  ///
-          simpleSubstitutionGSpecificContext = simpleSubstitution.getSpecificContext(),
-          complexSubstitutionGSpecificContext = complexSubstitution.getSpecificContext(),
-          generalContext = simpleSubstitutionGSpecificContext,  ///
-          specificContext = complexSubstitutionGSpecificContext;  ///
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
 
-    let simpleSubstitutionUnifies = false;
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's replacement statement with the '${generalSubstitutionString}' substitution's replacement statement...`);
 
-    join((context) => {
-      const specificContext = context;  ///
+    const generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext(),
+          generalSubstitutionReplacementStatement = generalSubstitution.getReplacementStatement(),
+          specificSubstitutionReplacementStatement = specificSubstitution.getReplacementStatement(),
+          generalContext = generalSubstitutionSpecificContext,  ///
+          specificContext = specificSubstitutionSpecificContext,  ///
+          generalStatement = generalSubstitutionReplacementStatement, ///
+          specificStatement = specificSubstitutionReplacementStatement; ///
 
+    join((specificContext) => {
       reconcile((specificContext) => {
-        const replacementStatement = complexSubstitution.getReplacementStatement(),
-              replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
+        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (replacementStatementUnifies) {
-          const context = specificContext,  ///
-                soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
+        if (statementUnifies) {
+          specificContext.commit(context);
 
-          substitution = soleNonTrivialDerivedSubstitution;  ///
+          replacementStatemnentUnifies = true;
         }
       }, specificContext);
     }, specificContext, context);
 
-    if (substitution !== null) {
-      substitution = substitution.validate(context);  ///
-
-      simpleSubstitutionUnifies = true;
-    }
-
-    if (simpleSubstitutionUnifies) {
-      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
+    if (replacementStatemnentUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement statement with the '${generalSubstitutionString}' substitution's replacement statement.`);
     }
 
-    return substitution;
+    return replacementStatemnentUnifies;
   }
 
-  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
-    let replacementStatemnentUnifies = false;
+  unifyComplexSubstitution(complexSubstitution, context) {
+    let substitution = null;
 
-    const context = specificContext,  ///
-          replacementStatementString = replacementStatement.getString(),
-          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
+    const simpleSubstitution = this,  ///
+          simpleSubstitutionString = simpleSubstitution.getString(),  ///
+          complexSubstitutionString = complexSubstitution.getString();  ///
+
+    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
+
+    let simpleSubstitutionUnifies = false;
 
-    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement...`);
+    reconcile((context) => {
+      const replacementStatementUnifies = this.unifyReplacementStatement(complexSubstitution, context);
 
-    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
+      if (replacementStatementUnifies) {
+        const soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
 
-    if (statementUnifies) {
-      replacementStatemnentUnifies = true;
+        substitution = soleNonTrivialDerivedSubstitution;  ///
+      }
+    }, context);
+
+    if (substitution !== null) {
+      simpleSubstitutionUnifies = true;
     }
 
-    if (replacementStatemnentUnifies) {
-      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement.`);
+    if (simpleSubstitutionUnifies) {
+      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
     }
 
-    return replacementStatemnentUnifies;
+    return substitution;
   }
 
   resolve(context) {
-    let resolved = false;
-
     const metavariableNode = this.getMetavariableNode(),
-          simpleDerivedSubstitution = context.findSimpleDerivedSubstitutionByMetavariableNode(metavariableNode), ///
-          complexSubstitution = this,
-          simpleSubstitution = simpleDerivedSubstitution; ///
+          simpleDerivedSubstitution = context.findSimpleDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-    if (simpleSubstitution !== null) {
-      const substitutionString = this.getString(); ///
+    if (simpleDerivedSubstitution !== null) {
+      const simpleSubstitution = simpleDerivedSubstitution, ///
+            complexSubstitution = this, ///
+            complexSubstitutionString = complexSubstitution.getString();
 
-      context.trace(`Resolving the ${substitutionString} substitution...`);
+      context.trace(`Resolving the ${complexSubstitutionString}' complex substitution...`);
 
       const substitution = simpleSubstitution.unifyComplexSubstitution(complexSubstitution, context);
 
       if (substitution !== null) {
-        const simpleSubstitution = substitution,  ///
-              simpleSubstitutionUnifies = complexSubstitution.unifySimpleSubstitution(simpleSubstitution, context);
+        const simpleSubstitutionUnifies = this.substitution.unifySubstitution(substitution, context);
 
         if (simpleSubstitutionUnifies) {
-          resolved = true;
-        }
-
-        if (resolved) {
           this.resolved = true;
 
-          context.debug(`...resolved the '${substitutionString}' substitution.`);
+          context.debug(`...resolved the '${complexSubstitutionString}' complex substitution.`);
         }
       }
     }