occam-verify-cli 1.0.587 → 1.0.602

package/src/element/substitution/reference.js

@@ -38,6 +38,21 @@ export default define(class ReferenceSubstitution extends Substitution {
     return replacementNode;
   }
 
+  getMetavariable(generalContext, specificContext) {
+    let metavariable = null;
+
+    const targetReferenceNode = this.targetReference.getNode(),
+          metavariableName = targetReferenceNode.getMetavariableName();
+
+    if (metavariableName !== null) {
+      const context = generalContext; ///
+
+      metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    }
+
+    return metavariable;
+  }
+
   isTrivial() {
     const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
           trivial = targetReferenceEqualToReplacementReference; ///
@@ -59,38 +74,51 @@ export default define(class ReferenceSubstitution extends Substitution {
     return comparesToParameter;
   }
 
-  validate(context) {
+  validate(generalContext, specificContext) {
     let validates = false;
 
+    const context = this.getContext();
+
+    specificContext = context;  ///
+
     const referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
 
-    const targetReferenceValidates = this.validateTargetReference(context);
+    const valid = this.isValid(context);
 
-    if (targetReferenceValidates) {
-      const replacementReferenceValidates = this.validateReplacementReference(context);
+    if (valid) {
+      validates = true;
+
+      context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
+    } else {
+      const targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
+
+      if (targetReferenceValidates) {
+        const replacementReferenceValidates = this.validateReplacementReference(generalContext, specificContext);
 
-      if (replacementReferenceValidates) {
-        validates = true;
+        if (replacementReferenceValidates) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const substititoin = this;  ///
+      if (validates) {
+        const substititoin = this;  ///
 
-      context.addSubstitution(substititoin);
+        context.addSubstitution(substititoin);
 
-      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
+        context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
+      }
     }
 
     return validates;
   }
 
-  validateTargetReference(context) {
+  validateTargetReference(generalContext, specificContext) {
     let targetReferenceValidates = false;
 
-    const targetReferenceString = this.targetReference.getString(),
+    const context = generalContext, ///
+          targetReferenceString = this.targetReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
@@ -110,10 +138,11 @@ export default define(class ReferenceSubstitution extends Substitution {
     return targetReferenceValidates;
   }
 
-  validateReplacementReference(context) {
+  validateReplacementReference(generalContext, specificContext) {
     let replacementReferenceValidates;
 
-    const replacementReferenceString = this.replacementReference.getString(),
+    const context = specificContext,  ///
+          replacementReferenceString = this.replacementReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);

package/src/element/substitution/statement.js

@@ -3,10 +3,10 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
+import { liminally, literally, synthetically } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementToStatementJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
@@ -37,6 +37,21 @@ export default define(class StatementSubstitution extends Substitution {
     return this.replacementStatement;
   }
 
+  getMetavariable(generalContext, specificContext) {
+    let metavariable = null;
+
+    const targetStatementNode = this.targetStatement.getNode(),
+          metavariableName = targetStatementNode.getMetavariableName();
+
+    if (metavariableName !== null) {
+      const context = generalContext; ///
+
+      metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    }
+
+    return metavariable;
+  }
+
   getTargetNode() {
     const targetStatementNode = this.targetStatement.getNode(),
           targetNode = targetStatementNode; ///
@@ -91,38 +106,53 @@ export default define(class StatementSubstitution extends Substitution {
     return comparesToSubstitution;
   }
 
-  validate(context) {
+  compareMetavariable(metavariable) { return this.targetStatement.compareMetavariable(metavariable); }
+
+  validate(generalContext, specificContext) {
     let validates = false;
 
+    const context = this.getContext();
+
+    specificContext = context;  ///
+
     const statementSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution...`);
 
-    const targetStatementValidates = this.validateTargetStatement(context);
+    const valid = this.isValid(context);
 
-    if (targetStatementValidates) {
-      const replacementStatementValidates = this.validateReplacementStatement(context);
+    if (valid) {
+      validates = true;
 
-      if (replacementStatementValidates) {
-        validates = true;
+      context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
+    } else {
+      const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
+
+      if (targetStatementValidates) {
+        const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
+
+        if (replacementStatementValidates) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const substititoin = this;  ///
+      if (validates) {
+        const substititoin = this;  ///
 
-      context.addSubstitution(substititoin);
+        context.addSubstitution(substititoin);
 
-      context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
+        context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
+      }
     }
 
     return validates;
   }
 
-  validateTargetStatement(context) {
+  validateTargetStatement(generalContext, specificContext) {
     let targetStatementValidates = false;
 
-    const targetStatementString = this.targetStatement.getString(),
+    const context = generalContext, ///
+          targetStatementString = this.targetStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement...`);
@@ -145,10 +175,11 @@ export default define(class StatementSubstitution extends Substitution {
     return targetStatementValidates;
   }
 
-  validateReplacementStatement(context) {
+  validateReplacementStatement(generalContext, specificContext) {
     let replacementStatementValidates;
 
-    const replacementStatementString = this.replacementStatement.getString(),
+    const context = specificContext,  ///
+          replacementStatementString = this.replacementStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
@@ -165,65 +196,39 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatementValidates;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnifies = false;
-
-    const statementString = statement.getString(),
-          statementSubstitutionString = this.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${statementSubstitutionString}' statement substiution's statement...`);
-
-    const specificContext = context; ///
+  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
+    let replacementStatemnentUnifies = false;
 
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
+    const context = specificContext,  ///
+          substitutionString = this.getString(),  ///
+          replacementStatementString = replacementStatement.getString(),
+          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
 
-    const substitutions = [];
+    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement...`);
 
-    statementUnifies = this.replacementStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    let substitution = null;
+    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
 
     if (statementUnifies) {
-      const substitutionsNonTrivialLength = substitutions.getNonTrivialLength();
-
-      if (substitutionsNonTrivialLength === 1) {
-        const firstSubstitution = substitutions.getFirstSubstitution();
-
-        substitution = firstSubstitution; ///
-      } else {
-        statementUnifies = false;
-      }
+      replacementStatemnentUnifies = true;
     }
 
-    if (statementUnifies) {
-      context.trace(`...unified the '${statementString}' statement with the '${statementSubstitutionString}' statement substiution's statement.`);
+    if (replacementStatemnentUnifies) {
+      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement.`);
     }
 
-    return substitution;
+    return replacementStatemnentUnifies;
   }
 
-  unifySubstitution(substitution, substitutions, context) {
-    const generalSubstitution = this.substitution,  ///
+  unifySubstitution(substitution, generalContext, specificContext) {
+    const context = specificContext,
+          generalSubstitution = this.substitution,  ///
           specificSubstitution = substitution,  ///
           generalSubstitutionString = generalSubstitution.getString(),
           specificSubstitutionString = specificSubstitution.getString();
 
     context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-    let substitutionContext;
-
-    substitutionContext = this.substitution.getContext();
-
-    const generalContext = substitutionContext; ///
-
-    substitutionContext = substitution.getContext();
-
-    const specificContext = substitutionContext,  ///
-          substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
+    const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
 
     if (substitutionUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
@@ -232,30 +237,77 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionUnifies;
   }
 
-  resolve(substitutions, context) {
+  resolve(generalContext, specificContext) {
+    let context;
+
     context = this.getContext();
 
     const substitutionString = this.getString(); ///
 
     context.trace(`Resolving the ${substitutionString} substitution...`);
 
-    substitutions.snapshot(context);
+    context = generalContext; ///
+
+    const metavariable = this.getMetavariable(generalContext, specificContext);
 
-    const metavariable = this.getMetavariable(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
-          substitution = simpleSubstitution.unifyStatement(this.replacementStatement, context);
+    context = specificContext;  ///
+
+    const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+
+    context = this.getContext();
 
-    if (substitution !== null) {
-      const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
+    const subtitution = liminally((context) => {
+      let substitution = null;
 
-      if (substitutionUnifies) {
-        this.resolved = true;
+      const specificContext = context;  ///
+
+      context = simpleSubstitution.getContext();
+
+      const generalContext = context; ///
+
+      context = specificContext;  ///
+
+      const replacementStatementUnifies = simpleSubstitution.unifyReplacementStatement(this.replacementStatement, generalContext, specificContext);
+
+      if (replacementStatementUnifies) {
+        const nested = false,
+              soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
+
+        substitution = soleNonTrivialSubstitution;  ///
       }
-    }
 
-    this.resolved ?
-      substitutions.continue(context) :
-        substitutions.rollback(context);
+      return substitution;
+    }, context);
+
+    if (subtitution !== null) {
+      liminally((specificContext) => {
+        const contexts = [];
+
+        context = simpleSubstitution.getContext();
+
+        contexts.push(context);
+
+        context = this.getContext();
+
+        contexts.push(context);
+
+        context = specificContext;  ///
+
+        synthetically((context) => {
+          const specificContext = context;  ///
+
+          context = this.substitution.getContext();
+
+          const generalContext = context; ///
+
+          this.unifySubstitution(subtitution, generalContext, specificContext);
+        }, contexts, context);
+
+        specificContext.commit();
+      }, specificContext);
+
+      this.resolved = true;
+    }
 
     if (this.resolved) {
       context.debug(`...resolved the '${substitutionString}' substitution.`);
@@ -303,7 +355,7 @@ export default define(class StatementSubstitution extends Substitution {
       const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
             string = statementSubstitutionString, ///
             statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context);
+            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
       return statementSubstitution;
     }, context);

package/src/element/substitution/term.js

@@ -39,6 +39,20 @@ export default define(class TermSubstitution extends Substitution {
     return replacementNode;
   }
 
+  getVariable(generalContext, specificContext) {
+    let variable = null;
+
+    const targetTermNode = this.targetTerm.getNode(),
+          variableIdentifier = targetTermNode.getVariableIdentifier();
+
+    if (variableIdentifier !== null) {
+      const context = specificContext;  ///
+      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    }
+
+    return variable;
+  }
+
   isTrivial() {
     const targetTermEqualToReplacementTerm = this.targetTerm.isEqualTo(this.replacementTerm),
           trivial = targetTermEqualToReplacementTerm; ///
@@ -62,38 +76,51 @@ export default define(class TermSubstitution extends Substitution {
     return comparesToParameter;
   }
 
-  validate(context) {
+  validate(generalContext, specificContext) {
     let validates = false;
 
+    const context = this.getContext();
+
+    specificContext = context;  ///
+
     const termSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution...`);
 
-    const targetTermValidates = this.validateTargetTerm(context);
+    const valid = this.isValid(context);
 
-    if (targetTermValidates) {
-      const replacementTermValidates = this.validateReplacementTerm(context);
+    if (valid) {
+      validates = true;
+
+      context.debug(`...the '${termSubstitutionString}' term substitution is alrady valid.`);
+    } else {
+      const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
 
-      if (replacementTermValidates) {
-        validates = true;
+      if (targetTermValidates) {
+        const replacementTermValidates = this.validateReplacementTerm(generalContext, specificContext);
+
+        if (replacementTermValidates) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const substititoin = this;  ///
+      if (validates) {
+        const substititoin = this;  ///
 
-      context.addSubstitution(substititoin);
+        context.addSubstitution(substititoin);
 
-      context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
+        context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
+      }
     }
 
     return validates;
   }
 
-  validateTargetTerm(context) {
+  validateTargetTerm(generalContext, specificContext) {
     let targetTermValidates = false;
 
-    const targetTermString = this.targetTerm.getString(),
+    const context = generalContext, ///
+          targetTermString = this.targetTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${targetTermString}' target term...`);
@@ -117,10 +144,11 @@ export default define(class TermSubstitution extends Substitution {
     return targetTermValidates;
   }
 
-  validateReplacementTerm(context) {
+  validateReplacementTerm(generalContext, specificContext) {
     let replacementTermValidates;
 
-    const replacementTermString = this.replacementTerm.getString(),
+    const context = specificContext,  ///
+          replacementTermString = this.replacementTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);

package/src/element/substitution.js

@@ -25,6 +25,47 @@ export default class Substitution extends Element {
     return primitive;
   }
 
+  getMetavariable(context) {
+    const metavariable = null;
+
+    return metavariable;
+  }
+
+  getSubstitutionNode() {
+    const node = this.getNode(),
+          substitutionNode = node; ///
+
+    return substitutionNode;
+  }
+
+  matchSubstitutionNode(substitutionNode) {
+    const substitutionNodeA = substitutionNode; ///
+
+    substitutionNode = this.getSubstitutionNode();
+
+    const substitutionNodeB = substitutionNode, ///
+          substitutionNodeAAMatchesSubstitutionBNodeB = substitutionNodeA.match(substitutionNodeB),
+          equalTo = substitutionNodeAAMatchesSubstitutionBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const substitutionNode = this.getSubstitutionNode(),
+          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode),
+          valid = substitutionPresent;  ///
+
+    return valid;
+  }
+
+  isEqualTo(substitution) {
+    const substitutionNode = substitution.getNode(),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          equalTo = substitutionNodeMatches;  ///
+
+    return equalTo;
+  }
+
   isSimple() {
     const simple = true;
 
@@ -44,6 +85,13 @@ export default class Substitution extends Element {
     return trivial;
   }
 
+  isNonTrivial() {
+    const trivial = this.isTrivial(),
+          nonTrivlal = !trivial;
+
+    return nonTrivlal;
+  }
+
   isFrameEqualToFrame(frame) {
     const frameEqualToFrame = false;
 
@@ -56,21 +104,10 @@ export default class Substitution extends Element {
     return referenceEqualToReference;
   }
 
-  isMetavariableEqualToMetavariable(metavariable) {
-    const metavariableEqualToMetavariable = false;
-
-    return metavariableEqualToMetavariable;
-  }
-
-  isEqualTo(substitution) {
-    const substitutionA = this, ///
-          substitutionB = substitution, ///
-          substitutionANode = substitutionA.getNode(),
-          substitutionBNode = substitutionB.getNode(),
-          substitutionANodeMatchesSubstitutionBNode = substitutionANode.match(substitutionBNode),
-          equalTo = substitutionANodeMatchesSubstitutionBNode; ///
+  compare(substitution) {
+    const comparesToSubstitution = false;
 
-    return equalTo;
+    return comparesToSubstitution;
   }
 
   compareTerm(term, context) {
@@ -91,13 +128,13 @@ export default class Substitution extends Element {
     return comparesToParameter;
   }
 
-  compareSubstitution(substitution) {
-    const comparesToSubstitution = false;
+  compareMetavariable(metavariable) {
+    const compaaresToMetavariable = false;
 
-    return comparesToSubstitution;
+    return compaaresToMetavariable;
   }
 
-  resolve(substitutions, context) {
+  resolve(substitutions, generalContext, specificContext) {
     const resolved = true;
 
     return resolved;