occam-verify-cli 1.0.388 → 1.0.396

package/src/ontology/statement.js

@@ -94,6 +94,8 @@ export default define(class Statement {
     return frameContained;
   }
 
+  matchStatementNode(statementNode) { return this.node.match(statementNode); }
+
   verify(assignments, stated, context) {
     let verifies;
 
@@ -111,6 +113,10 @@ export default define(class Statement {
     });
 
     if (verifies) {
+      const statement = this; ///
+
+      context.addStatement(statement);
+
       context.debug(`...verified the '${statementString}' statement.`, this.node);
     }
 

package/src/ontology/step.js

@@ -3,13 +3,15 @@
 import ontology from "../ontology";
 import unifyMixins from "../mixins/step/unify";
 import Substitutions from "../substitutions";
+import TemporaryContext from "../context/temporary";
 import equationalUnifier from "../unifier/equantional";
 
 import { define } from "../ontology";
 import { propertyAssertionFromStatement } from "../utilities/context";
 
 export default define(class Step {
-  constructor(node, string, statement, reference, satisfiesAssertion) {
+  constructor(context, node, string, statement, reference, satisfiesAssertion) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
@@ -17,6 +19,10 @@ export default define(class Step {
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -74,31 +80,13 @@ export default define(class Step {
     return termAndPropertyRelationMatch;
   }
 
-  unify(substitutions, context) {
-    let unifies;
-
-    const stepString = this.string;  ///
-
-    context.trace(`Unifying the '${stepString}' step...`, this.node);
-
-    unifies = unifyMixins.some((unifyMixin) => {
-      const unifies = unifyMixin(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
-
-      if (unifies) {
-        return true;
-      }
-    });
-
-    if (unifies) {
-      context.debug(`...unified the '${stepString}' step.`, this.node);
-    }
-
-    return unifies;
-  }
-
   verify(substitutions, assignments, context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const stepString = this.string; ///
 
     context.trace(`Verifying the '${stepString}' step...`, this.node);
@@ -136,12 +124,38 @@ export default define(class Step {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${stepString}' step.`, this.node);
     }
 
     return verifies;
   }
 
+  unify(substitutions, context) {
+    let unifies;
+
+    context = this.context;
+
+    const stepString = this.string;  ///
+
+    context.trace(`Unifying the '${stepString}' step...`, this.node);
+
+    unifies = unifyMixins.some((unifyMixin) => {
+      const unifies = unifyMixin(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+
+      if (unifies) {
+        return true;
+      }
+    });
+
+    if (unifies) {
+      context.debug(`...unified the '${stepString}' step.`, this.node);
+    }
+
+    return unifies;
+  }
+
   equateWithStatement(statement, context) {
     let statementEquates;
 
@@ -196,7 +210,7 @@ export default define(class Step {
           node = null,
           reference = null,
           satisfiesAssertion = null,
-          step = new Step(node, string, statement, reference, satisfiesAssertion);
+          step = new Step(context, node, string, statement, reference, satisfiesAssertion);
 
     return step;
   }
@@ -213,9 +227,12 @@ export default define(class Step {
             string = context.nodeAsString(node),
             statement = Statement.fromStepNode(stepNode, context),
             reference = Reference.fromStepNode(stepNode, context),
-            satisfiesAssertion = SatisfiesAssertion.fromStepNode(stepNode, context);
+            satisfiesAssertion = SatisfiesAssertion.fromStepNode(stepNode, context),
+            temporaryContext = null;
+
+      context = temporaryContext; ///
 
-      step = new Step(node, string, statement, reference, satisfiesAssertion);
+      step = new Step(context, node, string, statement, reference, satisfiesAssertion)
     }
 
     return step;

package/src/ontology/subproof.js

@@ -8,21 +8,21 @@ import { define } from "../ontology";
 import { subproofStringFromSubproofNode } from "../utilities/subproof";
 
 export default define(class Subproof {
-  constructor(node, string, suppositions, subDerivation) {
-    this.node = node;
+  constructor(string, node, suppositions, subDerivation) {
     this.string = string;
+    this.node = node;
     this.suppositions = suppositions;
     this.subDerivation = subDerivation;
   }
 
-  getNode() {
-    return this.node;
-  }
-
   getString() {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getSuppositions() {
     return this.suppositions;
   }
@@ -66,7 +66,7 @@ export default define(class Subproof {
   verify(substitutions, assignments, context) {
     let subproofVerifies = false;
 
-    const localContext = LocalContext.fromContext(context);  ///
+    const localContext = LocalContext.fromNothing(context);  ///
 
     context = localContext; ///
 
@@ -146,7 +146,7 @@ export default define(class Subproof {
             node = subproofNode,  ///
             string = subproofString;  ///
 
-      subproof = new Subproof(node, string, suppositions, subDerivation);
+      subproof = new Subproof(string, node, suppositions, subDerivation);
     }
 
     return subproof;

package/src/ontology/substitution/frame.js

@@ -7,8 +7,8 @@ import FrameSubstitutionPartialContext from "../../context/partial/substitution/
 import { define } from "../../ontology";
 
 export default define(class FrameSubstitution extends Substitution {
-  constructor(string, node, tokens, frame, metavariable) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, frame, metavariable) {
+    super(context, string, node, tokens);
 
     this.frame = frame;
     this.metavariable = metavariable;
@@ -22,12 +22,6 @@ export default define(class FrameSubstitution extends Substitution {
     return this.metavariable;
   }
 
-  isFrameEqualTo(frame) { return this.frame.isEqualTo(frame); }
-
-  isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
-
-  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
-
   getReplacementNode() {
     const frameNode = this.frame.getNode(),
           replacementNode = frameNode; ///
@@ -35,28 +29,80 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementNode;
   }
 
-  static fromStatementNode(statementNode, context) {
+  isFrameEqualToFrame(frame) { return this.frame.isEqualTo(frame); }
+
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+
+  matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
+
+  verify(context) {
+    let verifies = false;
+
+    const frameSubstitutionString = this.string;  ///
+
+    context.trace(`Verifiying the '${frameSubstitutionString}' frame substitutin...`);
+
+    const frameSimple = this.frame.isSimple();
+
+    if (frameSimple) {
+      if (this.metavariable === null) {
+        context.debug(`The specific frame is not simple.`);
+      } else {
+        const metavariablePresent = context.isMetavariablePresent(this.metavariable);
+
+        if (metavariablePresent) {
+          const metavariable = this.frame.getMetavariable(),
+                metavariablePresent = context.isMetavariablePresent(metavariable);
+
+          if (metavariablePresent) {
+            verifies = true;
+          } else {
+            const metavariableString = metavariable.getString();
+
+            context.debug(`The '${metavariableString}' metavariable is not present.`);
+          }
+        } else {
+          const metavariableString = this.metavariable.getString();
+
+          context.debug(`The '${metavariableString}' metavariable is not present.`);
+        }
+      }
+    } else {
+      context.debug(`The general frame is not simple.`);
+    }
+
+    if (verifies) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...verified the '${frameSubstitutionString}' frame substitutin.`);
+    }
+
+    return verifies;
+  }
+
+  static name = "FrameSubstitution";
+
+  static fromStatement(statement, context) {
     let frameSubstitution = null;
 
-    const frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
+    const statementNode = statement.getNode(),
+          frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      const lastFrameNode = frameSubstitutionNode.getLastFrameNode(),
+      const { Frame, Metavariable } = ontology,
             firstFrameNode = frameSubstitutionNode.getFirstFrameNode(),
-            singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
-
-      if (singularMetavariableNode !== null) {
-        const { Frame, Metavariable } = ontology,
-              frameNode = firstFrameNode, ///
-              metavariableNode = singularMetavariableNode,  ///
-              frame = Frame.fromFrameNode(frameNode, context),
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
-              node = frameSubstitutionNode,  ///
-              tokens = context.nodeAsTokens(node),
-              string = stringFromFrameAndMetavariable(frame, metavariable);
-
-        frameSubstitution = new FrameSubstitution(string, node, tokens, frame, metavariable);
-      }
+            lastMetavariableNode = frameSubstitutionNode.getLastMetavariableNode(),
+            metavariableNode = lastMetavariableNode,  ///
+            frameNode = firstFrameNode, ///
+            node = frameSubstitutionNode,  ///
+            tokens = context.nodeAsTokens(node),
+            string = context.nodeAsString(node),
+            frame = Frame.fromFrameNode(frameNode, context),
+            metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+
+      frameSubstitution = new FrameSubstitution(context, string, node, tokens, frame, metavariable);
     }
 
     return frameSubstitution;
@@ -69,7 +115,7 @@ export default define(class FrameSubstitution extends Substitution {
           frameSubstitutionPartialContext = FrameSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = frameSubstitutionPartialContext.getNode(),
           tokens = frameSubstitutionPartialContext.getTokens(),
-          frameSubstitution = new FrameSubstitution(string, node, tokens, frame, metavariable);
+          frameSubstitution = new FrameSubstitution(context, string, node, tokens, frame, metavariable);
 
     return frameSubstitution;
   }

package/src/ontology/substitution/reference.js

@@ -6,8 +6,8 @@ import ReferenceSubstitutionPartialContext from "../../context/partial/substitut
 import { define } from "../../ontology";
 
 export default define(class ReferenceSubstitution extends Substitution {
-  constructor(string, node, tokens, reference, metavariable) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, reference, metavariable) {
+    super(context, string, node, tokens);
 
     this.reference = reference;
     this.metavariable = metavariable;
@@ -21,12 +21,14 @@ export default define(class ReferenceSubstitution extends Substitution {
     return this.metavariable;
   }
 
-  isReferenceEqualTo(reference) {
-    const referenceEqualTo = this.reference.isEqualTo(reference);
+  isReferenceEqualToReference(reference) {
+    const referenceEqualToReference = this.reference.isEqualTo(reference);
 
-    return referenceEqualTo;
+    return referenceEqualToReference;
   }
 
+  static name = "ReferenceSubstitution";
+
   static fromReferenceAndMetavariable(reference, metavariable, context) {
     const string = stringFromReferenceAndMetavariable(reference, metavariable),
           lexer = context.getLexer(),
@@ -34,7 +36,7 @@ export default define(class ReferenceSubstitution extends Substitution {
           referenceSubstitutionPartialContext = ReferenceSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = referenceSubstitutionPartialContext.getNode(),
           tokens = referenceSubstitutionPartialContext.getTokens(),
-          referenceSubstitution = new ReferenceSubstitution(string, node, tokens, reference, metavariable);
+          referenceSubstitution = new ReferenceSubstitution(context, string, node, tokens, reference, metavariable);
 
     return referenceSubstitution;
   }

package/src/ontology/substitution/statement.js

@@ -10,8 +10,8 @@ import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../../utilities/json";
 
 export default define(class StatementSubstitution extends Substitution {
-  constructor(string, node, tokens, resolved, statement, metavariable, substitution) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, resolved, statement, metavariable, substitution) {
+    super(context, string, node, tokens);
 
     this.resolved = resolved;
     this.statement = statement;
@@ -35,125 +35,139 @@ export default define(class StatementSubstitution extends Substitution {
     return this.substitution;
   }
 
-  isStatementEqualTo(statement, context) {
+  getReplacementNode() {
+    const statementNode = this.statement.getNode(),
+          replacementNode = statementNode; ///
+
+    return replacementNode;
+  }
+
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
+  }
+
+  isStatementEqualToStatement(statement, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const statementEqualTo = this.statement.isEqualTo(statement);
+    const statementEqualToStatement = this.statement.isEqualTo(statement);
 
-    return statementEqualTo;
+    return statementEqualToStatement;
   }
 
-  isMetavariableEqualTo(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  isSubstitutionEqualTo(substitution) {
-    let substitutionEqualTo;
+  isSubstitutionEqualToSubstitution(substitution) {
+    let substitutionEqualToSubstitution;
 
-    if (false) {
-      ///
-    } else if ((substitution === null) && (this.substitution === null)) {
-      substitutionEqualTo = true;
-    } else if ((substitution !== null) && (this.substitution === null)) {
-      substitutionEqualTo = false;
-    } else if ((substitution === null) && (this.substitution !== null)) {
-      substitutionEqualTo = false;
+    if (this.substitution === null) {
+      substitutionEqualToSubstitution = (substitution === null);
     } else {
-      substitutionEqualTo = this.substitution.isEqualTo(substitution);
+      if (substitution === null) {
+        substitutionEqualToSubstitution = false;
+      } else {
+        substitutionEqualToSubstitution = this.substitution.isEqualToSubstitution(substitution);
+      }
     }
 
-    return substitutionEqualTo;
-  }
-
-  isSimple() {
-    const simple = (this.substitution === null);
-
-    return simple;
+    return substitutionEqualToSubstitution;
   }
 
   matchParameter(parameter) { return this.metavariable.matchParameter(parameter); }
 
-  getReplacementNode() {
-    const statementNode = this.statement.getNode(),
-          replacementNode = statementNode; ///
-
-    return replacementNode;
-  }
+  unifyStatement(statement, context) {
+    let substitution = null;
 
-  resolve(substitutions, generalContext, specificContext) {
-    const substitutionString = this.string; ///
+    const substitutions = Substitutions.fromNothing(),
+          generalContext = context; ///
 
-    const metavariable = this.getMetavariable(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
+    context = this.getContext();
 
-    if (simpleSubstitution !== null) {
-      specificContext.trace(`Resolving the ${substitutionString} substitution...`);
+    const specificContext = context, ///
+          statementUnifies = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
 
-      const substitution = simpleSubstitution,  ///
-            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, generalContext, specificContext);
+    if (statementUnifies) {
+      const substitutionsNonTrivialLength = substitutions.getNonTrivialLength();
 
-      this.resolved = substitutionResolved; ///
+      if (substitutionsNonTrivialLength === 1) {
+        const firstSubstitution = substitutions.getFirstSubstitution();
 
-      if (this.resolved) {
-        specificContext.debug(`...resolved the ${substitutionString} substitution.`);
+        substitution = firstSubstitution; ///
       }
     }
+
+    return substitution;
   }
 
-  resolveSubstitution(substitution, statement, substitutions, generalContext, specificContext) {
-    let substitutionResolved = false;
+  unifySubstitution(substitution, substitutions, context) {
+    const frame = context.getFrame(),
+          generalSubstitution = this.substitution,  ///
+          specificSubstitution = substitution,  ///
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
 
-    const substitutionString = substitution.getString();
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-    specificContext.trace(`Resolving the ${substitutionString} substitution...`);
+    let substitutionContext;
 
-    const generalSubstitution = substitution, ///
-          specificSubstitution = this.unifyStatement(statement, specificContext, specificContext);  ///
+    substitutionContext = this.substitution.getContext();
 
-    if (specificSubstitution !== null) {
-      substitutions.snapshot();
+    const generalContext = substitutionContext; ///
 
-      const generalSubstitutionString = generalSubstitution.getString(),
-            specificSubstitutionString = specificSubstitution.getString();
+    substitutionContext = substitution.getContext();
 
-      specificContext.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+    const specificContext = substitutionContext;  ///
 
-      const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
+    specificContext.addFrame(frame);
 
+    substitutions.snapshot();
 
-      if (substitutionUnifies) {
-        specificContext.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
-      }
+    const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext);
 
-      substitutionUnifies ?
-        substitutions.continue() :
-          substitutions.rollback(specificContext);
+    specificContext.removeFrame(frame);
 
-      substitutionResolved = substitutionUnifies;  ///
-    }
+    substitutionUnifies ?
+      substitutions.continue() :
+        substitutions.rollback(context);
 
-    if (substitutionResolved) {
-      specificContext.debug(`...resolved the ${substitutionString} substitution.`);
+    if (substitutionUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
     }
 
-    return substitutionResolved;
+    return substitutionUnifies;
   }
 
-  unifyStatement(statement, generalContext, specificContext) {
-    let specificSubstitution = null;
+  resolve(substitutions, context) {
+    const substitutionString = this.string; ///
 
-    const substitutions = Substitutions.fromNothing(),
-          statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    context.trace(`Resolving the ${substitutionString} substitution...`);
 
-    if (statementUnifies) {
-      const substitutionsNonTrivialLength = substitutions.getNonTrivialLength();
+    const metavariable = this.getMetavariable(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable);
 
-      if (substitutionsNonTrivialLength === 1) {
-        const firstSubstitution = substitutions.getFirstSubstitution();
+    if (simpleSubstitution !== null) {
+      let substitution;
 
-        specificSubstitution = firstSubstitution; ///
+      substitution = simpleSubstitution;  ///
+
+      const context = substitution.getContext(),
+            statement = substitution.getStatement();
+
+      substitution = this.unifyStatement(statement, context);
+
+      if (substitution !== null) {
+        const substitutionUnifies = this.unifySubstitution(substitution, substitutions, context);
+
+        if (substitutionUnifies) {
+          this.resolved = true;
+        }
       }
     }
 
-    return specificSubstitution;
+    if (this.resolved) {
+      context.debug(`...resolved the ${substitutionString} substitution.`);
+    }
   }
 
   toJSON() {
@@ -171,6 +185,8 @@ export default define(class StatementSubstitution extends Substitution {
     return json;
   }
 
+  static name = "StatementSubstitution";
+
   static fromJSON(json, context) {
     const { string } = json,
           lexer = context.getLexer(),
@@ -182,7 +198,7 @@ export default define(class StatementSubstitution extends Substitution {
           statement = statementFromJSON(json, context),
           metavariable = metavariableFromJSON(json, context),
           substitution = null,  ///
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }
@@ -198,7 +214,7 @@ export default define(class StatementSubstitution extends Substitution {
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = true,
           substitution = null,
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }
@@ -213,7 +229,7 @@ export default define(class StatementSubstitution extends Substitution {
           node = statementSubstitutionPartialContext.getNode(),
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = false,
-          statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
+          statementSubstitution = new StatementSubstitution(context, string, node, tokens, resolved, statement, metavariable, substitution);
 
     return statementSubstitution;
   }