occam-verify-cli 0.0.698 → 0.0.702

package/src/collection.js

@@ -1,5 +1,9 @@
 "use strict";
 
+import { nodeQuery } from "./utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
 export default class Collection {
   constructor(terms) {
     this.terms = terms;
@@ -17,9 +21,9 @@ export default class Collection {
     this.terms.push(term);
   }
 
-  getType() {
+  getType(context) {
     const type = this.terms.reduce((type, term) => {
-      const termType = term.getType();
+      const termType = termTypeFromTerm(term, context);
 
       if (type === null) {
         type = termType;  ///
@@ -37,14 +41,15 @@ export default class Collection {
     return type;
   }
 
-  matchType(type) {
+  matchType(type, context) {
     const typeA = type; ///
 
-    type = this.getType();
+    type = this.getType(context);
 
     const typeB = type; ///
 
-    const typeMatches = (typeA === typeB);  ///
+    const typeAEqualToTypeB = typeA.isEqualTo(typeB),
+          typeMatches = typeAEqualToTypeB;  ///
 
     return typeMatches;
   }
@@ -63,6 +68,21 @@ export default class Collection {
     return termMatches;
   }
 
+  matchTermNode(termNode) {
+    const termNodeA = termNode, ///
+          termNodeMatches = this.terms.some((term) => {
+            const termNode = term.getNode(),
+                  termNodeB = termNode, ///
+                  termNodeAMatchesTermB = termNodeA.match(termNodeB);
+
+            if (termNodeAMatchesTermB) {
+              return true;
+            }
+          });
+
+    return termNodeMatches;
+  }
+
   matchTerms(terms) {
     const termsMatch = terms.every((term) => {
       const termMatches = this.matchTerm(term);
@@ -75,6 +95,18 @@ export default class Collection {
     return termsMatch;
   }
 
+  matchTermNodes(termNodes) {
+    const termNodesMatch = termNodes.every((termNode) => {
+      const termNodeMatches = this.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        return true;
+      }
+    })
+
+    return termNodesMatch;
+  }
+
   static fromEquality(equality) {
     const leftTerm = equality.getLeftTerm(),
           rightTerm = equality.getRightTerm(),
@@ -99,3 +131,21 @@ export default class Collection {
     return collection;
   }
 }
+
+function termTypeFromTerm(term, context) {
+  let termType;
+
+  const termNode = term.getNode(),
+        variableNode = variableNodeQuery(termNode);
+
+  if (variableNode !== null) {
+    const variable = context.findVariableByVariableNode(variableNode),
+          variableType = variable.getType();
+
+    termType = variableType;  ///
+  } else {
+    termType = term.getType();
+  }
+
+  return termType;
+}

package/src/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import conclusionStatementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable/conclusion";
-import conclusionMetastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable/conclusion";
+import statementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable";
+import metastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable";
 
 import { nodeAsString } from "./utilities/string";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
@@ -20,7 +20,7 @@ export default class Conclusion {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = conclusionStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifyAhead = true;
 
             return verifyAhead;
@@ -30,12 +30,12 @@ export default class Conclusion {
     return statementNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetalocalContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
-          metalocalContextB = metastatementMetalocalContext,  ///
-          nonTerminalNodeVerified = conclusionMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
+          localMetaContextB = metastatementLocalMetaContext,  ///
+          nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/consequent.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import consequentTermForVariableNodesVerifier from "./verifier/nodes/termForVariable/consequent";
+import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
 
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
@@ -14,12 +14,12 @@ export default class Consequent {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, localContext) {
+  matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
-          localContextB = null, ///
-          nonTerminalNodeVerified = consequentTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          localContextB = statementLocalContext, ///
+          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/constructor.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import Type from "./type";
-
 import { nodeAsString } from "./utilities/string";
+import { typeFromJSONAndFileContext } from "./type";
 import { termNodeFromConstructorDeclarationTokens } from "./utilities/node";
 import { constructorDeclarationTokensFromTermString } from "./utilities/tokens";
 
@@ -62,11 +61,7 @@ export default class Constructor {
 
       json = typeJSON;  ///
 
-      type = Type.fromJSONAndFileContext(json, fileContext);
-
-      const typeName = type.getName();
-
-      type = fileContext.findTypeByTypeName(typeName); ///
+      type = typeFromJSONAndFileContext(json, fileContext);
     }
 
     const tokens = constructorDeclarationTokens,  ///

package/src/context/file.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import Type from "../type";
 import Rule from "../rule";
 import Axiom from "../axiom";
 import Lemma from "../lemma";
@@ -11,9 +10,10 @@ import Combinator from "../combinator";
 import Constructor from "../constructor";
 import Metavariable from "../metavariable";
 
+import { push } from "../utilities/array";
 import { objectType } from "../type";
-import { push, filter } from "../utilities/array";
 import { statementMetaType } from "../metaType";
+import { typeFromJSONAndFileContext } from "../type";
 import { nodeAsString, nodesAsString } from "../utilities/string";
 
 const metaTypes = [
@@ -58,13 +58,19 @@ export default class FileContext {
 
   getParser() { return this.releaseContext.getParser(); }
 
+  getTermType(term) {
+    const termType = term.getType();
+
+    return termType;
+  }
+
   getProofSteps() {
     const proofSteps = [];  ///
 
     return proofSteps;
   }
 
-  getCollections() {
+  getCollections(localContext) {
     const collections = []; ///
 
     return collections;
@@ -259,18 +265,15 @@ export default class FileContext {
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
-    types = [ ///
-      ...types,
-      objectType
-    ];
+    types.push(objectType);
 
     const type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+      const matches = type.matchTypeName(typeName);
 
-            if (matches) {
-              return true;
-            }
-          }) || null;
+      if (matches) {
+        return true;
+      }
+    }) || null;
 
     return type;
   }
@@ -632,7 +635,7 @@ export default class FileContext {
 
     typesJSON.forEach((typeJSON) => {
       const json = typeJSON,  ///
-            type = Type.fromJSONAndFileContext(json, fileContext);
+            type = typeFromJSONAndFileContext(json, fileContext);
 
       this.types.push(type);
     });

package/src/context/local.js

@@ -2,11 +2,10 @@
 
 import Variable from "../variable";
 import Collection from "../collection";
-import fileMixins from "../mixins/file";
-import loggingMixins from "../mixins/logging";
+import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
-import { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from "../utilities/collection";
+import { mergeCollections, findCollectionByTerm } from "../utilities/collection";
 
 class LocalContext {
   constructor(context, variables, proofSteps, collections) {
@@ -24,8 +23,8 @@ class LocalContext {
     let variables = this.context.getVariables();
 
     variables = [ ///
-      ...variables,
-      ...this.variables
+      ...this.variables,
+      ...variables
     ];
 
     return variables;
@@ -35,8 +34,8 @@ class LocalContext {
     let proofSteps = this.context.getProofSteps();
 
     proofSteps = [  ///
-      ...proofSteps,
-      ...this.proofSteps
+      ...this.proofSteps,
+      ...proofSteps
     ];
 
     return proofSteps;
@@ -45,10 +44,11 @@ class LocalContext {
   getCollections() {
     let collections = this.context.getCollections();
 
-    const collectionsA = collections, ///
-          collectionsB = this.collections;
+    const collectionsA = this.collections, ///
+          collectionsB = collections,
+          localContext = this;  ///
 
-    collections = mergeCollections(collectionsA, collectionsB); ///
+    collections = mergeCollections(collectionsA, collectionsB, localContext); ///
 
     return collections;
   }
@@ -67,6 +67,24 @@ class LocalContext {
 
   getMetavariables() { return this.context.getMetavariables(); }
 
+  getTermType(term) {
+    let termType;
+
+    const collections = this.getCollections(),
+          collection = findCollectionByTerm(collections, term);
+
+    if (collection !== null) {
+      const localContext = this,  ///
+            collectionType = collection.getType(localContext);
+
+      termType = collectionType;  ///
+    } else {
+      termType = term.getType();
+    }
+
+    return termType;
+  }
+
   addEquality(equality) {
     let equalityAdded;
 
@@ -89,23 +107,24 @@ class LocalContext {
 
         equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection === null)) {
-        const term = rightTerm, ///
-              collection = leftCollection;  ///
-
-        collection.addTerm(term);
+        leftCollection.addTerm(rightTerm);
 
         equalityAdded = true;
       } else if ((leftCollection === null) && (rightCollection !== null)) {
-        const term = leftTerm, ///
-              collection = rightCollection;  ///
-
-        collection.addTerm(term);
+        rightCollection.addTerm(leftTerm);
 
         equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection !== null)) {
+        if (leftCollection === rightCollection) {
+          const collection = leftCollection;  ///
 
-        debugger
+          collection.addTerm(leftTerm);
+          collection.addTerm(rightTerm);
 
+          equalityAdded = true;
+        } else {
+          debugger
+        }
       }
     }
 
@@ -163,27 +182,6 @@ class LocalContext {
     return statementMatches;
   }
 
-  findCollectionByType(type) {
-    const collections = this.getCollections(),
-          collection = findCollectionByType(collections, type);
-
-    return collection;
-  }
-
-  findCollectionByTerm(term) {
-    const collections = this.getCollections(),
-          collection = findCollectionByTerm(collections, term);
-
-    return collection;
-  }
-
-  findCollectionByTerms(terms) {
-    const collections = this.getCollections(),
-          collection = findCollectionByTerms(collections, terms);
-
-    return collection;
-  }
-
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
@@ -205,35 +203,6 @@ class LocalContext {
     return variablePresent;
   }
 
-  isEqualityEqual(equality) {
-    let equalityEqual;
-
-    const equalityReflexive = equality.isReflexive();
-
-    if (equalityReflexive) {
-      equalityEqual = true;
-    } else {
-      const leftTerm = equality.getLeftTerm(),
-            rightTerm = equality.getRightTerm(),
-            terms = [
-              leftTerm,
-              rightTerm
-            ],
-            termsEqual = this.areTermsEqual(terms);
-
-      equalityEqual = termsEqual; ///
-    }
-
-    return equalityEqual;
-  }
-
-  areTermsEqual(terms) {
-    const collection = this.findCollectionByTerms(terms),
-          termsEqual = (collection !== null);
-
-    return termsEqual;
-  }
-
   toJSON(tokens) {
     const variables = this.variables.map((variable) => {
             const variableJSON = variable.toJSON(tokens);
@@ -289,24 +258,8 @@ class LocalContext {
 
     return localContext;
   }
-
-  static fromLocalContextAndAssignments(localContext, assignments) {
-    const context = localContext,  ///
-          variables = assignments.map((assignment) => {
-            const variable = assignment.getVariable();
-
-            return variable;
-          }),
-          proofSteps = [],
-          collections = [];
-
-    localContext = new LocalContext(context, variables, proofSteps, collections);
-
-    return localContext;
-  }
 }
 
-Object.assign(LocalContext.prototype, fileMixins);
-Object.assign(LocalContext.prototype, loggingMixins);
+Object.assign(LocalContext.prototype, contextMixins);
 
 export default LocalContext;

package/src/context/localMeta.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import fileMixins from "../mixins/file";
-import loggingMixins from "../mixins/logging";
+import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
 
@@ -16,12 +15,18 @@ class LocalMetaContext {
     return this.context;
   }
 
+  getTermType(term) {
+    const termType = term.getType();
+
+    return termType;
+  }
+
   getMetavariables() {
     let metavariables = this.context.getMetavariables();
 
     metavariables = [ ///
+      ...this.metavariables,
       ...metavariables,
-      this.metavariables
     ]
 
     return metavariables;
@@ -31,8 +36,8 @@ class LocalMetaContext {
     let metaproofSteps = this.context.getMetaproofSteps();
 
     metaproofSteps = [  ///
-      ...metaproofSteps,
-      ...this.metaproofSteps
+      ...this.metaproofSteps,
+      ...metaproofSteps
     ];
 
     return metaproofSteps;
@@ -140,7 +145,6 @@ class LocalMetaContext {
   }
 }
 
-Object.assign(LocalMetaContext.prototype, fileMixins);
-Object.assign(LocalMetaContext.prototype, loggingMixins);
+Object.assign(LocalMetaContext.prototype, contextMixins);
 
 export default LocalMetaContext;

package/src/context/release.js

@@ -277,18 +277,15 @@ export default class ReleaseContext {
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
-    types = [ ///
-      ...types,
-      objectType
-    ];
+    types.push(objectType);
 
     const type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+      const matches = type.matchTypeName(typeName);
 
-            if (matches) {
-              return true;
-            }
-          }) || null;
+      if (matches) {
+        return true;
+      }
+    }) || null;
 
     return type;
   }

package/src/equality.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import equalityNodesVerifier from "./verifier/nodes/equality";
+
 export default class Equality {
   constructor(node, leftTerm, rightTerm) {
     this.node = node;
@@ -21,19 +23,38 @@ export default class Equality {
 
   isReflexive() {
     const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
-          reflexive = leftTermMatchesRightTerm;
+          reflexive = leftTermMatchesRightTerm; ///
 
     return reflexive;
   }
 
-  static fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm) {
+  isEqual(context) {
+    const leftTerm = this.getLeftTerm(),
+          rightTerm = this.getRightTerm(),
+          leftTermNode = leftTerm.getNode(),
+          rightTermNode = rightTerm.getNode(),
+          nonTerminalNodeA = leftTermNode,  ///
+          nonTerminalNodeB = rightTermNode, ///
+          collections = context.getCollections(),
+          localContext = this,  ///
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
+          equal = nonTerminalNodeVerified;  ///
+
+    return equal;
+  }
+
+  static fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode) {
     let equality = null;
 
     const leftTermType = leftTerm.getType(),
           rightTermType = rightTerm.getType(),
-          leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOfOrSuperTypeOf(rightTermType);
+          leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
-    if (leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType) {
+    if (leftTermTypeComparableToRightTermType) {
       const node = equalityNode;  ///
 
       equality = new Equality(node, leftTerm, rightTerm);

package/src/metaType.js

@@ -57,16 +57,6 @@ export default class MetaType {
 
     return metaType;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    let metaType;
-
-    const { name } = json;
-
-    metaType = new MetaType(name);
-
-    return metaType;
-  }
 }
 
 class StatementMetaType extends MetaType {
@@ -79,3 +69,13 @@ class StatementMetaType extends MetaType {
 }
 
 export const statementMetaType = StatementMetaType.fromNothing();
+
+export function metaTypeFromJSONAndFileContext(json, fileContext) {
+  let metaType;
+
+  const { name } = json;
+
+  metaType = new MetaType(name);
+
+  return metaType;
+}

package/src/metavariable.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import MetaType from "./metaType";
-
 import { nodeAsString } from "./utilities/string";
+import { metaTypeFromJSONAndFileContext } from "./metaType";
 
 export default class Metavariable {
   constructor(node, metaType) {
@@ -54,11 +53,7 @@ export default class Metavariable {
 
     json = metaType;  ///
 
-    metaType = MetaType.fromJSONAndFileContext(json, fileContext);
-
-    const metaTypeName = metaType.getName();
-
-    metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName); ///
+    metaType = metaTypeFromJSONAndFileContext(json, fileContext);
 
     const metavariable = new Metavariable(node, metaType);
 

package/src/mixins/{file.js → context.js}

@@ -1,5 +1,17 @@
 "use strict";
 
+function trace(node, message) { this.context.trace(node, message); }
+
+function debug(node, message) { this.context.debug(node, message); }
+
+function info(node, message) { this.context.info(node, message); }
+
+function warning(node, message) { this.context.warning(node, message); }
+
+function error(node, message) { this.context.error(node, message); }
+
+function fatal(node, message) { this.context.fatal(node, message); }
+
 function getAxioms() { return this.context.getAxioms(); }
 
 function getLemmas() { return this.context.getLemmas(); }
@@ -34,7 +46,13 @@ function nodeAsString(node) { return this.context.nodeAsString(node); }
 
 function nodesAsString(node) { return this.context.nodesAsString(node); }
 
-const fileMixins = {
+const contextMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal,
   getAxioms,
   getLemmas,
   getTheorems,
@@ -54,4 +72,4 @@ const fileMixins = {
   nodesAsString
 };
 
-export default fileMixins;
+export default contextMixins;