occam-verify-cli 0.0.1089 → 0.0.1091

package/src/utilities/equivalences.js

@@ -79,7 +79,7 @@ export function findEquivalenceByTermNodes(equivalences, termNodes) {
   return equivalence;
 }
 
-export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, localContext) {
+export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
   let groundedEquivalences,
       remainingEquivalences,
       initiallyGroundedEquivalences,
@@ -89,7 +89,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
   initiallyGroundedEquivalences = [];
 
-  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext);
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
 
   const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
@@ -105,9 +105,9 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
       while (definedVariablesLength > previousDefinedVariablesLength) {
         previousDefinedVariablesLength = definedVariablesLength;  ///
 
-        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext);
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
 
-        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext);
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
 
         definedVariablesLength = definedVariables.length;
       }
@@ -118,7 +118,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
       implicitlyGroundedEquivalences = [];
 
-      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext);
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
 
       push(groundedEquivalences, implicitlyGroundedEquivalences);
 
@@ -137,12 +137,12 @@ function typesFromEquivalences(equivalences) {
   return types;
 }
 
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext) {
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
   const terms = groundedTerms,  ///
         variables = definedVariables; ///
 
   terms.forEach((term) => {
-    const termVariables = term.getVariables(localContext);
+    const termVariables = term.getVariables(context);
 
     termVariables.forEach((termVariable) => {
       const variablesIncludesTermVariable = variables.includes(termVariable);
@@ -156,9 +156,9 @@ function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, loca
   });
 }
 
-function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext) {
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
   separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(localContext);
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
 
     if (!equivalenceInitiallyGrounded) {
       return true;
@@ -166,9 +166,9 @@ function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalenc
   });
 }
 
-function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext) {
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
   separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
-    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, localContext);
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
 
     if (!equivalenceImplicitlyGrounded) {
       return true;
@@ -176,8 +176,8 @@ function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalen
   });
 }
 
-function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext) {
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
   groundedEquivalences.forEach((groundedEquivalence) => {
-    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, localContext);
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
   });
 }

package/src/utilities/json.js

@@ -124,9 +124,10 @@ export function unqualifiedStatementFromJSON(json, fileContext) {
 export function typesFromJSON(json, types, fileContext) {
   const { types: typesJSON } = json;
 
+  const { Type } = shim;
+
   typesJSON.forEach((typeJSON) => {
-    const { Type } = shim,
-          json = typeJSON,  ///
+    const json = typeJSON,  ///
           type = Type.fromJSON(json, fileContext);
 
     types.push(type);
@@ -136,14 +137,15 @@ export function typesFromJSON(json, types, fileContext) {
 export function rulesFromJSON(json, fileContext) {
   let { rules } = json;
 
-  const rulesJSON = rules; ///
-        rules = rulesJSON.map((ruleJSON) => {
-          const { Rule } = shim,
-                json = ruleJSON,  ///
-                rule = Rule.fromJSON(json, fileContext);
+  const { Rule } = shim,
+        rulesJSON = rules; ///
+
+  rules = rulesJSON.map((ruleJSON) => {
+    const json = ruleJSON,  ///
+          rule = Rule.fromJSON(json, fileContext);
 
-          return (rule);
-        });
+    return (rule);
+  });
 
   return rules;
 }
@@ -167,14 +169,15 @@ export function labelsFromJSON(json, fileContext) {
 export function axiomsFromJSON(json, fileContext) {
   let { axioms } = json;
 
-  const axiomsJSON = axioms; ///
-        axioms = axiomsJSON.map((axiomJSON) => {
-          const { Axiom } = shim,
-                json = axiomJSON,  ///
-                axiom = Axiom.fromJSON(json, fileContext);
+  const { Axiom } = shim,
+        axiomsJSON = axioms; ///
 
-          return (axiom);
-        });
+  axioms = axiomsJSON.map((axiomJSON) => {
+    const json = axiomJSON,  ///
+          axiom = Axiom.fromJSON(json, fileContext);
+
+    return (axiom);
+  });
 
   return axioms;
 }
@@ -198,14 +201,15 @@ export function premisesFromJSON(json, fileContext) {
 export function theoremsFromJSON(json, fileContext) {
   let { theorems } = json;
 
-  const theoremsJSON = theorems; ///
-        theorems = theoremsJSON.map((theoremJSON) => {
-          const { Theorem } = shim,
-                json = theoremJSON,  ///
-                theorem = Theorem.fromJSON(json, fileContext);
+  const { Theorem } = shim,
+        theoremsJSON = theorems; ///
 
-          return (theorem);
-        });
+  theorems = theoremsJSON.map((theoremJSON) => {
+    const json = theoremJSON,  ///
+          theorem = Theorem.fromJSON(json, fileContext);
+
+    return (theorem);
+  });
 
   return theorems;
 }
@@ -213,14 +217,15 @@ export function theoremsFromJSON(json, fileContext) {
 export function variablesFromJSON(json, fileContext) {
   let { variables } = json;
 
-  const variablesJSON = variables; ///
-        variables = variablesJSON.map((variableJSON) => {
-          const { Variable } = shim,
-                json = variableJSON,  ///
-                variable = Variable.fromJSON(json, fileContext);
+  const { Variable } = shim,
+        variablesJSON = variables; ///
 
-          return (variable);
-        });
+  variables = variablesJSON.map((variableJSON) => {
+    const json = variableJSON,  ///
+          variable = Variable.fromJSON(json, fileContext);
+
+    return (variable);
+  });
 
   return variables;
 }
@@ -228,14 +233,15 @@ export function variablesFromJSON(json, fileContext) {
 export function conjecturesFromJSON(json, fileContext) {
   let { conjectures } = json;
 
-  const conjecturesJSON = conjectures; ///
-        conjectures = conjecturesJSON.map((conjectureJSON) => {
-          const { Conjecture } = shim,
-                json = conjectureJSON,  ///
-                conjecture = Conjecture.fromJSON(json, fileContext);
+  const { Conjecture } = shim,
+        conjecturesJSON = conjectures; ///
+
+  conjectures = conjecturesJSON.map((conjectureJSON) => {
+    const json = conjectureJSON,  ///
+          conjecture = Conjecture.fromJSON(json, fileContext);
 
-          return (conjecture);
-        });
+    return (conjecture);
+  });
 
   return conjectures;
 }
@@ -243,14 +249,15 @@ export function conjecturesFromJSON(json, fileContext) {
 export function combinatorsFromJSON(json, fileContext) {
   let { combinators } = json;
 
-  const combinatorsJSON = combinators; ///
-        combinators = combinatorsJSON.map((combinatorJSON) => {
-          const { Combinator } = shim,
-                json = combinatorJSON,  ///
-                combinator = Combinator.fromJSON(json, fileContext);
+  const { Combinator } = shim,
+        combinatorsJSON = combinators; ///
+
+  combinators = combinatorsJSON.map((combinatorJSON) => {
+    const json = combinatorJSON,  ///
+          combinator = Combinator.fromJSON(json, fileContext);
 
-          return (combinator);
-        });
+    return (combinator);
+  });
 
   return combinators;
 }
@@ -258,14 +265,15 @@ export function combinatorsFromJSON(json, fileContext) {
 export function constructorsFromJSON(json, fileContext) {
   let { constructors } = json;
 
-  const constructorsJSON = constructors; ///
-        constructors = constructorsJSON.map((constructorJSON) => {
-          const { Constructor } = shim,
-                json = constructorJSON,  ///
-                constructor = Constructor.fromJSON(json, fileContext);
+  const { Constructor } = shim,
+        constructorsJSON = constructors; ///
 
-          return (constructor);
-        });
+  constructors = constructorsJSON.map((constructorJSON) => {
+    const json = constructorJSON,  ///
+          constructor = Constructor.fromJSON(json, fileContext);
+
+    return (constructor);
+  });
 
   return constructors;
 }
@@ -273,14 +281,15 @@ export function constructorsFromJSON(json, fileContext) {
 export function metatheoremsFromJSON(json, fileContext) {
   let { metatheorems } = json;
 
-  const metatheoremsJSON = metatheorems; ///
-        metatheorems = metatheoremsJSON.map((metatheoremJSON) => {
-          const { Metatheorem } = shim,
-                json = metatheoremJSON,  ///
-                metatheorem = Metatheorem.fromJSON(json, fileContext);
+  const { Metatheorem } = shim,
+        metatheoremsJSON = metatheorems; ///
 
-          return (metatheorem);
-        });
+  metatheorems = metatheoremsJSON.map((metatheoremJSON) => {
+    const json = metatheoremJSON,  ///
+          metatheorem = Metatheorem.fromJSON(json, fileContext);
+
+    return (metatheorem);
+  });
 
   return metatheorems;
 }
@@ -304,7 +313,7 @@ export function suppositionsFromJSON(json, fileContext) {
 export function substitutionsFromJSON(json, fileContext) {
   let { substitutions = [] } = json;  ///
 
-  const { Substitution } = shim,
+  const { StatementForMetavariableSubstitution: Substitution } = shim,  ///
         substitutionsJSON = substitutions;  ///
 
   substitutions = substitutionsJSON.map((substitutionJSON) => {
@@ -320,14 +329,15 @@ export function substitutionsFromJSON(json, fileContext) {
 export function metavariablesFromJSON(json, fileContext) {
   let { metavariables } = json;
 
-  const metavariablesJSON = metavariables; ///
-        metavariables = metavariablesJSON.map((metavariableJSON) => {
-          const { Metavariable } = shim,
-                json = metavariableJSON,  ///
-                metavariable = Metavariable.fromJSON(json, fileContext);
+  const { Metavariable } = shim,
+        metavariablesJSON = metavariables; ///
 
-          return (metavariable);
-        });
+  metavariables = metavariablesJSON.map((metavariableJSON) => {
+    const json = metavariableJSON,  ///
+          metavariable = Metavariable.fromJSON(json, fileContext);
+
+    return (metavariable);
+  });
 
   return metavariables;
 }

package/src/utilities/unifier.js

@@ -20,26 +20,24 @@ export function terminalNodeMapFromNodes(nodes) {
   return terminalNodeMap;
 }
 
-export function areTerminalNodeMapsEqual(terminalNodeMapA, terminalNodeMapB) {
+export function areTerminalNodeMapsEqual(generalTerminalNodeMap, specificTerminalNodeMap) {
   let terminalNodeMapsEqual = false;
 
-  const indexesA = Object.keys(terminalNodeMapA), ///
-        indexesB = Object.keys(terminalNodeMapB), ///
-        terminalNodeMapKeysMatch = match(indexesA, indexesB, (indexA, indexB) => {
-          const matches = (indexA === indexB);
-
-          if (matches) {
+  const generalIndexes = Object.keys(generalTerminalNodeMap), ///
+        specificIndexes = Object.keys(specificTerminalNodeMap), ///
+        terminalNodeMapKeysMatch = match(generalIndexes, specificIndexes, (generalIndex, specificIndex) => {
+          if (generalIndex === specificIndex) {
             return true;
           }
         });
 
   if (terminalNodeMapKeysMatch) {
-    const terminalNodesA = Object.values(terminalNodeMapA), ///
-          terminalNodesB = Object.values(terminalNodeMapB), ///
-          terminalNodeMapValuesMatch = match(terminalNodesA, terminalNodesB, (terminalNodeA, terminalNodeB) => {
-            const matches = terminalNodeA.match(terminalNodeB);
+    const generalTerminalNodes = Object.values(generalTerminalNodeMap), ///
+          specificTerminalNodes = Object.values(specificTerminalNodeMap), ///
+          terminalNodeMapValuesMatch = match(generalTerminalNodes, specificTerminalNodes, (generalTerminalNode, specficTerminalNode) => {
+            const generalTerminalNodeMatchesSpecificTerminalNode = generalTerminalNode.match(specficTerminalNode);
 
-            if (matches) {
+            if (generalTerminalNodeMatchesSpecificTerminalNode) {
               return true;
             }
           });

package/src/variable.js

@@ -15,8 +15,8 @@ const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       termVariableNodeQuery = nodeQuery("/term/variable");
 
 class Variable {
-  constructor(localContext, string, node, name, type) {
-    this.localContext = localContext; ///
+  constructor(context, string, node, name, type) {
+    this.context = context; ///
     this.string = string;
     this.node = node;
     this.name = name;
@@ -24,7 +24,7 @@ class Variable {
   }
 
   getLocalContext() {
-    return this.localContext;
+    return this.context;
   }
 
   getString() {
@@ -59,16 +59,16 @@ class Variable {
     return variableNodeMatches;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified;
 
     const variableString = this.string; ///
 
-    localContext.trace(`Verifying the '${variableString}' variable...`);
+    context.trace(`Verifying the '${variableString}' variable...`);
 
     const variableNode = this.node, ///
           variableName = variableNameFromVariableNode(variableNode),
-          variable = localContext.findVariableByVariableName(variableName);
+          variable = context.findVariableByVariableName(variableName);
 
     if (variable !== null) {
       const type = variable.getType();
@@ -77,13 +77,13 @@ class Variable {
 
       verified = true;
     } else {
-      localContext.debug(`The '${variableString}' variable is not present.`);
+      context.debug(`The '${variableString}' variable is not present.`);
     }
 
     if (verified) {
       const typeName = this.type.getName();
 
-      localContext.debug(`...verified the '${variableString}:${typeName}' variable.`);
+      context.debug(`...verified the '${variableString}:${typeName}' variable.`);
     }
 
     return verified;
@@ -143,13 +143,13 @@ class Variable {
     return verifiedAtTopLevel;
   }
 
-  unifyTerm(term, substitutions, localContext) {
+  unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnified = false;
 
     const termString = term.getString(),
           variableString = this.string; ///
 
-    localContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
+    specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
     const termNode = term.getNode(),
           variableName = this.name, ///
@@ -163,24 +163,25 @@ class Variable {
       }
     } else {
       const variableNode = this.node,  ///
-            variable = variableFromVariableNode(variableNode, localContext),
-            termVariable = termVariableFromTermNode(termNode, localContext);
+            variable = variableFromVariableNode(variableNode, generalContext, specificContext),
+            termVariable = termVariableFromTermNode(termNode, generalContext, specificContext);
 
       if ((variable !== null) && (variable === termVariable)) {
         termUnified = true;
       } else {
-        const variable = this,  ///
-              termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable, localContext),
+        const context = specificContext,  ///
+              variable = this,  ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termForVariableSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, localContext);
+        substitutions.addSubstitution(substitution, context);
 
         termUnified = true;
       }
     }
 
     if (termUnified) {
-      localContext.trace(`...unified the '${termString}' term with the '${variableString}' variable.`);
+      specificContext.trace(`...unified the '${termString}' term with the '${variableString}' variable.`);
     }
 
     return termUnified;
@@ -205,16 +206,16 @@ class Variable {
           variableString = string,  ///
           variableNode = variableNodeFromVariableString(variableString, lexer, parser),
           variableName = variableNameFromVariableNode(variableNode),
-          localContext = LocalContext.fromFileContext(fileContext),
+          context = LocalContext.fromFileContext(fileContext),
           node = variableNode,
           name = variableName,  ///
           type = typeFromJSON(json, fileContext),
-          variable = new Variable(localContext, string, node, name, type);
+          variable = new Variable(context, string, node, name, type);
 
     return variable;
   }
 
-  static fromTermNode(termNode, localContext) {
+  static fromTermNode(termNode, context) {
     let variable = null;
 
     const termVariableNode = termVariableNodeQuery(termNode);
@@ -223,42 +224,42 @@ class Variable {
       const variableNode = termVariableNode,  ///
             variableName = variableNameFromVariableNode(variableNode),
             node = variableNode,  ///
-            string = localContext.nodeAsString(node),
+            string = context.nodeAsString(node),
             name = variableName,  ///
             type = null;
 
-      variable = new Variable(localContext, string, node, name, type);
+      variable = new Variable(context, string, node, name, type);
     }
 
     return variable;
   }
 
-  static fromVariableNode(variableNode, localContext) {
+  static fromVariableNode(variableNode, context) {
     let variable = null;
 
     if (variableNode !== null) {
       const node = variableNode,  ///
             variableName = variableNameFromVariableNode(variableNode),
-            string = localContext.nodeAsString(node),
+            string = context.nodeAsString(node),
             name = variableName,  ///
             type = null;
 
-      variable = new Variable(localContext, string, node, name, type);
+      variable = new Variable(context, string, node, name, type);
     }
 
     return variable;
   }
 
-  static fromVariableNodeAndType(variableNode, type, localContext) {
+  static fromVariableNodeAndType(variableNode, type, context) {
     let variable = null;
 
     if (variableNode !== null) {
       const node = variableNode,  ///
             variableName = variableNameFromVariableNode(variableNode),
-            string = localContext.nodeAsString(node),
+            string = context.nodeAsString(node),
             name = variableName;  ///
 
-      variable = new Variable(localContext, string, node, name, type);
+      variable = new Variable(context, string, node, name, type);
     }
 
     return variable;
@@ -269,13 +270,13 @@ class Variable {
           typeNode = typeNodeQuery(variableDeclarationNode),
           variableNode = variableNodeQuery(variableDeclarationNode),
           variableName = variableNameFromVariableNode(variableNode),
-          localContext = LocalContext.fromFileContext(fileContext),
+          context = LocalContext.fromFileContext(fileContext),
           variableString = fileContext.nodeAsString(variableNode),
           string = variableString,  ///
           node = variableNode,  ///
           name = variableName,  ///
-          type = Type.fromTypeNode(typeNode, localContext),
-          variable = new Variable(localContext, string, node, name, type);
+          type = Type.fromTypeNode(typeNode, context),
+          variable = new Variable(context, string, node, name, type);
 
     return variable;
   }
@@ -287,23 +288,25 @@ Object.assign(shim, {
 
 export default Variable;
 
-function termVariableFromTermNode(termNode, localContext) {
+function variableFromVariableNode(variableNode, generalContext, specificContext) {
+  const variableName = variableNameFromVariableNode(variableNode),
+        context = generalContext, ///
+        variable = context.findVariableByVariableName(variableName);
+
+  return variable;
+}
+
+function termVariableFromTermNode(termNode, specificContext, generalContext) {
   let termVariable = null;
 
   const termVariableNode = termVariableNodeQuery(termNode);
 
   if (termVariableNode !== null) {
-    const termVariableName = variableNameFromVariableNode(termVariableNode);
+    const termVariableName = variableNameFromVariableNode(termVariableNode),
+          context = generalContext; ///
 
-    termVariable = localContext.findVariableByVariableName(termVariableName);
+    termVariable = context.findVariableByVariableName(termVariableName);
   }
 
   return termVariable;
 }
-
-function variableFromVariableNode(variableNode, localContext) {
-  const variableName = variableNameFromVariableNode(variableNode),
-        variable = localContext.findVariableByVariableName(variableName);
-
-  return variable;
-}

package/src/verifier/statementAsCombinator.js

@@ -29,7 +29,8 @@ class StatementAsCombinatorVerifier extends Verifier {
       verify: (termNode, fileContext) => {
         const { Term } = shim,
               localContext = LocalContext.fromFileContext(fileContext),
-              term = Term.fromTermNode(termNode, localContext),
+              context = localContext, ///
+              term = Term.fromTermNode(termNode, context),
               termVerified = term.verify(localContext, () => {
                 const verifiedAhead = true;
 

package/src/verifier/termAsConstructor.js

@@ -33,7 +33,8 @@ class TermAsConstructorVerifier extends Verifier {
       verify: (termNode, fileContext, verifyAhead) => {
         const { Term } = shim,
               localContext = LocalContext.fromFileContext(fileContext),
-              term = Term.fromTermNode(termNode, localContext),
+              context = localContext, ///
+              term = Term.fromTermNode(termNode, context),
               termVerified = term.verify(localContext, verifyAhead);
 
         return termVerified;