occam-verify-cli 1.0.405 → 1.0.415

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;  ///
 

package/src/ontology/assertion/defined.js

@@ -67,10 +67,10 @@ export default define(class DefinedAssertion 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;
@@ -95,10 +95,10 @@ export default define(class DefinedAssertion 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;  ///
 
@@ -153,7 +153,7 @@ export default define(class DefinedAssertion extends Assertion {
   unifyIndependently(substitutions, generalContext, specificContext) {
     let unifiesIndependently;
 
-    const context = generalContext, ///
+    const context = specificContext, ///
           definedAssertionString = this.getString(); ///
 
     context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);

package/src/ontology/assertion/subproof.js

@@ -6,7 +6,7 @@ import ontology from "../../ontology";
 import Assertion from "../assertion";
 
 import { define } from "../../ontology";
-import { unifyStatement } from "../../utilities/unification";
+import { unifyStatement } from "../../process/unify";
 
 const { match } = arrayUtilities;
 

package/src/ontology/assumption.js

@@ -3,15 +3,15 @@
 import ontology from "../ontology";
 
 import { define } from "../ontology";
-import { unifyStatementIntrinsically } from "../utilities/unification";
-import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { unifyStatementIntrinsically } from "../process/unify";
+import { referenceFromJSON, referenceToReferenceJSON } from "../utilities/json";
 
 export default define(class Assumption {
-  constructor(string, node, statement, metavariable) {
+  constructor(string, node, statement, reference) {
     this.string = string;
     this.node = node;
     this.statement = statement;
-    this.metavariable = metavariable;
+    this.reference = reference;
   }
 
   getString() {
@@ -26,10 +26,12 @@ export default define(class Assumption {
     return this.statement;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReference() {
+    return this.reference;
   }
 
+  getMetavariable() { return this.reference.getMetavariable(); }
+
   isSimple() {
     const simple = (this.statement === null);
 
@@ -47,7 +49,8 @@ export default define(class Assumption {
     const simple = this.isSimple();
 
     if (simple) {
-      const judgement = context.findJudgementByMetavariable(this.metavariable);
+      const metavariable = this.reference.getMetavariable(),
+            judgement = context.findJudgementByMetavariable(metavariable);
 
       if (judgement !== null) {
         const assumption = judgement.getDeclaration();
@@ -58,9 +61,9 @@ export default define(class Assumption {
       const statement = substitution.getStatement(),
             metavariable = substitution.getMetavariable(),
             statementEqualToStatement = this.statement.isEqualTo(statement),
-            metavariableEqualToMetavariable = this.metavariable.isEqualTo(metavariable);
+            referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualToMetavariable(metavariable);
 
-      if (metavariableEqualToMetavariable && statementEqualToStatement) {
+      if (statementEqualToStatement && referenceMetavariableEqualToMetavariable) {
         substitutionMatches = true;
       }
     }
@@ -82,13 +85,13 @@ export default define(class Assumption {
     const simple = this.isSimple();
 
     if (simple) {
-      const verifiesAsMetavariable = this.verifyAsMetavariable(assignments, stated, context);
+      const referenceVerifiesAsMetavariable = this.verifyReferenceAsMetavariable(assignments, stated, context);
 
-      verifies = verifiesAsMetavariable; ///
+      verifies = referenceVerifiesAsMetavariable; ///
     } else {
-      const metavariableVerifiesAsReference = this.verifyMetavariableAsReference(assignments, stated, context);
+      const referenceVerified = this.verifyReference(assignments, stated, context);
 
-      if (metavariableVerifiesAsReference) {
+      if (referenceVerified) {
         const statementVerifies = this.verifyStatement(assignments, stated, context);
 
         if (statementVerifies) {
@@ -115,24 +118,21 @@ export default define(class Assumption {
     return verifies;
   }
 
-  verifyMetavariableAsReference(assignments, stated, context) {
-    let metavariableVerifiesAsReference;
-
-    const assumptionString = this.string,
-          metavariableString = this.metavariable.getString();
+  verifyReference(assignments, stated, context) {
+    let referenceVerified;
 
-    context.trace(`Verifying the '${assumptionString}' assumption's '${metavariableString}' metavariable as a reference...`);
+    const referenceString = this.reference.getString(),
+          assumptionString = this.string; ///
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          referenceVerifies = reference.verify(context);
+    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference...`);
 
-    metavariableVerifiesAsReference = referenceVerifies;  ///
+    referenceVerified = this.reference.verify(context);
 
-    if (metavariableVerifiesAsReference) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${metavariableString}' metavariable as a reference.`);
+    if (referenceVerified) {
+      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference.`);
     }
 
-    return metavariableVerifiesAsReference;
+    return referenceVerified;
   }
 
   verifyStatement(assignments, stated, context) {
@@ -159,21 +159,27 @@ export default define(class Assumption {
     return statementVerifies;
   }
 
-  verifyAsMetavariable(assignments, stated, context) {
-    let verifiesAsMetavariable;
+  verifyReferenceAsMetavariable(assignments, stated, context) {
+    let referenceVerifiesAsMetavariable = false;
 
-    const assumptionString = this.string,  ///
-          metavariableString = this.metavariable.getString();
+    const referenceString = this.reference.getString(),
+          assumptionString = this.string; ///
 
-    context.trace(`Verifying the '${assumptionString}' assumption's '${metavariableString}' metavariable...`);
+    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
 
-    verifiesAsMetavariable = this.metavariable.verify(context);
+    const metavariable = this.reference.getMetavariable(),
+          metavariableName = metavariable.getName(),
+          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
 
-    if (verifiesAsMetavariable) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${metavariableString}' metavariable.`);
+    if (metavariablePresent) {
+      referenceVerifiesAsMetavariable = true;
     }
 
-    return verifiesAsMetavariable;
+    if (referenceVerifiesAsMetavariable) {
+      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
+    }
+
+    return referenceVerifiesAsMetavariable;
   }
 
   verifyWhenStated(assignments, context) {
@@ -183,13 +189,12 @@ export default define(class Assumption {
 
     context.trace(`Verifying the '${assumptionString}' stated assumption...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          metavariablePresent = context.isMetavariablePresentByReference(reference);
+    const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
 
     if (metavariablePresent) {
       verifiesWhenStated = true;
     } else {
-      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(reference),
+      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
             metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
               const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
 
@@ -215,8 +220,7 @@ export default define(class Assumption {
 
     context.trace(`Verifying the '${assumptionString}' derived assumption...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(reference);
+    const metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(this.reference);
 
     verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
 
@@ -264,8 +268,7 @@ export default define(class Assumption {
 
     context.trace(`Unifying the '${labelString}' label with the '${assumptionString}' assumption...`);
 
-    const reference = referenceFromMetavariable(this.metavariable, context),
-          labelUnifies = reference.unifyLabel(label, substitutions, context);
+    const labelUnifies = this.reference.unifyLabel(label, substitutions, context);
 
     labelUnifiesWithReference = labelUnifies; ///
 
@@ -325,10 +328,10 @@ export default define(class Assumption {
     const simple = this.isSimple();
 
     if (simple) {
-      const metavariable = this.getMetavariable(),
-            metavariableJSON = metavariableToMetavariableJSON(metavariable);
+      const reference = this, ///
+            referenceJSON = referenceToReferenceJSON(reference);
 
-      json = metavariableJSON;  ///
+      json = referenceJSON;  ///
     }
 
     return json;
@@ -343,9 +346,9 @@ export default define(class Assumption {
       const string = null,
             node = null,
             statement = null,
-            metavariable = metavariableFromJSON(json, context);
+            reference = referenceFromJSON(json, context);
 
-      assumption = new Assumption(string, node, statement, metavariable)
+      assumption = new Assumption(string, node, statement, reference)
     }
 
     return assumption;
@@ -365,21 +368,13 @@ export default define(class Assumption {
   }
 });
 
-function referenceFromMetavariable(metavariable, context) {
-  const { Reference } = ontology,
-        metavariableNode = metavariable.getNode(),
-        reference = Reference.fromMetavariableNode(metavariableNode, context);
-
-  return reference;
-}
-
 function assumptionFromAssumptionNode(assumptionNode, context) {
-  const { Metavariable, Assumption, Statement } = ontology,
+  const { Reference, Assumption, Statement } = ontology,
         node = assumptionNode,  ///
         string = context.nodeAsString(node),
         statement = Statement.fromAssumptionNode(assumptionNode, context),
-        metavariable = Metavariable.fromAssumptionNode(assumptionNode, context),
-        assumption = new Assumption(string, node, statement, metavariable);
+        reference = Reference.fromAssumptionNode(assumptionNode, context),
+        assumption = new Assumption(string, node, statement, reference);
 
   return assumption;
 }

package/src/ontology/combinator.js

@@ -3,7 +3,7 @@
 import ontology from "../ontology";
 
 import { define } from "../ontology";
-import { unifyStatementWithCombinator } from "../utilities/unification";
+import { unifyStatementWithCombinator } from "../process/unify";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Combinator {

package/src/ontology/constructor.js

@@ -4,7 +4,7 @@ import ontology from "../ontology";
 
 import { define } from "../ontology";
 import { baseType } from ".//type";
-import { unifyTermWithConstructor } from "../utilities/unification";
+import { unifyTermWithConstructor } from "../process/unify";
 import { termFromJSON, termToTermJSON } from "../utilities/json";
 
 export default define(class Constructor {

package/src/ontology/declaration/combinator.js

@@ -4,8 +4,7 @@ import ontology from "../../ontology";
 import Declaration from "../declaration";
 
 import { define } from "../../ontology";
-
-import combinatorVerifier from "../../verifier/combinator";
+import { verifyStatement } from "../../process/verify";
 
 export default define(class CombinatorDeclaration extends Declaration {
   constructor(context, node, string, combinator) {
@@ -53,7 +52,7 @@ export default define(class CombinatorDeclaration extends Declaration {
     const statement = this.combinator.getStatement(),
           statementNode = statement.getNode();
 
-    statementVerifies = combinatorVerifier.verifyStatement(statementNode, context);
+    statementVerifies = verifyStatement(statementNode, context);
 
     if (statementVerifies) {
       context.debug(`...verified the '${combinatorString}' combinator.`, node);

package/src/ontology/declaration/constructor.js

@@ -2,9 +2,9 @@
 
 import ontology from "../../ontology";
 import Declaration from "../declaration";
-import constructorVerifier from "../../verifier/constructor";
 
 import { define } from "../../ontology";
+import { verifyTerm } from "../../process/verify";
 
 export default define(class ConstructorDeclaration extends Declaration {
   constructor(context, node, string, constructor) {
@@ -57,7 +57,7 @@ export default define(class ConstructorDeclaration extends Declaration {
     const term = this.constructor.getTerm(),
           termNode = term.getNode();
 
-    constructorVerifies = constructorVerifier.verifyTerm(termNode, context);
+    constructorVerifies = verifyTerm(termNode, context);
 
     if (constructorVerifies) {
       context.debug(`...verified the '${constructorString}' constructor.`, node);

package/src/ontology/equality.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import ontology from "../ontology";
-import equationalUnifier from "../unifier/equantional";
 import EqualityAssignment from "../assignment/equality";
 import VariableAssignment from "../assignment/variable";
 
 import { define } from "../ontology";
+import { equateTerms } from "../process/equate";
 
 export default define(class Equality {
   constructor(string, leftTerm, rightTerm) {
@@ -67,9 +67,9 @@ export default define(class Equality {
 
     const leftTermNode = this.leftTerm.getNode(),
           rightTermNode = this.rightTerm.getNode(),
-          termsEquates = equationalUnifier.equateTerms(leftTermNode, rightTermNode, context);
+          termsEquate = equateTerms(leftTermNode, rightTermNode, context);
 
-    if (termsEquates) {
+    if (termsEquate) {
       equal = true;
     }
 

package/src/ontology/equivalence.js

@@ -143,7 +143,7 @@ export default define(class Equivalence {
     compress(terms, (termA, termB) => {
       const termAEqualToTermB = termA.isEqualTo(termB);
 
-      if (termAEqualToTermB) {
+      if (!termAEqualToTermB) {
         return true;
       }
     });

package/src/ontology/frame.js

@@ -53,9 +53,9 @@ export default define(class Frame {
   getMetavariable() {
     let metavariable = null;
 
-    const simple = this.isSimple();
+    const singular = this.isSingular();
 
-    if (simple) {
+    if (singular) {
       const assumption = this.getAssumption();
 
       metavariable = assumption.getMetavariable();
@@ -64,15 +64,49 @@ export default define(class Frame {
     return metavariable;
   }
 
-  isSimple() { return this.node.isSimple();}
+  getMetavariableName() {
+    let metavariableName = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariableName = this.node.getMetavariableName();
+    }
+
+    return metavariableName;
+  }
+
+  isSingular() { return this.node.isSingular(); }
 
   isEqualTo(frame) {
-    const frameString = frame.getString(),
-          equalTo = (frameString === this.string);
+    const frameNode = frame.getNode(),
+          matches = this.node.match(frameNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }
 
+  isMetavariableEqualToMetavariable(metavariable, context) {
+    let metavariableEqualToMetavariable;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableA = metavariable, ///
+            singularMetavariableNode = this.node.getSingularMetavariableNode(),
+            metavariableName = singularMetavariableNode.getMetavariableName();
+
+      metavariable = context.findMetavariableByMetavariableName(metavariableName)
+
+      const metavariableB = metavariable,
+            equalTo = metavariableA.isEqualTo(metavariableB);
+
+      metavariableEqualToMetavariable = equalTo;  ///
+    }
+
+    return metavariableEqualToMetavariable;
+  }
+
   matchFrameNode(frameNode) { return this.node.match(frameNode); }
 
   matchSubstitution(substitution, context) {
@@ -165,10 +199,10 @@ export default define(class Frame {
 
     context.trace(`Verifying the '${frameString}' stated frame...`);
 
-    const simple = this.isSimple();
+    const singular = this.isSingular();
 
-    if (!simple) {
-      context.trace(`The '${frameString}' stated frame must be simple.`);
+    if (!singular) {
+      context.trace(`The '${frameString}' stated frame must be singular.`);
     } else {
       verifiesWhenStated = true;
     }
@@ -253,9 +287,9 @@ export default define(class Frame {
   toJSON() {
     let json = null;
 
-    const simple = this.isSimple();
+    const singular = this.isSingular();
 
-    if (simple) {
+    if (singular) {
       const assumption = this.getAssumption(),
             assumptionJSON = assumption.toJSON();
 

package/src/ontology/judgement.js

@@ -6,8 +6,9 @@ import JudgementAssignment from "../assignment/judgement";
 import { define } from "../ontology";
 
 export default define(class Judgement {
-  constructor(string, frame, assumption) {
+  constructor(string, node, frame, assumption) {
     this.string = string;
+    this.node = node;
     this.frame = frame;
     this.assumption = assumption;
   }
@@ -16,6 +17,10 @@ export default define(class Judgement {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getFrame() {
     return this.frame;
   }
@@ -24,7 +29,7 @@ export default define(class Judgement {
     return this.assumption;
   }
 
-  isSimple() { return this.frame.isSimple(); }
+  isSingular() { return this.node.isSingular(); }
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
@@ -157,7 +162,7 @@ export default define(class Judgement {
             frame = Frame.fromJudgementNode(judgementNode, context),
             assumption = Assumption.fromJudgementNode(judgementNode, context);
 
-      judgement = new Judgement(string, frame, assumption);
+      judgement = new Judgement(string, node, frame, assumption);
     }
 
     return judgement;