occam-verify-cli 0.0.697 → 0.0.698

package/src/context/file.js

@@ -331,13 +331,13 @@ export default class FileContext {
     return theorem;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
+            const nodeMatches = variable.matchNode(node);
 
-            if (matches) {
+            if (nodeMatches) {
               return true;
             }
           }) || null;
@@ -372,11 +372,11 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchName(name);
+            const matches = metavariable.matchNode(node);
 
             if (matches) {
               return true;
@@ -400,15 +400,15 @@ export default class FileContext {
     return typePresent;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
+  isVariablePresentByVariableNode(variableNode) {
+    const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -453,18 +453,24 @@ export default class FileContext {
   }
 
   addVariable(variable) {
-    const variableName = variable.getName();
+    let variableAdded = false;
 
-    filter(this.variables, (variable) => {
-      const name = variable.getName(),
-            nameVariableName = (name === variableName);
+    const node = variable.getNode(),
+          variablePresent = this.variables.some((variable) => {
+            const nodeMatches = variable.matchNode(node);
 
-      if (!nameVariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!variablePresent) {
+      this.variables.push(variable);
+
+      variableAdded = true;
+    }
 
-    this.variables.push(variable);
+    return variableAdded;
   }
 
   addConjecture(conjecture) {
@@ -480,18 +486,24 @@ export default class FileContext {
   }
 
   addMetavariable(metavariable) {
-    const metavariableName = metavariable.getName();
+    let metavariableAdded = false;
 
-    filter(this.metavariables, (metavariable) => {
-      const name = metavariable.getName(),
-            nameMetavariableName = (name === metavariableName);
+    const node = metavariable.getNode(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const nodeMatches = metavariable.matchNode(node);
 
-      if (!nameMetavariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
 
-    this.metavariables.push(metavariable);
+    return metavariableAdded;
   }
 
   trace(message, node) { this.releaseContext.trace(message, node, this.tokens, this.filePath); }

package/src/context/local.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import Variable from "../variable";
-import Equality from "../equality";
 import Collection from "../collection";
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
 
-import { last, filter } from "../utilities/array";
+import { last } from "../utilities/array";
 import { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from "../utilities/collection";
 
 class LocalContext {
@@ -69,15 +68,17 @@ class LocalContext {
   getMetavariables() { return this.context.getMetavariables(); }
 
   addEquality(equality) {
+    let equalityAdded;
+
     const equalityReflexive = equality.isReflexive();
 
     if (equalityReflexive) {
-      ///
+      equalityAdded = true; ///
     } else {
       const leftTerm = equality.getLeftTerm(),
             rightTerm = equality.getRightTerm(),
-            leftCollection = this.findCollectionByTerm(leftTerm),
-            rightCollection = this.findCollectionByTerm(rightTerm);
+            leftCollection = findCollectionByTerm(this.collections, leftTerm),
+            rightCollection = findCollectionByTerm(this.collections, rightTerm);
 
       if (false) {
         ///
@@ -85,37 +86,51 @@ class LocalContext {
         const collection = Collection.fromEquality(equality);
 
         this.addCollection(collection);
+
+        equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection === null)) {
         const term = rightTerm, ///
               collection = leftCollection;  ///
 
         collection.addTerm(term);
+
+        equalityAdded = true;
       } else if ((leftCollection === null) && (rightCollection !== null)) {
         const term = leftTerm, ///
               collection = rightCollection;  ///
 
         collection.addTerm(term);
+
+        equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection !== null)) {
 
         debugger
 
       }
     }
+
+    return equalityAdded;
   }
 
   addVariable(variable) {
-    const variableName = variable.getName();
+    let variableAdded = false;
 
-    filter(this.variables, (variable) => {
-      const name = variable.getName(),
-            nameVariableName = (name === variableName);
+    const node = variable.getNode(),
+          variablePresent = this.variables.some((variable) => {
+            const nodeMatches = variable.matchNode(node);
 
-      if (!nameVariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!variablePresent) {
+      this.variables.push(variable);
+
+      variableAdded = true;
+    }
 
-    this.variables.push(variable);
+    return variableAdded;
   }
 
   addProofStep(proofStep) {
@@ -169,11 +184,11 @@ class LocalContext {
     return collection;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
+            const matches = variable.matchNode(node);
 
             if (matches) {
               return true;
@@ -183,8 +198,8 @@ class LocalContext {
     return variable;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
+  isVariablePresentByVariableNode(variableNode) {
+    const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
 
     return variablePresent;

package/src/context/localMeta.js

@@ -3,7 +3,7 @@
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
 
-import { last, filter } from "../utilities/array";
+import { last } from "../utilities/array";
 
 class LocalMetaContext {
   constructor(context, metavariables, metaproofSteps) {
@@ -53,18 +53,24 @@ class LocalMetaContext {
   }
 
   addMetavariable(metavariable) {
-    const metavariableName = metavariable.getName();
+    let metavariableAdded = false;
 
-    filter(this.metavariables, (metavariable) => {
-      const name = metavariable.getName(),
-            nameMetavariableName = (name === metavariableName);
+    const node = metavariable.getName(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const nodeMatches = metavariable.matchNode(node);
 
-      if (!nameMetavariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
 
-    this.metavariables.push(metavariable);
+    return metavariableAdded;
   }
 
   addMetaproofStep(metaproofStep) {
@@ -93,11 +99,11 @@ class LocalMetaContext {
     return metastatementMatches;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchName(name);
+            const matches = metavariable.matchNode(node);
 
             if (matches) {
               return true;
@@ -107,8 +113,8 @@ class LocalMetaContext {
     return metavariable;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;

package/src/equality.js

@@ -1,11 +1,16 @@
 "use strict";
 
 export default class Equality {
-  constructor(leftTerm, rightTerm) {
+  constructor(node, leftTerm, rightTerm) {
+    this.node = node;
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getLeftTerm() {
     return this.leftTerm;
   }
@@ -21,7 +26,7 @@ export default class Equality {
     return reflexive;
   }
 
-  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
+  static fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm) {
     let equality = null;
 
     const leftTermType = leftTerm.getType(),
@@ -29,7 +34,9 @@ export default class Equality {
           leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOfOrSuperTypeOf(rightTermType);
 
     if (leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType) {
-      equality = new Equality(leftTerm, rightTerm);
+      const node = equalityNode;  ///
+
+      equality = new Equality(node, leftTerm, rightTerm);
     }
 
     return equality;

package/src/metavariable.js

@@ -2,32 +2,35 @@
 
 import MetaType from "./metaType";
 
+import { nodeAsString } from "./utilities/string";
+
 export default class Metavariable {
-  constructor(name, metaType) {
-    this.name = name;
+  constructor(node, metaType) {
+    this.node = node;
     this.metaType = metaType;
   }
 
-  getName() {
-    return this.name;
+  getNode() {
+    return this.node;
   }
 
   getMetaType() {
     return this.metaType;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchNode(node) {
+    const nodeMatches = this.node.match(node);
 
-    return nameMatches;
+    return nodeMatches;
   }
 
   toJSON(tokens) {
     const metaTypeJSON = this.metaType.toJSON(tokens),
-          name = this.name, ///
           metaType = metaTypeJSON,  ///
+          string = nodeAsString(this.node, tokens),
+          node = string,  ///
           json = {
-            name,
+            node,
             metaType
           };
 
@@ -35,20 +38,17 @@ export default class Metavariable {
   }
 
   asString(tokens) {
-    const metaTypeName = this.metaType.getName(),
-          string = `${this.name}:${metaTypeName}`;
+    const metaTypeName = this.metaType.getName();
 
-    return string;
-  }
+    let string = nodeAsString(this.node, tokens);
 
-  static fromNameAndMetaType(name, metaType) {
-    const metavariable = new Metavariable(name, metaType);
+    string = `${string}:${metaTypeName}`;
 
-    return metavariable;
+    return string;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { name } = json;
+    const { node } = json;
 
     let { metaType } = json;
 
@@ -60,7 +60,14 @@ export default class Metavariable {
 
     metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName); ///
 
-    const metavariable = new Metavariable(name, metaType);
+    const metavariable = new Metavariable(node, metaType);
+
+    return metavariable;
+  }
+
+  static fromMetavariableNodeAndMetaType(metavariableNode, metaType) {
+    const node = metavariableNode,  ///
+          metavariable = new Metavariable(node, metaType);
 
     return metavariable;
   }

package/src/substitution/metastatementForMetavariable.js

@@ -3,19 +3,25 @@
 import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
 
 export default class MetastatementForMetavariableSubstitution {
-  constructor(metavariableName, metastatementNode) {
-    this.metavariableName = metavariableName;
+  constructor(metavariableNode, metastatementNode) {
+    this.metavariableNode = metavariableNode;
     this.metastatementNode = metastatementNode;
   }
 
-  getMetavariableName() {
-    return this.metavariableName;
+  getMetavariableNode() {
+    return this.metavariableNode;
   }
 
   getMetastatementNode() {
     return this.metastatementNode;
   }
 
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
   matchMetastatementNode(metastatementNode) {
     let metastatementNodeMatches;
 
@@ -34,15 +40,15 @@ export default class MetastatementForMetavariableSubstitution {
     return metastatementNodeMatches;
   }
 
-  static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
-    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
+  static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
+    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
 
     const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
     if (bracketedMetastatementChildNode !== null) {
       const metastatementNode = bracketedMetastatementChildNode; ///
 
-      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
+      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
     }
 
     return metastatementForMetavariableSubstitution;

package/src/substitution/statementForMetavariable.js

@@ -3,13 +3,13 @@
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution {
-  constructor(metavariableName, statementNode) {
-    this.metavariableName = metavariableName;
+  constructor(metavariableNode, statementNode) {
+    this.metavariableNode = metavariableNode;
     this.statementNode = statementNode;
   }
 
-  getMetavariableName() {
-    return this.metavariableName;
+  getMetavariableNode() {
+    return this.metavariableNode;
   }
 
   getStatementNode() {
@@ -34,15 +34,21 @@ export default class StatementForMetavariableSubstitution {
     return statementNodeMatches;
   }
 
-  static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
-    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
 
     const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
     if (bracketedStatementChildNode !== null) {
       const statementNode = bracketedStatementChildNode; ///
 
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
     }
 
     return statementForMetavariableSubstitution;

package/src/substitution/termForVariable.js

@@ -1,13 +1,13 @@
 "use strict";
 
 export default class TermForVariableSubstitution {
-  constructor(variableName, termNode) {
-    this.variableName = variableName;
+  constructor(variableNode, termNode) {
+    this.variableNode = variableNode;
     this.termNode = termNode;
   }
 
-  getVariableName() {
-    return this.variableName;
+  getVariableNode() {
+    return this.variableNode;
   }
 
   getTermNode() {
@@ -15,15 +15,19 @@ export default class TermForVariableSubstitution {
   }
 
   matchTermNode(termNode) {
-    let termNodeMatches;
-
-    termNodeMatches = this.termNode.match(termNode);
+    const termNodeMatches = this.termNode.match(termNode);
 
     return termNodeMatches;
   }
 
-  static fromVariableNameAndTermNode(variableName, termNode) {
-    const termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
+  matchVariableNode(variableNode) {
+    const variableNodeMatches = this.variableNode.match(variableNode);
+
+    return variableNodeMatches;
+  }
+
+  static fromVariableNodeAndTermNode(variableNode, termNode) {
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
 
     return termForVariableSubstitution;
   }

package/src/utilities/query.js

@@ -5,9 +5,7 @@ import { Query } from "occam-dom";
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
       labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
-      variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
-      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
-      metavariableNameTerminalNodeQuery = nodeQuery("/metavariable/@name");
+      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
 
 export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
@@ -71,14 +69,6 @@ export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
   return metaTypeName;
 }
 
-export function variableNameFromVariableNode(variableNode) {
-  const variableNameTerminalNode = variableNameTerminalNodeQuery(variableNode),
-        variableNameTerminalNodeContent = variableNameTerminalNode.getContent(),
-        variableName = variableNameTerminalNodeContent; ///
-
-  return variableName;
-}
-
 export function referenceNameFromReferenceNode(referenceNode) {
   const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
         referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
@@ -86,11 +76,3 @@ export function referenceNameFromReferenceNode(referenceNode) {
 
   return referenceName;
 }
-
-export function metavariableNameFromMetavariableNode(metavariableNode) {
-  const metavariableNameTerminalNode = metavariableNameTerminalNodeQuery(metavariableNode),
-        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
-        metavariableName = metavariableNameTerminalNodeContent; ///
-
-  return metavariableName;
-}