occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/statement.js

@@ -10,7 +10,6 @@ import { unifyStatement } from "../utilities/unification";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
-import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/context";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -33,6 +32,8 @@ export default define(class Statement {
     return this.tokens;
   }
 
+  isSimple() { return this.node.isSimple();}
+
   isEqualTo(statement) {
     const statementString = statement.getString(),
           equalTo = (statementString === this.string);
@@ -94,6 +95,8 @@ export default define(class Statement {
     return frameContained;
   }
 
+  matchStatementNode(statementNode) { return this.node.match(statementNode); }
+
   verify(assignments, stated, context) {
     let verifies;
 
@@ -111,6 +114,10 @@ export default define(class Statement {
     });
 
     if (verifies) {
+      const statement = this; ///
+
+      context.addStatement(statement);
+
       context.debug(`...verified the '${statementString}' statement.`, this.node);
     }
 
@@ -144,14 +151,18 @@ export default define(class Statement {
     let subproofUnifies = false;
 
     const context = specificContext,  ///
-          statement = this, ///
-          subproofAssertion = subproofAssertionFromStatement(statement, context);
+          statementNode = this.node,
+          subproofAssertionNode = statementNode.getSubproofAssertionNode(),
+          assertionNode = subproofAssertionNode;  ///
+
+    if (assertionNode !== null) {
+      const assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+            subproofAssertion = assertion;  ///
 
-    if (subproofAssertion !== null) {
       const subproofString = subproof.getString(),
             subproofAssertionString = subproofAssertion.getString();
 
-      specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+      context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
       const subproofStatements = subproof.getStatements(),
             subproofAssertionStatements = subproofAssertion.getStatements();
@@ -167,7 +178,7 @@ export default define(class Statement {
       });
 
       if (subproofUnifies) {
-        specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+        context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
       }
     }
 
@@ -193,27 +204,26 @@ export default define(class Statement {
     return statementUnifies;
   }
 
-  unifyIndependently(substitutions, context) {
+  unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiesIndependently = false;
 
-    const statement = this, ///
+    const context = specificContext,  ///
           statementString = this.string;  ///
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    const definedAssertion = definedAssertionFromStatement(statement, context),
-          containedAssertion = containedAssertionFromStatement(statement, context);
-
-    if (definedAssertion !== null) {
-      const definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(substitutions, context);
-
-      unifiesIndependently = definedAssertionUnifiesIndependently; ///
-    }
+    const statementNode = this.node,
+          definedAssertionNode = statementNode.getDefinedAssertionNode(),
+          containedAssertionNode = statementNode.getContainedAssertionNode();
 
-    if (containedAssertion !== null) {
-      const containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(substitutions, context);
+    if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {
+      const assertionNode = (definedAssertionNode || containedAssertionNode),
+            assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+            assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = containedAssertionUnifiesIndependently; ///
+      if (assertionUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (unifiesIndependently) {
@@ -327,28 +337,28 @@ export default define(class Statement {
     return statement;
   }
 
-  static fromSuppositionNode(suppositionNode, context) {
+  static fromAssumptionNode(assumptionNode, context) {
     let statement = null;
 
-    const statementNode = suppositionNode.getStatementNode();
+    let statementNode;
+
+    statementNode = assumptionNode.getStatementNode(); ///
 
     if (statementNode !== null) {
+      statementNode = stripBracketsFromStatementNode(statementNode);  ///
+
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromDeclarationNode(declarationNode, context) {
+  static fromSuppositionNode(suppositionNode, context) {
     let statement = null;
 
-    let statementNode;
-
-    statementNode = declarationNode.getStatementNode(); ///
+    const statementNode = suppositionNode.getStatementNode();
 
     if (statementNode !== null) {
-      statementNode = stripBracketsFromStatementNode(statementNode);  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 

package/src/ontology/step.js

@@ -2,14 +2,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 +18,10 @@ export default define(class Step {
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -74,31 +79,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 +123,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;
 
@@ -168,7 +181,8 @@ export default define(class Step {
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const step = this,  ///
+      const { Substitutions } = ontology,
+            step = this,  ///
             substitutions = Substitutions.fromNothing(),
             stepUnifies = axiom.unifyStep(step, substitutions, context);
 
@@ -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

@@ -2,27 +2,26 @@
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 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 +65,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; ///
 
@@ -110,7 +109,8 @@ export default define(class Subproof {
       const axiomSatisfiable = axiom.isSatisfiable();
 
       if (axiomSatisfiable) {
-        const subproof = this,  ///
+        const { Substitutions } = ontology,
+              subproof = this,  ///
               substitutions = Substitutions.fromNothing(),
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 
@@ -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;
   }