occam-verify-cli 1.0.404 → 1.0.414

package/src/ontology/metavariable.js

@@ -7,8 +7,7 @@ import { define } from "../ontology";
 import { EMPTY_STRING } from "../constants";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
-import { metavariableFromFrame, metavariableFromStatement } from "../utilities/context";
-import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
+import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
 
 export default define(class Metavariable {
   constructor(string, node, tokens, name, type, metaType) {
@@ -81,8 +80,9 @@ export default define(class Metavariable {
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
   isEqualTo(metavariable) {
-    const metavariableString = metavariable.getString(),
-          equalTo = (metavariableString === this.string);
+    const metavariableNode = metavariable.getNode(),
+          matches = this.node.match(metavariableNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }
@@ -175,50 +175,6 @@ export default define(class Metavariable {
     return frameUnifies;
   }
 
-  unifyReference(reference, substitutions, generalContext, specificContext) {
-    let referenceUnifies = false;
-
-    const referenceString = reference.getString(),
-          metavariableString = this.string;
-
-    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
-
-    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
-
-    if (referenceMetavariableUnifies) {
-      referenceUnifies = true;
-    } else {
-      const context = specificContext,  ///
-            metavariable = this, ///
-            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
-
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
-              substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference, context);
-
-        if (substitutionReferenceEqualToReference) {
-          referenceUnifies = true;
-        }
-      } else {
-        const { ReferenceSubstitution } = ontology,
-              metavariable = this,
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution;  ///
-
-        substitutions.addSubstitution(substitution, context);
-
-        referenceUnifies = true;
-      }
-    }
-
-    if (referenceUnifies) {
-      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
-    }
-
-    return referenceUnifies;
-  }
-
   unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
@@ -267,6 +223,50 @@ export default define(class Metavariable {
     return statementUnifies;
   }
 
+  unifyReference(reference, substitutions, generalContext, specificContext) {
+    let referenceUnifies = false;
+
+    const referenceString = reference.getString(),
+          metavariableString = this.string; ///
+
+    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
+
+    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
+
+    if (referenceMetavariableUnifies) {
+      referenceUnifies = true;
+    } else {
+      const context = specificContext,  ///
+            metavariable = this, ///
+            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
+
+      if (simpleSubstitutionPresent) {
+        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
+              substitution = simpleSubstitution,  ///
+              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference, context);
+
+        if (substitutionReferenceEqualToReference) {
+          referenceUnifies = true;
+        }
+      } else {
+        const { ReferenceSubstitution } = ontology,
+              metavariable = this,
+              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
+              substitution = referenceSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, context);
+
+        referenceUnifies = true;
+      }
+    }
+
+    if (referenceUnifies) {
+      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
+    }
+
+    return referenceUnifies;
+  }
+
   unifyMetavariable(metavariable, context) {
     let metavariableUnifies;
 
@@ -291,33 +291,35 @@ export default define(class Metavariable {
   unifyFrameMetavariable(frame, substitutions, generalContext, specificContext) {
     let frameMetavariableUnifies = false;
 
-    const generalContextFilePath = generalContext.getFilePath(),
+    const context = specificContext,  ///
+          generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const frameString = frame.getString();
+      const metavariable = this,
+            metavariableString = this.string, ///
+            frameMetavariableEqualToMetvariable = frame.isMetavariableEqualToMetavariable(metavariable, context);
 
-      if (frameString === this.string) {
+      if (frameMetavariableEqualToMetvariable) {
         frameMetavariableUnifies = true;
       } else {
-        const context = specificContext,  ///
-              metavariable = metavariableFromFrame(frame, context);
+        const frameSingular = frame.isSingular();
 
-        if (metavariable !== null) {
-          const frameMetavariable = metavariable, ///
-                metavariableString = this.string, ///
+        if (frameSingular) {
+          const frameMetavariableName = frame.getMetavariableName(),
+                frameMetavariable = context.findMetavariableByMetavariableName(frameMetavariableName),
                 frameMetavariableString = frameMetavariable.getString();
 
-          specificContext.trace(`Unifying the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+          context.trace(`Unifying the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
 
-          const specificMetavariable = frameMetavariable, ///
-                generalMetavariable = this, ///
+          const generalMetavariable = this, ///
+                specificMetavariable = frameMetavariable, ///
                 metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
           frameMetavariableUnifies = metavariableUnifiesIntrinsically; ///
 
           if (frameMetavariableUnifies) {
-            specificContext.debug(`...unified the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+            context.debug(`...unified the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
           }
         }
       }
@@ -326,77 +328,79 @@ export default define(class Metavariable {
     return frameMetavariableUnifies;
   }
 
-  unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext) {
-    let referenceMetavariableUnifies = false;
+  unifyStatementMetavariable(statement, substitutions, generalContext, specificContext) {
+    let statementMetavariableUnifies = false;
 
-    const generalContextFilePath = generalContext.getFilePath(),
+    const context = specificContext,  ///
+          generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const referenceString = reference.getString();
+      const metavariable = this,  ///
+            metavariableString = this.string, ///
+            statementMetavariableEqualToMetvariable = statement.isMetavariableEqualToMetavariable(metavariable, context);
 
-      if (referenceString === this.string) {
-        referenceMetavariableUnifies = true;
+      if (statementMetavariableEqualToMetvariable) {
+        statementMetavariableUnifies = true;
       } else {
-        const metavariable = reference.getMetavariable();
+        const statementSingular = statement.isSingular();
 
-        const referenceMetavariable = metavariable, ///
-              metavariableString = this.string, ///
-              referenceMetavariableString = referenceMetavariable.getString();
+        if (statementSingular) {
+          const statementMetavariableName = statement.getMetavariableName(),
+                statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
+                statementMetavariableString = statementMetavariable.getString();
 
-        specificContext.trace(`Unifying the reference's ${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+          context.trace(`Unifying the statement's ${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
 
-        const specificMetavariable = referenceMetavariable, ///
-              generalMetavariable = this, ///
-              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+          const generalMetavariable = this, ///
+                specificMetavariable = statementMetavariable, ///
+                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
 
-        if (referenceMetavariableUnifies) {
-          specificContext.debug(`...unified the reference's '${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          if (statementMetavariableUnifies) {
+            context.debug(`...unified the statement's '${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          }
         }
       }
     }
 
-    return referenceMetavariableUnifies;
+    return statementMetavariableUnifies;
   }
 
-  unifyStatementMetavariable(statement, substitutions, generalContext, specificContext) {
-    let statementMetavariableUnifies = false;
+  unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext) {
+    let referenceMetavariableUnifies = false;
 
-    const generalContextFilePath = generalContext.getFilePath(),
+    const context = specificContext,  ///
+          generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const statementString = statement.getString();
+      const metavariable = this,  ///
+            metavariableString = this.string, ///
+            referenceMetavariableEqualToMetvariable = reference.isMetavariableEqualToMetavariable(metavariable);
 
-      if (statementString === this.string) {
-        statementMetavariableUnifies = true;
+      if (referenceMetavariableEqualToMetvariable) {
+        referenceMetavariableUnifies = true;
       } else {
-        const context = specificContext,  ///
-              metavariable = metavariableFromStatement(statement, context);
-
-        if (metavariable !== null) {
-          const statementMetavariable = metavariable, ///
-                metavariableString = this.string, ///
-                statementMetavariableString = statementMetavariable.getString();
+        const referenceMetavariable = reference.getMetavariable(),
+              referenceMetavariableString = referenceMetavariable.getString();
 
-          specificContext.trace(`Unifying the statement's ${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
+        context.trace(`Unifying the reference's ${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
 
-          const specificMetavariable = statementMetavariable, ///
-                generalMetavariable = this, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+        const generalMetavariable = this, ///
+              specificMetavariable = referenceMetavariable, ///
+              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
 
-          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
 
-          if (statementMetavariableUnifies) {
-            specificContext.debug(`...unified the statement's '${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
-          }
+        if (referenceMetavariableUnifies) {
+          context.debug(`...unified the reference's '${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
         }
       }
     }
 
-    return statementMetavariableUnifies;
+    return referenceMetavariableUnifies;
   }
 
   toJSON() {
@@ -465,9 +469,11 @@ export default define(class Metavariable {
   static fromStatementNode(statementNode, context) {
     let metavariable = null;
 
-    const metavariableNode = statementNode.getMetavariableNode();
+    const singularMetavariableNode = statementNode.getSingularMetavariableNode();
+
+    if (singularMetavariableNode !== null) {
+      const metavariableNode = singularMetavariableNode;  ///
 
-    if (metavariableNode !== null) {
       metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
 

package/src/ontology/propertyRelation.js

@@ -34,8 +34,9 @@ export default define(class PropertyRelation {
   }
 
   isEqualTo(propertyRelation) {
-    const propertyRelationString = propertyRelation.getString(),
-          equalTo = (propertyRelationString === this.string);
+    const propertyRelationNode = propertyRelation.getNode(),
+          matches = this.node.match(propertyRelationNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }

package/src/ontology/reference.js

@@ -4,7 +4,7 @@ import ontology from "../ontology";
 
 import { define } from "../ontology";
 import { referenceMetaType } from ".//metaType";
-import { unifyMetavariableIntrinsically } from "../utilities/unification";
+import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Reference {
@@ -18,6 +18,8 @@ export default define(class Reference {
 
   getName() { return this.metavariable.getName(); }
 
+  getName() { return this.metavariable.getName(); }
+
   getString() { return this.metavariable.getString(); }
 
   getMetavariableName() {
@@ -32,10 +34,30 @@ export default define(class Reference {
     return metavariableNode;
   }
 
+  isEqualTo(refernece) {
+    const metavariable = refernece.getMetavariable(),
+          metavariableEqualToMetvariable = this.metavariable.isEqualTo(metavariable),
+          equalTo = metavariableEqualToMetvariable; ///
+
+    return equalTo;
+  }
+
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = this.metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode, ///
+          matches = metavariableNodeA.match(metavariableNodeB),
+          metavariableNodeMatches = matches;  ///
+
+    return metavariableNodeMatches; ///
+  }
+
   verify(context) {
     let verifies = false;
 
@@ -57,6 +79,10 @@ export default define(class Reference {
     }
 
     if (verifies) {
+      const reference = this; ///
+
+      context.addReference(reference);
+
       context.debug(`...verified the '${referenceString}' reference.`);
     }
 
@@ -191,6 +217,18 @@ export default define(class Reference {
     return reference;
   }
 
+  static fromAssumptionNode(assumptionNode, context) {
+    let reference = null;
+
+    const metavariableNode = assumptionNode.getMetavariableNode();
+
+    if (metavariableNode !== null) {
+      reference = referenceFromMetavariableNode(metavariableNode, context);
+    }
+
+    return reference;
+  }
+
   static fromMetavariableNode(metavariableNode, context) {
     const reference = referenceFromMetavariableNode(metavariableNode, context);
 

package/src/ontology/signature.js

@@ -27,7 +27,7 @@ export default define(class Signature {
   verify(context) {
     let verifies;
 
-    const signatureString = this.string;
+    const signatureString = this.string;  ///
 
     context.trace(`Verifying the ${signatureString} signature...`);
 
@@ -84,7 +84,7 @@ export default define(class Signature {
   compareSubstitutions(substitutions, context) {
     let substitutionsCompares = false;
 
-    const signatureString = this.string,
+    const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Comparing the '${substitutionsString}' substitutions against the ${signatureString} signature...`);
@@ -113,7 +113,7 @@ export default define(class Signature {
   correlateSubstitutions(substitutions, context) {
     let substitutionsCorrelates = false;
 
-    const signatureString = this.string,
+    const signatureString = this.string,  ///
           substitutionsString = substitutions.asString();
 
     context.trace(`Correlating the '${substitutionsString}' substitutions against the ${signatureString} signature...`);

package/src/ontology/statement.js

@@ -6,7 +6,7 @@ import verifyMixins from "../mixins/statement/verify";
 import StatementPartialContext from "../context/partial/statement";
 
 import { define } from "../ontology";
-import { unifyStatement } from "../utilities/unification";
+import { unifyStatement } from "../process/unify";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
@@ -32,11 +32,24 @@ export default define(class Statement {
     return this.tokens;
   }
 
-  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(statement) {
-    const statementString = statement.getString(),
-          equalTo = (statementString === this.string);
+    const statementNode = statement.getNode(),
+          matches = this.node.match(statementNode),
+          equalTo = matches;  ///
 
     return equalTo;
   }
@@ -95,6 +108,27 @@ export default define(class Statement {
     return frameContained;
   }
 
+  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;
+  }
+
   matchStatementNode(statementNode) { return this.node.match(statementNode); }
 
   verify(assignments, stated, context) {

package/src/ontology/step.js

@@ -3,9 +3,9 @@
 import ontology from "../ontology";
 import unifyMixins from "../mixins/step/unify";
 import TemporaryContext from "../context/temporary";
-import equationalUnifier from "../unifier/equantional";
 
 import { define } from "../ontology";
+import { equateStatements } from "../process/equate";
 import { propertyAssertionFromStatement } from "../utilities/context";
 
 export default define(class Step {
@@ -158,13 +158,13 @@ export default define(class Step {
   equateWithStatement(statement, context) {
     let statementEquates;
 
-    const statementA = statement,  ///
-          statementB = this.statement,  ///
-          statementANode = statementA.getNode(),
-          statementBNode = statementB.getNode(),
-          statementsEquates = equationalUnifier.equateStatements(statementANode, statementBNode, context);
+    const leftStatement = statement,  ///
+          rightStatement = this.statement,  ///
+          leftStatementNode = leftStatement.getNode(),
+          rightStatementNode = rightStatement.getNode(),
+          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
 
-    statementEquates = statementsEquates;  ///
+    statementEquates = statementsEquate;  ///
 
     return statementEquates;
   }

package/src/ontology/substitution/frame.js

@@ -40,35 +40,31 @@ export default define(class FrameSubstitution extends Substitution {
 
     const frameSubstitutionString = this.string;  ///
 
-    context.trace(`Verifiying the '${frameSubstitutionString}' frame substitutin...`);
+    context.trace(`Verifiying the '${frameSubstitutionString}' frame substitution...`);
 
-    const frameSimple = this.frame.isSimple();
+    const frameSingular = this.frame.isSingular();
 
-    if (frameSimple) {
-      if (this.metavariable === null) {
-        context.debug(`The specific frame is not simple.`);
-      } else {
+    if (frameSingular) {
+      if (this.metavariable !== null) {
         const metavariablePresent = context.isMetavariablePresent(this.metavariable);
 
         if (metavariablePresent) {
-          const metavariable = this.frame.getMetavariable(),
-                metavariablePresent = context.isMetavariablePresent(metavariable);
+          const frameMetavariable = this.frame.getMetavariable(),
+                frameMetavariablePresent = context.isMetavariablePresent(frameMetavariable);
 
-          if (metavariablePresent) {
+          if (frameMetavariablePresent) {
             verifies = true;
           } else {
-            const metavariableString = metavariable.getString();
-
-            context.debug(`The '${metavariableString}' metavariable is not present.`);
+            context.debug(`The '${frameSubstitutionString}' frame substitution's general frame's metavariable is not present.`);
           }
         } else {
-          const metavariableString = this.metavariable.getString();
-
-          context.debug(`The '${metavariableString}' metavariable is not present.`);
+          context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame's metavariable is not present.`);
         }
+      } else {
+        context.debug(`The '${frameSubstitutionString}' frame substitution's general frame is not singular.`);
       }
     } else {
-      context.debug(`The general frame is not simple.`);
+      context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame is not singular.`);
     }
 
     if (verifies) {
@@ -76,7 +72,7 @@ export default define(class FrameSubstitution extends Substitution {
 
       context.addSubstitution(substititoin);
 
-      context.debug(`...verified the '${frameSubstitutionString}' frame substitutin.`);
+      context.debug(`...verified the '${frameSubstitutionString}' frame substitution.`);
     }
 
     return verifies;