occam-verify-cli 1.0.405 → 1.0.414

package/src/context/temporary.js

@@ -5,15 +5,15 @@ import { arrayUtilities } from "necessary";
 const { extract, compress } = arrayUtilities;
 
 export default class TemporaryContext {
-  constructor(context, tokens, terms, frames, statements, assertions, substitutions, reference) {
+  constructor(context, tokens, terms, frames, statements, assertions, references, substitutions) {
     this.context = context;
     this.tokens = tokens;
     this.terms = terms;
     this.frames = frames;
     this.statements = statements;
     this.assertions = assertions;
+    this.references = references;
     this.substitutions = substitutions;
-    this.reference = reference;
   }
 
   getContext() {
@@ -40,111 +40,126 @@ export default class TemporaryContext {
     return this.assertions;
   }
 
-  getSubstitutions() {
-    return this.substitutions;
+  getReferences() {
+    return this.references;
   }
 
-  getReference() {
-    return this.reference;
+  getSubstitutions() {
+    return this.substitutions;
   }
 
   addTerm(term) {
-    const context = this, ///
-          termNode = term.getNode(),
+    const termA = term, ///
+          context = this, ///
           termString = term.getString();
 
     extract(this.terms, (term) => {
-      const termMatchesTermNode = term.matchTermNode(termNode);
+      const termB = term, ///
+            termAEqualToTermB = termA.isEqualTo(termB);
 
-      if (termMatchesTermNode) {
+      if (termAEqualToTermB) {
         return true;
       }
     });
 
-    context.trace(`ADded the '${termString}' term.`);
+    context.trace(`ADded the '${termString}' term to the context.`);
 
     this.terms.push(term);
   }
 
   addFrame(frame) {
-    const context = this, ///
-          frameNode = frame.getNode(),
+    const frameA = frame, ///
+          context = this, ///
           frameString = frame.getString();
 
     extract(this.frames, (frame) => {
-      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+      const frameB = frame, ///
+            frameAEqualToFrameB = frameA.isEqualTo(frameB);
 
-      if (frameMatchesFrameNode) {
+      if (frameAEqualToFrameB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${frameString}' frame.`);
+    context.trace(`Added the '${frameString}' frame to the context.`);
 
     this.frames.push(frame);
   }
 
   addStatement(statement) {
     const context = this, ///
-          statementNode = statement.getNode(),
+          statementA = statement, ///
           statementString = statement.getString();
 
     extract(this.statements, (statement) => {
-      const statementMatchesFrameNode = statement.matchStatementNode(statementNode);
+      const statementB = statement, ///
+            statementAEqualToFrameB = statementA.isEqualTo(statementB);
 
-      if (statementMatchesFrameNode) {
+      if (statementAEqualToFrameB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${statementString}' statement.`);
+    context.trace(`Added the '${statementString}' statement to the context.`);
 
     this.statements.push(statement);
   }
 
   addAssertion(assertion) {
     const context = this, ///
-          assertionNode = assertion.getNode(),
+          assertionA = assertion, ///
           assertionString = assertion.getString();
 
     extract(this.assertions, (assertion) => {
-      const assertionMatchesFrameNode = assertion.matchAssertionNode(assertionNode);
+      const assertionB = assertion, ///
+            assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
 
-      if (assertionMatchesFrameNode) {
+      if (assertionAEqualToAssertionB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${assertionString}' assertion.`);
+    context.trace(`Added the '${assertionString}' assertion to the context.`);
 
     this.assertions.push(assertion);
   }
 
-  addSubstitution(substitution) {
+  addReference(reference) {
     const context = this, ///
-          substitutionNode = substitution.getNode(),
-          substitutionString = substitution.getString();
+          referenceA = reference, ///
+          referenceString = reference.getString();
 
-    extract(this.substitutions, (substitution) => {
-      const substitutionMatchesFrameNode = substitution.matchSubstitutionNode(substitutionNode);
+    extract(this.references, (reference) => {
+      const referenceB = reference, ///
+            referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
 
-      if (substitutionMatchesFrameNode) {
+      if (referenceAEqualToReferenceB) {
         return true;
       }
     });
 
-    context.trace(`Added the '${substitutionString}' substitution.`);
+    context.trace(`Added the '${referenceString}' reference to the context.`);
 
-    this.substitutions.push(substitution);
+    this.references.push(reference);
   }
 
-  addReference(reference) {
+  addSubstitution(substitution) {
     const context = this, ///
-      referenceString = reference.getString();
+          substitutionA = substitution, ///
+          substitutionString = substitution.getString();
 
-    this.reference = reference;
+    extract(this.substitutions, (substitution) => {
+      const substitutionB = substitution, ///
+            substituionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
 
-    context.trace(`Added the '${referenceString}' reference.`);
+      if (substituionAEqualToSubstitutionB) {
+        return true;
+      }
+    });
+
+    context.trace(`Added the '${substitutionString}' substitution to the context.`);
+
+    this.substitutions.push(substitution);
   }
 
   findTermByTermNode(termNode) {
@@ -171,6 +186,18 @@ export default class TemporaryContext {
     return frame;
   }
 
+  findStatementByStatementNode(statementNode) {
+    const statement = this.statements.find((statement) => {
+      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+
+      if (statementMatchesStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statement;
+  }
+
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
       const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
@@ -183,21 +210,21 @@ export default class TemporaryContext {
     return assertion;
   }
 
-  findStatementByStatementNode(statementNode) {
-    const statement = this.statements.find((statement) => {
-      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+  findReferenceByMetavariableNode(metavariableNode) {
+    const reference = this.references.find((reference) => {
+      const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
 
-      if (statementMatchesStatementNode) {
+      if (referenceMatcheMetavariableNode) {
         return true;
       }
     }) || null;
 
-    return statement;
+    return reference;
   }
 
-  findSubtitutionBySubtitutionNode(substitutionNode) {
+  findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionMatchesSubtitutionNode = substitution.matchSubtitutionNode(substitutionNode);
+      const substitutionMatchesSubtitutionNode = substitution.matchSubstitutionNode(substitutionNode);
 
       if (substitutionMatchesSubtitutionNode) {
         return true;
@@ -381,11 +408,12 @@ export default class TemporaryContext {
 
   error(message, node = null) { this.context.error(message, node); }
 
-  marge(context) {
+  merge(context) {
     const terms = context.getTerms(),
           frames = context.getFrames(),
           statements = context.getStatements(),
           assertions = context.getAssertions(),
+          references = context.getReferences(),
           substitutions = context.getSubstitutions();
 
     this.terms = [
@@ -408,21 +436,63 @@ export default class TemporaryContext {
       ...assertions
     ];
 
+    this.references = [
+      ...this.references,
+      ...references
+    ];
+
     this.substitutions = [
       ...this.substitutions,
       ...substitutions
     ];
 
     compress(this.terms, (termA, termB) => {
-      const termANode = termA.getNode(),
-            termBNode = termB.getNode(),
-            termANodeMatchesTermBNode = termANode.match(termBNode);
+      const termAEqualToTermB = termA.isEqualTo(termB);
+
+      if (!termAEqualToTermB) {
+        return true;
+      }
+    });
+
+    compress(this.frames, (frameA, frameB) => {
+      const frameAEqualToFrameB = frameA.isEqualTo(frameB);
+
+      if (!frameAEqualToFrameB) {
+        return true;
+      }
+    });
+
+    compress(this.statements, (statementA, statementB) => {
+      const statementAEqualToStatementB = statementA.isEqualTo(statementB);
 
-      if (termAMatchesTermB) {
+      if (!statementAEqualToStatementB) {
         return true;
       }
     });
 
+    compress(this.assertions, (assertionA, assertionB) => {
+      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+
+      if (!assertionAEqualToAssertionB) {
+        return true;
+      }
+    });
+
+    compress(this.references, (referenceA, referenceB) => {
+      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+
+      if (!referenceAEqualToReferenceB) {
+        return true;
+      }
+    });
+
+    compress(this.substitutions, (substitutionA, substitutionB) => {
+      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+
+      if (!substitutionAEqualToSubstitutionB) {
+        return true;
+      }
+    });
   }
 
   static fromNothing(context) {
@@ -431,9 +501,9 @@ export default class TemporaryContext {
           tokens = null,
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }
@@ -442,9 +512,9 @@ export default class TemporaryContext {
     const tokens = null,
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }
@@ -454,9 +524,9 @@ export default class TemporaryContext {
           frames = [],
           statements = [],
           assertions = [],
+          references = [],
           substitutions = [],
-          reference = null,
-          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, substitutions, reference);
+          temporaryContext = new TemporaryContext(context, tokens, terms, frames, statements, assertions, references, substitutions);
 
     return temporaryContext;
   }

package/src/mixins/statement/verify.js

@@ -26,7 +26,9 @@ function verifyAsMetavariableAndSubstitution(statement, assignments, stated, con
 
     if (metavariableVerifies) {
       const { TermSubstitution, FrameSubstitution } = ontology,
-            substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
+            frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+            termSubstitution = TermSubstitution.fromStatement(statement, context),
+            substitution = (termSubstitution || frameSubstitution);
 
       if (substitution !== null) {
         const substitutionVerifies = substitution.verify(context);

package/src/mixins/step/unify.js

@@ -54,7 +54,6 @@ function unifyWithReference(statement, reference, satisfiesAssertion, substituti
 
       const { StatementSubstitution } = ontology,
             metavariable = reference.getMetavariable(),
-            specificContext = context,  ///
             statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementSubstitution; ///
 

package/src/node/argument.js

@@ -21,7 +21,7 @@ export default class ArgumentNode extends NonTerminalNode {
 
   getSingularTermNode() {
     const ruleName = TERM_RULE_NAME,
-          singularTermNode = this.getSingularTNodeByRuleName(ruleName);
+          singularTermNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularTermNode;
   }

package/src/node/assumption.js

@@ -5,16 +5,16 @@ import DocumentNode from "../nonTerminalNode";
 import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class AssumptionpNode extends DocumentNode {
-  isSimple() {
-    let simple = false;
+  isSingular() {
+    let singular = false;
 
     const statementNode = this.getStatementNode();
 
     if (statementNode === null) {
-      simple = true;
+      singular = true;
     }
 
-    return simple;
+    return singular;
   }
 
   getStatementNode() {

package/src/node/frame.js

@@ -5,16 +5,16 @@ import NonTerminalNode from "../nonTerminalNode";
 import { ASSUMPTION_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class FrameNode extends NonTerminalNode {
-  isSimple() {
-    let simple = false;
+  isSingular() {
+    let singular = false;
 
     const singularAssumptionNode = this.getSingularAssumptionNode();
 
     if (singularAssumptionNode !== null) {
-      simple = singularAssumptionNode.isSimple();
+      singular = singularAssumptionNode.isSingular();
     }
 
-    return simple;
+    return singular;
   }
 
   getAssumptionNodes() {
@@ -24,6 +24,20 @@ export default class FrameNode extends NonTerminalNode {
     return declarationNodes;
   }
 
+  getMetavariableName() {
+    let metavariableName = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const singularMetavariableNode = this.getSingularMetavariableNode();
+
+      metavariableName = singularMetavariableNode.getMetavariableName();
+    }
+
+    return metavariableName;
+  }
+
   getMetavariableNodes() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNodes = this.getNodesByRuleName(ruleName);
@@ -33,7 +47,7 @@ export default class FrameNode extends NonTerminalNode {
 
   getSingularAssumptionNode() {
     const ruleName = ASSUMPTION_RULE_NAME,
-          singularAssumptionNode = this.getSingularTNodeByRuleName(ruleName);
+          singularAssumptionNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularAssumptionNode;
   }

package/src/node/judgement.js

@@ -5,6 +5,13 @@ import NonTerminalNode from "../nonTerminalNode";
 import { FRAME_RULE_NAME, ASSUMPTION_RULE_NAME } from "../ruleNames";
 
 export default class JudgementNode extends NonTerminalNode {
+  isSingular() {
+    const frameNode = this.getFrameNode(),
+          singular = frameNode.isSingular();
+
+    return singular;
+  }
+
   getFrameNode() {
     const ruleName = FRAME_RULE_NAME,
           frameNode = this.getNodeByRuleName(ruleName);

package/src/node/statement.js

@@ -19,16 +19,38 @@ import { TERM_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 export default class StatementNode extends NonTerminalNode {
-  isSimple() {
-    let simple = false;
+  getMetavariableName() {
+    let metavariableName = null;
 
-    const metavariableNode = this.getMetavariableNode();
+    const singular = this.isSingular();
 
-    if (metavariableNode !== null) {
-      simple = true;
+    if (singular) {
+      const singularMetavariableNode = this.getSingularMetavariableNode();
+
+      metavariableName = singularMetavariableNode.getMetavariableName();
+    }
+
+    return metavariableName;
+  }
+
+  getSubstitutionNode() {
+    const frameSubstitutionNode = this.getFrameSubstitutionNode(),
+          termSubstitutionNode = this.getTermSubstitutionNode(),
+          substitutionNode = (frameSubstitutionNode || termSubstitutionNode);
+
+    return substitutionNode;
+  }
+
+  isSingular() {
+    let singular = false;
+
+    const singularMetavariableNode = this.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      singular = true;
     }
 
-    return simple;
+    return singular;
   }
 
   getTermNodes() {
@@ -59,13 +81,6 @@ export default class StatementNode extends NonTerminalNode {
     return judgementNode;
   }
 
-  getMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNode = this.getNodeByRuleName(ruleName);
-
-    return metavariableNode;
-  }
-
   getTypeAssertionNode() {
     const ruleName = TYPE_ASSERTION_RULE_NAME,
           typeAssertionNode = this.getNodeByRuleName(ruleName);
@@ -134,6 +149,13 @@ export default class StatementNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
+  getSingularMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularMetavariableNode;
+  }
+
   getSingularMetaArgumentNode() {
     const ruleName = META_ARGUMENT_RULE_NAME,
           singularMetaArgumentNode = this.getNodeByRuleName(ruleName);

package/src/node/substitution/term.js

@@ -20,27 +20,17 @@ export default class TermSubstitutionNode extends SubstitutionNode {
   }
 
   getLastVariableNode() {
-    let lastVariableNode = null;
-
     const lastTermNode = this.getLastTermNode(),
-          singularVariableNode = lastTermNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      lastVariableNode = singularVariableNode;  ///
-    }
+          singularVariableNode = lastTermNode.getSingularVariableNode(),
+          lastVariableNode = singularVariableNode;  ///
 
     return lastVariableNode;
   }
 
   getFirstVariableNode() {
-    let firstVariableNode = null;
-
     const firstTermNode = this.getFirstTermNode(),
-          singularVariableNode = firstTermNode.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      firstVariableNode = singularVariableNode;  ///
-    }
+          singularVariableNode = firstTermNode.getSingularVariableNode(),
+          firstVariableNode = singularVariableNode;  ///
 
     return firstVariableNode;
   }

package/src/node/term.js

@@ -5,16 +5,30 @@ import NonTerminalNode from "../nonTerminalNode";
 import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
-  isSimple() {
-    let simple = false;
+  getVariableIdentifier() {
+    let variableIdentifier = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const singularVariableNode = this.getSingularVariableNode();
+
+      variableIdentifier = singularVariableNode.getVariableIdentifier();
+    }
+
+    return variableIdentifier;
+  }
+
+  isSingular() {
+    let singular = false;
 
     const singularVariableNode = this.getSingularVariableNode();
 
     if (singularVariableNode !== null) {
-      simple = true;
+      singular = true;
     }
 
-    return simple;
+    return singular;
   }
 
   getVariableNodes() {
@@ -38,14 +52,14 @@ export default class TermNode extends NonTerminalNode {
 
   getSingularArgumentNode() {
     const ruleName = ARGUMENT_RULE_NAME,
-          singularArgumentNode = this.getSingularTNodeByRuleName(ruleName);
+          singularArgumentNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularArgumentNode;
   }
 
   getSingularVariableNode() {
     const ruleName = VARIABLE_RULE_NAME,
-          singularVariableNode = this.getSingularTNodeByRuleName(ruleName);
+          singularVariableNode = this.getSingularNodeByRuleName(ruleName);
 
     return singularVariableNode;
   }

package/src/nonTerminalNode.js

@@ -87,7 +87,7 @@ export default class NonTerminalNode extends NonTerminalNodeBase {
     return firstNode;
   }
 
-  getSingularTNodeByRuleName(...ruleNames) {
+  getSingularNodeByRuleName(...ruleNames) {
     let singularNode = null;
 
     const nodes = this.filterChildNode((childNode) => {

package/src/ontology/assertion/contained.js

@@ -73,10 +73,10 @@ export default define(class ContainedAssertion extends Assertion {
 
       context.trace(`Verifying the '${termString}' term...`);
 
-      const termSimple = this.term.isSimple();
+      const termSingular = this.term.isSingular();
 
-      if (!termSimple) {
-        context.debug(`The '${termString}' term is not simple.`);
+      if (!termSingular) {
+        context.debug(`The '${termString}' term is not singular.`);
       } else {
         termVerifies = this.term.verify(context, () => {
           const verifiesAhead = true;
@@ -101,10 +101,10 @@ export default define(class ContainedAssertion extends Assertion {
 
       context.trace(`Verifying the '${frameString}' frame...`);
 
-      const frameSimple = this.frame.isSimple();
+      const frameSingular = this.frame.isSingular();
 
-      if (!frameSimple) {
-        context.debug(`The '${frameString}' frame is not simple.`);
+      if (!frameSingular) {
+        context.debug(`The '${frameString}' frame is not singular.`);
       } else {
         stated = true;  ///