occam-verify-cli 0.0.968 → 0.0.971

package/src/substitution/termForVariable.js

@@ -3,26 +3,27 @@
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
+import { stripBracketsFromTerm } from "../utilities/brackets";
 
-const termNodeQuery = nodeQuery("/*/term!"),
+const termNodeQuery = nodeQuery("/substitution/term!"),
       variableNodeQuery = nodeQuery("/*/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(variableNode, termNode) {
+  constructor(termNode, variableNode) {
     super();
 
-    this.variableNode = variableNode;
     this.termNode = termNode;
-  }
-
-  getVariableNode() {
-    return this.variableNode;
+    this.variableNode = variableNode;
   }
 
   getTermNode() {
     return this.termNode;
   }
 
+  getVariableNode() {
+    return this.variableNode;
+  }
+
   getNode() {
     const node = this.termNode; ///
 
@@ -32,12 +33,11 @@ export default class TermForVariableSubstitution extends Substitution {
   transformed(substitutions) {
     let transformedSubstitution = null;
 
-    const transformedTermNode = transformTermNode(this.termNode, substitutions),
-          transformedVariableNode = transformVariableNode(this.variableNode, substitutions);
+    const transformedTermNode = transformTermNode(this.termNode, substitutions);
 
-    if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
+    if (transformedTermNode !== null) {
       const termNode = transformedTermNode, ///
-            variableNode = transformedVariableNode,
+            variableNode = this.variableNode, ///
             termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
 
       transformedSubstitution = termForVariableSubstitution;  ///
@@ -46,29 +46,41 @@ export default class TermForVariableSubstitution extends Substitution {
     return transformedSubstitution;
   }
 
+  match(substitution) {
+    const termNode = substitution.getTermNode(),
+          variableNode = substitution.getVariableNode(),
+          termNodeMatches = this.matchTermNode(termNode),
+          variableNodeMatches = this.matchVariableNode(variableNode),
+          matches = (termNodeMatches && variableNodeMatches);
+
+    return matches;
+  }
+
   matchTermNode(termNode) {
-    const matchesTermNode = this.termNode.match(termNode);
+    termNode = stripBracketsFromTerm(termNode); ///
 
-    return matchesTermNode;
+    const termNodeMatches = this.termNode.match(termNode);
+
+    return termNodeMatches;
   }
 
   matchVariableNode(variableNode) {
-    const matchesVariableNode = this.variableNode.match(variableNode);
+    const metavariableNodeMatches = this.variableNode.match(variableNode);
 
-    return matchesVariableNode;
+    return metavariableNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedWithEquivalence;
 
-    const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
+    const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
 
-    if (equivalenceMatchesVariableNode) {
-      const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
+    if (equivalenceMatchesTermNode) {
+      const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
 
-      if (equivalenceMatchesTermNode) {
-        unifiedWithEquivalence = true;
-      }
+      if (equivalenceMatchesVariableNode) {
+          unifiedWithEquivalence = true;
+        }
     }
 
     return unifiedWithEquivalence;
@@ -78,38 +90,32 @@ export default class TermForVariableSubstitution extends Substitution {
     const termNodeB = this.termNode,  ///
           termStringB = localContextB.nodeAsString(termNodeB),
           variableNodeA = this.variableNode,  ///
-          variableStringA = localContextA.nodeAsString(variableNodeA),
-          string = `[${termStringB} for ${variableStringA}]`;
+          variableStringA = localContextA.nodeAsString(variableNodeA);
+
+    const string = `[${termStringB} for ${variableStringA}]`;
 
     return string;
   }
 
   static fromSubstitutionNode(substitutionNode) {
-    const termNode = termNodeQuery(substitutionNode),
-          variableNode = variableNodeQuery(substitutionNode),
-          termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+    let termForVariableSubstitution = null;
 
-    return termForVariableSubstitution;
-  }
+    let termNode = termNodeQuery(substitutionNode),
+        variableNode = variableNodeQuery(substitutionNode);
+
+    if (termNode !== null) {
+      termNode = stripBracketsFromTerm(termNode); ///
 
-  static fromVariableNodeAndTermNode(variableNode, termNode) {
-    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+      termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+    }
 
     return termForVariableSubstitution;
   }
 
-  static fromSubstitutionAndSubstitutions(substitution, substitutions) {
-    let termNode = substitution.getTermNode(),
-        variableNode = substitution.getVariableNode();
-
-    const transformedTermNode = transformTermNode(termNode, substitutions),
-          transformedVariableNode = transformVariableNode(variableNode, substitutions); ///
+  static fromTernNodeAndVariableNode(termNode, variableNode) {
+    termNode = stripBracketsFromTerm(termNode); ///
 
-    termNode = transformedTermNode; ///
-
-    variableNode = transformedVariableNode; ///
-
-    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
+    const termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
 
     return termForVariableSubstitution;
   }
@@ -118,11 +124,11 @@ export default class TermForVariableSubstitution extends Substitution {
 function transformTermNode(termNode, substitutions) {
   let transformedTermNode = null;
 
-  const termVariableNode = variableNodeQuery(termNode);
+  const variableNode = variableNodeQuery(termNode);
 
-  if (termVariableNode !== null) {
+  if (variableNode !== null) {
     substitutions.someSubstitution((substitution) => {
-      const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
+      const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
       if (substitutionMatchesVariableNode) {
         const termNode = substitution.getTermNode();
@@ -136,24 +142,3 @@ function transformTermNode(termNode, substitutions) {
 
   return transformedTermNode;
 }
-
-function transformVariableNode(variableNode, substitutions) {
-  let transformedVariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
-
-    if (substitutionMatchesVariableNode) {
-      const termNode = substitution.getTermNode(),
-            variableNode = variableNodeQuery(termNode);
-
-      if (variableNode !== null) {
-        transformedVariableNode = variableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedVariableNode;
-}

package/src/substitution.js

@@ -1,28 +1,66 @@
 "use strict";
 
 export default class Substitution {
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isComplex() {
+    const simple = this.isSimple(),
+          complex = !simple;
+
+    return complex;
+  }
+
+  isResolved() {
+    const simple = this.isSimple(),
+          resolved = simple; ///
+
+    return resolved;
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = null;
+
+    return metavariableNode;
+  }
+
   matchTermNode(termNode) {
-    const matchesTermNode = false;
+    const termNodeMatches = false;
 
-    return matchesTermNode;
+    return termNodeMatches;
   }
 
   matchVariableNode(variableNode) {
-    const matchesMetavariableNode = false;
+    const variableNodeMatches = false;
 
-    return matchesMetavariableNode;
+    return variableNodeMatches;
   }
 
   matchStatementNode(statementNode) {
-    const matchesStatementNode = false;
+    const statementNodeMatches = false;
 
-    return matchesStatementNode;
+    return statementNodeMatches;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const matchesMetavariableNode = false;
+    const metavariableNodeMatches = false;
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
+
+    return metavariableNodeAndSubstitutionNodeMatches;
+  }
+
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence = false;
 
-    return matchesMetavariableNode;
+    return unifiedWithEquivalence;
   }
 
   unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB) {

package/src/substitutions.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import { prune, compare, rightDifference } from "./utilities/array";
+import { EMPTY_STRING } from "./constants";
+import { find, first, prune, compress, rightDifference } from "./utilities/array";
 
 export default class Substitutions {
   constructor(array, savedArray) {
@@ -16,26 +17,160 @@ export default class Substitutions {
     return this.savedArray;
   }
 
-  hasChanged() {
-    const compares = compare(this.array, this.savedArray),
-          changed = !compares;  ///
+  getFirstSubstitution() {
+    let firstSubstitution = null;
 
-    return changed;
+    const length = this.array.length;
+
+    if (length > 0) {
+      firstSubstitution = first(this.array);
+    }
+
+    return firstSubstitution;
+  }
+
+  getMetavariableNodes() {
+    const metavariableNodes = [];
+
+    this.forEachSubstitution((substitution) => {
+      const metavariableNode = substitution.getMetavariableNode();
+
+      if (metavariableNode !== null) {
+        metavariableNodes.push(metavariableNode);
+      }
+    });
+
+    compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
+      const metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
+
+      if (metavariableNodeAMatchesMetavariableNodeB) {
+        return true;
+      }
+    });
+
+    return metavariableNodes;
   }
 
-  findSubstitution(callback) { return this.array.find(callback); }
+  findSubstitution(callback) { return this.array.find(callback) || null; }  ///
 
   someSubstitution(callback) { return this.array.some(callback); }
 
   everySubstitution(callback) { return this.array.every(callback); }
 
+  forEachSubstitution(callback) { this.array.forEach(callback); }
+
+  findSubstitutions(callback) {
+    const array = find(this.array, callback),
+          substitutions = Substitutions.fromArray(array);
+
+    return substitutions;
+  }
+
+  filterSubstitution(callback) {
+    const array = this.array.filter(callback),
+          substitutions = Substitutions.fromArray(array);
+
+    return substitutions;
+  }
+
+  findSimpleSubstitution() {
+    const simpleSubstitution = this.findSubstitution((substitution) => {
+      const substitutionSimple = substitution.isSimple();
+
+      if (substitutionSimple) {
+        return true;
+      }
+    });
+
+    return simpleSubstitution;
+  }
+
+  findSubstitutionByVariableNode(variableNode) {
+    const substitution = this.findSubstitution((substitution) => {
+      const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
+
+      if (substitutionMatchesVariableNode) {
+        return true;
+      }
+    });
+
+    return substitution;
+  }
+
+  findSubstitutionsByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutions((substitution) => {
+      const substitutionMatchesMetavariableNode = substitution.matchMetavariableNode(metavariableNode);
+
+      if (substitutionMatchesMetavariableNode) {
+        return true;
+      }
+    });
+
+    return substitutions;
+  }
+
+  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
+          simpleSubstitutions = substitutions.filterSubstitution((substitution) => {
+            const substitutionSimple = substitution.isSimple();
+
+            if (substitutionSimple) {
+              return true;
+            }
+          }),
+          firstSimpleSubstitution = simpleSubstitutions.getFirstSubstitution(),
+          simpleSubstitution = firstSimpleSubstitution; ///
+
+    return simpleSubstitution;
+  }
+
+  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
+          complexSubstitutions = substitutions.filterSubstitution((substitution) => {
+            const substitutionComplex = substitution.isComplex();
+
+            if (substitutionComplex) {
+              return true;
+            }
+          });
+
+    return complexSubstitutions;
+  }
+
+  findSubstitutionsByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const substitutions = this.findSubstitutions((substitution) => {
+      const substitutionMatchesMetavariableNodeAndSubstitutionNode = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+
+      if (substitutionMatchesMetavariableNodeAndSubstitutionNode) {
+        return true;
+      }
+    });
+
+    return substitutions;
+  }
+
+  findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
+          complexSubstitutions = substitutions.filterSubstitution((substitution) => {
+            const substitutionComplex = substitution.isComplex();
+
+            if (substitutionComplex) {
+              return true;
+            }
+          }),
+          firstComplexSubstitution = complexSubstitutions.getFirstSubstitution(),
+          complexSubstitution = firstComplexSubstitution; ///
+
+    return complexSubstitution;
+  }
+
   addSubstitution(substitution, localContextA, localContextB) {
     this.array.push(substitution);
 
     const substitutionNode = substitution.getNode(),
           substitutionString = substitution.asString(localContextA, localContextB);
 
-    localContextB.trace(`Added the '${substitutionString}' substitution.`, substitutionNode);
+    localContextB.trace(`Added the ${substitutionString} substitution.`, substitutionNode);
   }
 
   removeSubstitution(substitution, localContextA, localContextB) {
@@ -52,7 +187,7 @@ export default class Substitutions {
     const substitutionNode = substitution.getNode(),
           substitutionString = substitution.asString(localContextA, localContextB);
 
-    localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
+    localContextB.trace(`Removed the ${substitutionString} substitution.`, substitutionNode);
   }
 
   unifyWithEquivalences(equivalences, localContextA, localContextB) {
@@ -68,6 +203,16 @@ export default class Substitutions {
     return unifiedWithEquivalences;
   }
 
+  areResolved() {
+    const resolved = this.everySubstitution((substitution) => {
+      const substitutionResolved = substitution.isResolved();
+
+      return substitutionResolved;
+    });
+
+    return resolved;
+  }
+
   snapshot() {
     this.savedArray = [
       ...this.array
@@ -96,8 +241,29 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  transform() {
-    ///
+  asString(localContextA, localContextB) {
+    let string = this.array.reduce((string, substitution) => {
+      const substitutionString = substitution.asString(localContextA, localContextB);
+
+      string = (string === null) ?
+                 substitutionString :
+                   `${string}, ${substitutionString}`;
+
+      return string;
+    }, EMPTY_STRING);
+
+    if (string !== EMPTY_STRING) {
+      string = ` ${string}`;
+    }
+
+    return string;
+  }
+
+  static fromArray(array) {
+    const savedArray = [],
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
   }
 
   static fromNothing() {

package/src/term.js

@@ -60,6 +60,12 @@ export default class Term {
     return grounded;
   }
 
+  matchTermNode(termNode) {
+    const termNodeMatches = this.node.match(termNode);
+
+    return termNodeMatches;
+  }
+
   isInitiallyGrounded(localContext) {
     const variables = this.getVariables(localContext),
           variablesLength = variables.length,

package/src/topLevelAssertion.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Substitutions from "./substitutions";
+import resolveSubstitutions from "./resolve/substitutions";
 import unifyConsequentWithStatement from "./unify/consequentWithStatement";
 import unifySuppositionsWithProofSteps from "./unify/suppositionsWithProofSteps";
 
@@ -48,22 +49,26 @@ export default class TopLevelAssertion {
       const consequentA = this.consequent,  ///
             consequentUnified = unifyConsequentWithStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
 
-      statementUnified = consequentUnified;  ///
+      if (consequentUnified) {
+        const substitutionsResolved = resolveSubstitutions(substitutions, fileContextA, localContextB);
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const matchesMetavariableNode = this.labels.some((label) => {
-      const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-      if (labelMatchesMetavariableNode) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
 
-    return matchesMetavariableNode;
+    return metavariableNodeMatches;
   }
 
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }

package/src/type.js

@@ -92,15 +92,15 @@ export default class Type {
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nodeMatches = (this.name === name);
 
-    return matchesName;
+    return nodeMatches;
   }
 
   matchTypeName(typeName) {
-    const matchesTypeName = (this.name === typeName);
+    const typeNameMatches = (this.name === typeName);
 
-    return matchesTypeName;
+    return typeNameMatches;
   }
 
   matchTypeNode(typeNode) {

package/src/unifier/metaLevel.js

@@ -4,6 +4,7 @@ import shim from "../shim";
 import Unifier from "../unifier";
 import unifyVariableWithTerm from "../unify/variableWithTerm";
 import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
+import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -36,10 +37,17 @@ class MetaLevelUnifier extends Unifier {
         const metavariableNodeA = metavariableNodeQuery(statementNodeA);
 
         if (metavariableNodeA !== null) {
-          const substitutionNodeA = substitutionNodeQuery(statementNodeA),
-                metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+          const substitutionNodeA = substitutionNodeQuery(statementNodeA);
 
-          statementUnifiedWithStatement = metavariableUnifiedWithStatement;  ///
+          if (substitutionNodeA === null) {
+            const metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB);
+
+            statementUnifiedWithStatement = metavariableUnifiedWithStatement; ///
+          } else {
+            const metavariableUnifiedWithStatementGivenSubstitution = unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+
+            statementUnifiedWithStatement = metavariableUnifiedWithStatementGivenSubstitution; ///
+          }
         } else {
           const nonTerminalNodeA = statementNodeA, ///
                 nonTerminalNodeB = statementNodeB, ///

package/src/unifier/statementWithCombinator.js

@@ -12,12 +12,12 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!");
 
 class StatementWithCombinatorUnifier extends Unifier {
-  unify(statementNode, combinatorStatementNode, assignments, derived, localContext) {
+  unify(statementNode, combinatorStatementNode, assignments, stated, localContext) {
     let statementUnifiedWithCombinator;
 
     const nonTerminalNodeA = statementNode, ///
           nonTerminalNodeB = combinatorStatementNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, derived, localContext);
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, stated, localContext);
 
     statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
 
@@ -28,10 +28,10 @@ class StatementWithCombinatorUnifier extends Unifier {
     {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
-      unify: (statementNodeA, metaTypeNodeB, assignments, derived, localContext) => {
+      unify: (statementNodeA, metaTypeNodeB, assignments, stated, localContext) => {
         const metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext);
+              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, stated, localContext);
 
         return statementUnifiedWithMetaType;
       }
@@ -39,7 +39,7 @@ class StatementWithCombinatorUnifier extends Unifier {
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, assignments, derived, localContext) => {
+      unify: (termNodeA, typeNodeB, assignments, stated, localContext) => {
         const termNode = termNodeA, ///
               typeNode = typeNodeB, ///
               termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);

package/src/unifier.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
+import { isLastRemainingArgumentFunction } from "./utilities/arguments";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/unifier";
-import {isLastRemainingArgumentFunction} from "./utilities/arguments";
 
 const nonTerminalNodeQuery = nodeQuery("/*");