occam-verify-cli 0.0.842 → 0.0.844

package/src/context/local.js

@@ -5,12 +5,7 @@ import Equivalence from "../equivalence";
 import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
-import { mergeEquivalences,
-         separateEquivalences,
-         findEquivalenceByTerm,
-         compressDefinedVariables,
-         definedVariablesFromGroundedEquivalences,
-         implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables } from "../utilities/equivalences";
+import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
 class LocalContext {
   constructor(context, variables, proofSteps, equivalences) {
@@ -90,49 +85,42 @@ class LocalContext {
     return termType;
   }
 
-  isVariableDefined(variable) {
-    let variableDefined = false;
-
-    const equivalences = this.getEquivalences(),
-          remainingEquivalences = [],
-          initiallyGroundedEquivalences = [];
-
-    separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences);
-
-    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
-
-    if (initiallyGroundedEquivalencesLength > 0) {
-      let groundedEquivalences,
-          implicitlyGroundedEquivalences,
-          implicitlyGroundedEquivalencesLength;
-
-      const context = this,
-            definedVariables = [];
-
-      groundedEquivalences = initiallyGroundedEquivalences; ///
-
-      definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
-
-      implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+  isTermGrounded(term) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
-      while (implicitlyGroundedEquivalencesLength > 0) {
-        groundedEquivalences = implicitlyGroundedEquivalences;  ///
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+            const termMatchesGroundedTerm = term.match(groundedTerm);
 
-        definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
+            if (termMatchesGroundedTerm) {
+              return true;
+            }
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
 
-        implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+    return termGrounded;
+  }
 
-        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
-      }
+  isVariableDefined(variable) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-      compressDefinedVariables(definedVariables);
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
-      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+            const variableMatchesDefinedVariable = variable.match(definedVariable);
 
-      variableDefined = definedVariablesIncludesVariable;  ///
-    }
+            if (variableMatchesDefinedVariable) {
+              return true;
+            }
+          }),
+          variableDefined = variableMatchesDefinedVariable; ///
 
     return variableDefined;
   }

package/src/equivalence.js

@@ -107,35 +107,47 @@ export default class Equivalence {
     return termNodesMatch;
   }
 
-  getVariables(context) {
-    const variables = [];
-
+  getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
-      term.getVariables(variables, context);
-    });
+      const termGrounded = term.isGrounded(definedVariables, context);
+
+      if (termGrounded) {
+        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+          const termMatchesGroundedTerm = term.match(groundedTerm);
+
+          if (termMatchesGroundedTerm) {
+            return true;
+          }
+        })
 
-    return variables;
+        if (!termMatchesGroundedTerm) {
+          const groundedTerm = term;
+
+          groundedTerms.push(groundedTerm);
+        }
+      }
+    });
   }
 
-  isInitiallyGrounded() {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(),
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
           initiallyGroundedTermsLength = initiallyGroundedTerms.length,
           initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables),
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
           implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
           implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
 
     return implicitlyGrounded;
   }
 
-  getInitiallyGroundedTerms() {
+  getInitiallyGroundedTerms(context) {
     const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded();
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
 
       if (termInitiallyGrounded) {
         const initiallyGroundedTerm = term; ///
@@ -149,9 +161,9 @@ export default class Equivalence {
     return initiallyGroundedTerms;
   }
 
-  getImplicitlyGroundedTerms(definedVariables) {
+  getImplicitlyGroundedTerms(definedVariables, context) {
     const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables);
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
 
       if (termImplicitlyGrounded) {
         const implicitlyGroundedTerm = term; ///

package/src/log.js

@@ -107,7 +107,9 @@ function formatMessage(level, message, node = null, tokens = null, filePath = nu
   const upperCaseLevel = level.toUpperCase();
 
   if ((node === null) || (tokens === null)) {
-    message = `${upperCaseLevel}: ${filePath} - ${message}`;
+    message = (filePath !== null) ?
+              `${upperCaseLevel}: ${filePath} - ${message}`:
+                `${upperCaseLevel}: ${message}`;
   } else {
     const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
           leastLineNumber = leastLineIndex, ///

package/src/substitution/statementForMetavariable.js

@@ -2,14 +2,18 @@
 
 import Substitution from "../substitution";
 
+import TermForVariableSubstitution from "./termForVariable";
+import intrinsicLevelNodesVerifier from "../verifier/nodes/intrinsicLevel";
+
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(metavariableNode, statementNode) {
+  constructor(metavariableNode, statementNode, substitution) {
     super();
 
     this.metavariableNode = metavariableNode;
     this.statementNode = statementNode;
+    this.substitution = substitution;
   }
 
   getMetavariableNode() {
@@ -20,10 +24,14 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode) {
+  getSubstitution() {
+    return this.substitution;
+  }
+
+  matchStatementNode(statementNode, substitutions, localContextA, localContextB) {
     let statementNodeMatches;
 
-    statementNodeMatches = this.statementNode.match(statementNode);
+    statementNodeMatches = this.matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB);
 
     if (!statementNodeMatches) {
       const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -31,13 +39,29 @@ export default class StatementForMetavariableSubstitution extends Substitution {
       if (bracketedStatementChildNode !== null) {
         const statementNode = bracketedStatementChildNode; ///
 
-        statementNodeMatches = this.statementNode.match(statementNode);
+        statementNodeMatches = this.matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB);
       }
     }
 
     return statementNodeMatches;
   }
 
+  matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB) {
+    let statementNodeMatches;
+
+    if (this.substitution === null) {
+      statementNodeMatches = this.statementNode.match(statementNode);
+    } else {
+      const substitution = this.substitution,
+            statementNodeA = statementNode, ///
+            statementNodeB = this.statementNode;  ///
+
+      statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    }
+
+    return statementNodeMatches;
+  }
+
   matchMetavariableNode(metavariableNode) {
     const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
@@ -45,16 +69,56 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
-    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
+    const substitution = null;
+
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+
+    const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+
+    if (bracketedStatementChildNode !== null) {
+      const statementNode = bracketedStatementChildNode; ///
+
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+    }
+
+    return statementForMetavariableSubstitution;
+  }
+
+  static fromMetavariableNodeStatementNodeAndSubstitution(metavariableNode, statementNode, substitution) {
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
 
     const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
     if (bracketedStatementChildNode !== null) {
       const statementNode = bracketedStatementChildNode; ///
 
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
     }
 
     return statementForMetavariableSubstitution;
   }
 }
+
+export function matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementNodeMatches;
+
+  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
+
+  substitution = termForVariableSubstitution; ///
+
+  substitutions = [ ///
+    substitution
+  ];
+
+  const nonTerminalNodeA = statementNodeA, ///
+        nonTerminalNodeB = statementNodeB,  ///
+        nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+  statementNodeMatches = nonTerminalNodeVerified; ///
+
+  return statementNodeMatches;
+}

package/src/substitution/termForVariable.js

@@ -2,6 +2,11 @@
 
 import Substitution from "../substitution";
 
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/*/term!"),
+      variableNodeQuery = nodeQuery("/*/variable!");
+
 export default class TermForVariableSubstitution extends Substitution {
   constructor(variableNode, termNode) {
     super();
@@ -30,9 +35,80 @@ export default class TermForVariableSubstitution extends Substitution {
     return variableNodeMatches;
   }
 
+  static fromSubstitutionNode(substitutionNode) {
+    const termNode = termNodeQuery(substitutionNode),
+          variableNode = variableNodeQuery(substitutionNode),
+          termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+
+    return termForVariableSubstitution;
+  }
+
   static fromVariableNodeAndTermNode(variableNode, termNode) {
     const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
 
     return termForVariableSubstitution;
   }
-}
+
+  static fromSubstitutionAndSubstitutions(substitution, substitutions) {
+    let termNode = substitution.getTermNode(),
+        variableNode = substitution.getVariableNode();
+
+    termNode = substituteTermNode(termNode, substitutions); ///
+
+    variableNode = substituteVariableNode(variableNode, substitutions); ///
+
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+
+    return termForVariableSubstitution;
+  }
+
+  static fromSubstitutionNodeAndSubstitutions(substitutionNode, substitutions) {
+    let termNode = termNodeQuery(substitutionNode),
+        variableNode = variableNodeQuery(substitutionNode);
+
+    termNode = substituteTermNode(termNode, substitutions); ///
+
+    variableNode = substituteVariableNode(variableNode, substitutions); ///
+
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+
+    return termForVariableSubstitution;
+  }
+}
+
+function substituteTermNode(termNode, substitutions) {
+  const termVariableNode = variableNodeQuery(termNode);
+
+  if (termVariableNode !== null) {
+    substitutions.some((substitution) => {
+      const variableNodeMatches = substitution.matchVariableNode(termVariableNode);
+
+      if (variableNodeMatches) {
+        termNode = substitution.getTermNode();  ///
+
+        return true;
+      }
+    });
+  }
+
+  return termNode;
+}
+
+function substituteVariableNode(variableNode, substitutions) {
+  substitutions.some((substitution) => {
+    const variableNodeMatches = substitution.matchVariableNode(variableNode);
+
+    if (variableNodeMatches) {
+      const termNode = substitution.getTermNode(),
+            termVariableNode = variableNodeQuery(termNode);
+
+      if (termVariableNode !== null) {
+        variableNode = termVariableNode;  ///
+
+        return true;
+      }
+    }
+  });
+
+  return variableNode;
+}

package/src/term.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
 
 const variableNodesQuery = nodesQuery("//variable");
@@ -25,8 +26,9 @@ export default class Term {
     return matches;
   }
 
-  getVariables(variables, context) {
-    const variableNodes = variableNodesQuery(this.node);
+  getVariables(context) {
+    const variables = [],
+          variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
       const variable = context.findVariableByVariableNode(variableNode),
@@ -40,31 +42,35 @@ export default class Term {
     return variables;
   }
 
-  isInitiallyGrounded() {
-    const definedVariables = [],
-          implicitlyGrounded = this.isImplicitlyGrounded(definedVariables),
-          initiallyGrounded = implicitlyGrounded; ///
+  isGrounded(definedVariables, context) {
+    const variables = this.getVariables(context);
+
+    filter(variables, (variable) => {
+      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+
+      if (!definedVariablesIncludesVariable) {
+        return true;
+      }
+    });
+
+    const undefinedVariables = variables, ///
+          undefinedVariablesLength = undefinedVariables.length,
+          grounded = (undefinedVariablesLength <= 1);
+
+    return grounded;
+  }
+
+  isInitiallyGrounded(context) {
+    const variables = this.getVariables(context),
+          variablesLength = variables.length,
+          initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const variableNodes = variableNodesQuery(this.node),
-          variables = definedVariables, ///
-          nodes = variableNodes,  ///
-          implicitlyGrounded = nodes.every((node) => {
-            const variableMatchesNode = variables.some((variable) => {
-              const variableMatchesNode = variable.matchNode(node);
-
-              if (variableMatchesNode) {
-                return true;
-              }
-            });
-
-            if (variableMatchesNode) {
-              return true;
-            }
-          });
+  isImplicitlyGrounded(definedVariables, context) {
+    const grounded = this.isGrounded(definedVariables, context),
+          implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;
   }

package/src/utilities/array.js

@@ -29,6 +29,12 @@ export function someSubArray(array, subArrayLength, callback) {
       permutations = permutationsMatrix[indexesLength][permutationLength];
     }
 
+    if (subArrayLength === 4) {
+      permutations = [
+        [ 0, 2, 3, 4 ]
+      ];
+    }
+
     if (permutations !== null) {
       found = permutations.some((permutation) => {
         if (permutation !== null) {