occam-verify-cli 0.0.941 → 0.0.943

package/src/unify/variableAgainstTerm.js

@@ -1,17 +1,15 @@
 "use strict";
 
-import verifyTerm from "../verify/term";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
-import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
   let variableUnifiedAgainstTerm = false;
 
-  const substitution = substitutions.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
     if (substitutionMatchesVariableNodeA) {
@@ -23,66 +21,38 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
     const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
     if (substitutionMatchesTermNodeB) {
-      const verifiedAhead = verifyAhead();
-
-      variableUnifiedAgainstTerm = verifiedAhead;  ///
+      variableUnifiedAgainstTerm = true;
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
 
     if (variableA !== null) {
-      const terms = [],
-            termUnified = verifyTerm(termNodeB, terms, localContextB, () => {
-              let verifiedAhead = false;
-
-              const firstTerm = first(terms),
-                    termB = firstTerm, ///
-                    variableB = variableFromTerm(termB, localContextB);
-
-              if (variableA === variableB) {
-                verifiedAhead = verifyAhead();
-              } else {
-                const term = termB, ///
-                      variable = variableA, ///
-                      termType = term.getType(),
-                      variableType = variable.getType(),
-                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
-
-                if (variableTypeEqualToOrSuperTypeOfTermType) {
-                  const termNode = termNodeB, ///
-                        variableNode = variableNodeA, ///
-                        termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-                        substitution = termForVariableSubstitution;  ///
-
-                  substitutions.push(substitution);
-
-                  verifiedAhead = verifyAhead();
-
-                  if (!verifiedAhead) {
-                    substitutions.pop();
-                  }
-                }
-              }
-
-              return verifiedAhead;
-            });
-
-      variableUnifiedAgainstTerm = termUnified;  ///
+      const variableB = variableFromTermNode(termNodeB, localContextB);
+
+      if (variableA !== variableB) {
+        const termNode = termNodeB, ///
+              variableNode = variableNodeA, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContextA, localContextB);
+      }
+
+      variableUnifiedAgainstTerm = true;
     }
   }
 
   return variableUnifiedAgainstTerm;
 }
 
-function variableFromTerm(term, localContext) {
+function variableFromTermNode(termNode, localContext) {
   let variable = null;
 
-  const termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
+  const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
     variable = localContext.findVariableByVariableNode(variableNode);
   }
 
   return variable;
-}
+}

package/src/utilities/arguments.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { last } from "./array";
+import { FUNCTION } from "../constants";
+
+export function isLastRemainingArgumentFunction(remainingArguments) {
+  let lastRemainingArgumentFunction = false;
+
+  const remainingArgumentsLength = remainingArguments.length;
+
+  if (remainingArgumentsLength > 0) {
+    const lastRemainingArgument = last(remainingArguments);
+
+    lastRemainingArgumentFunction = (typeof lastRemainingArgument === FUNCTION);
+  }
+
+  return lastRemainingArgumentFunction;
+}

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, second, last, extract, push, match, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, extract, push, match, prune, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///
@@ -12,6 +12,21 @@ export function reverse(array) {
   return array;
 }
 
+export function compare(arrayA, arrayB) {
+  let compares = false;
+
+  const arrayALength = arrayA.length,
+        arrayBLength = arrayB.length;
+
+  if (arrayALength === arrayBLength) {
+    const correlates = correlate(arrayA, arrayB);
+
+    compares = correlates;  ///
+  }
+
+  return compares;
+}
+
 export function correlate(arrayA, arrayB, callback) {
   arrayB = [  ///
     ...arrayB

package/src/utilities/unify.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { nodeQuery, nodesQuery } from "./query";
+import { nodeAsString, nodesAsString } from "./string";
+
+const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+
+export function subproofNodeAsSubproofString(subproofNode, localContext) {
+  const tokens = localContext.getTokens(),
+        subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+        subproofSuppositionStatementsString = nodesAsString(subproofSuppositionStatementNodes, tokens),
+        subproofLastProofStepStatementString = nodeAsString(subproofLastProofStepStatementNode, tokens),
+        subproofString = `[${subproofSuppositionStatementsString}]...${subproofLastProofStepStatementString}`;
+
+  return subproofString;
+}

package/src/verifier/metaLevel.js

@@ -16,11 +16,7 @@ class MetaLevelVerifier extends Verifier {
     let verified;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext);
 
     verified = nonTerminalNodeVerified;  ///
 
@@ -30,25 +26,25 @@ class MetaLevelVerifier extends Verifier {
   static maps = [
     {
       nodeQuery: metavariableNodeQuery,
-      verify: (metavariableNode, localContext, verifyAhead) => {
-        const metavariableVerified = verifyMetavariable(metavariableNode, localContext, verifyAhead);
+      verify: (metavariableNode, localContext) => {
+        const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
         return metavariableVerified;
       }
     },
     {
       nodeQuery: variableNodeQuery,
-      verify: (variableNode, localContext, verifyAhead) => {
-        const variableVerified = verifyVariable(variableNode, localContext, verifyAhead);
+      verify: (variableNode, localContext) => {
+        const variableVerified = verifyVariable(variableNode, localContext);
 
         return variableVerified;
       }
     },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext, verifyAhead) => {
+      verify: (termNode, localContext) => {
         const terms = [],
-              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+              termVerified = verifyTerm(termNode, terms, localContext);
 
         return termVerified;
       }

package/src/verifier/statementAsCombinator.js

@@ -17,11 +17,7 @@ class StatementAsCombinatorVerifier extends Verifier {
 
     const nonTerminalNode = statementNode, ///
           childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext);
 
     statementVerifiedAsCombinator = childNodesVerified;  ///
 
@@ -29,41 +25,32 @@ class StatementAsCombinatorVerifier extends Verifier {
   }
 
   static maps = [
+    {
+      nodeQuery: statementNodeQuery,
+      verify: (statementNode, localContext) => {
+        const derived = false,
+              assignments = [],
+              statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+
+        return statementVerified;
+      }
+    },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext, verifyAhead) => {
+      verify: (termNode, localContext) => {
         const terms = [],
-              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+              termVerified = verifyTerm(termNode, terms, localContext);
 
         return termVerified;
       }
     },
     {
       nodeQuery: typeNodeQuery,
-      verify: (typeNode, localContext, verifyAhead) => {
-        const typeVerified = verifyType(typeNode, localContext, verifyAhead);
+      verify: (typeNode, localContext) => {
+        const typeVerified = verifyType(typeNode, localContext);
 
         return typeVerified;
       }
-    },
-    {
-      nodeQuery: statementNodeQuery,
-      verify: (statementNode, localContext, verifyAhead) => {
-        let statementVerified;
-
-        const derived = false,
-              assignments = [];
-
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
-
-        if (statementVerified) {
-          const verifiedAhead = verifyAhead();
-
-          statementVerified = verifiedAhead;  ///
-        }
-
-        return statementVerified;
-      }
     }
   ];
 }

package/src/verifier/topLevel.js

@@ -18,29 +18,25 @@ import verifyMetavariableDeclaration from "../verify/declaration/metavariable";
 import { nodeQuery } from "../utilities/query";
 
 const errorNodeQuery = nodeQuery("/error"),
-      ruleNodeQuery = nodeQuery("/rule!"),
-      axiomNodeQuery = nodeQuery("/axiom!"),
-      lemmaNodeQuery = nodeQuery("/lemma!"),
-      theoremNodeQuery = nodeQuery("/theorem!"),
-      metaLemmaNodeQuery = nodeQuery("/metaLemma!"),
-      conjectureNodeQuery = nodeQuery("/conjecture!"),
-      metatheoremNodeQuery = nodeQuery("/metatheorem!"),
-      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration!"),
-      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration!"),
-      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration!"),
-      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration!"),
-      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration!");
+      ruleNodeQuery = nodeQuery("/rule"),
+      axiomNodeQuery = nodeQuery("/axiom"),
+      lemmaNodeQuery = nodeQuery("/lemma"),
+      theoremNodeQuery = nodeQuery("/theorem"),
+      metaLemmaNodeQuery = nodeQuery("/metaLemma"),
+      conjectureNodeQuery = nodeQuery("/conjecture"),
+      metatheoremNodeQuery = nodeQuery("/metatheorem"),
+      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration"),
+      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
+      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration"),
+      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration"),
+      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration");
 
 class TopLevelVerifier extends Verifier {
   verify(node, fileContext) {
     let verified;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext);
 
     verified = nonTerminalNodeVerified;  ///
 

package/src/verifier.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
+import { isLastRemainingArgumentFunction } from "./utilities/arguments";
 
 const nonTerminalNodeQuery = nodeQuery("/*");
 
@@ -38,10 +39,23 @@ export default class Verifier {
   verifyChildNodes(childNodes, ...remainingArguments) {
     let childNodesVerify;
 
-    const index = 0,
-          childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
-    childNodesVerify = childNodesVerifyAhead; ///
+    if (lastRemainingArgumentFunction) {
+      const index = 0,
+            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+
+      childNodesVerify = childNodesVerifyAhead; ///
+    } else {
+      childNodesVerify = childNodes.every((childNode) => {
+        const node = childNode,
+              nodeVerified = this.verifyNode(node, ...remainingArguments);
+
+        if (nodeVerified) {
+          return true;
+        }
+      });
+    }
 
     return childNodesVerify;
   }
@@ -49,10 +63,18 @@ export default class Verifier {
   verifyTerminalNode(terminalNode, ...remainingArguments) {
     let terminalNodeVerified;
 
-    const verifyAhead = remainingArguments.pop(), ///
-          verifiedAhead = verifyAhead();  ///
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+
+    if (lastRemainingArgumentFunction) {
+      const verifyAhead = remainingArguments.pop(), ///
+            verifiedAhead = verifyAhead();
+
+      terminalNodeVerified = verifiedAhead; ///
 
-    terminalNodeVerified = verifiedAhead; ///
+      remainingArguments.push(verifyAhead);
+    } else {
+      terminalNodeVerified = true;
+    }
 
     return terminalNodeVerified;
   }

package/src/verify/assertion/type.js

@@ -77,9 +77,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
 
                   verifiedAhead = true;
 
-                  if (!verifiedAhead) {
-                    assignments.pop();
-                  }
+                  assignments.pop();
                 }
               }
             }
@@ -136,9 +134,7 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
 
                   verifiedAhead = true;
 
-                  if (!verifiedAhead) {
-                    assignments.pop();
-                  }
+                  assignments.pop();
                 }
               }
             }

package/src/verify/axiom.js

@@ -3,6 +3,7 @@
 import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -37,8 +38,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
       if (consequentVerified) {
         const firstConsequent = first(consequents),
+              substitutions = Substitutions.fromNothing(),
               consequent = firstConsequent, ///
-              substitutions = [],
               axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addAxiom(axiom);

package/src/verify/conjecture.js

@@ -4,6 +4,7 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -43,10 +44,12 @@ export default function verifyConjecture(conjectureNode, fileContext) {
               consequent = firstConsequent; ///
 
         if (proofNode !== null) {
-          verifyProof(proofNode, consequent, localContext);
+          const substitutions = Substitutions.fromNothing();
+
+          verifyProof(proofNode, consequent, substitutions, localContext);
         }
 
-        const substitutions = [],
+        const substitutions = Substitutions.fromNothing(),
               conjecture = Conjecture.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addConjecture(conjecture);

package/src/verify/declaration/metavariable.js

@@ -47,14 +47,14 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
     fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
     const termTypes = [],
-      metaTypes = [],
-      argumentNode = argumentNodeQuery(metavariableNode),
-      argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
-      metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
+          metaTypes = [],
+          argumentNode = argumentNodeQuery(metavariableNode),
+          argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
+          metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
 
     if (argumentVerified && metaTypeVerified) {
       let termType,
-        metaType;
+          metaType;
 
       const firstMetaType = first(metaTypes);
 
@@ -71,10 +71,10 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
       }
 
       const node = metavariableNode,  ///
-        name = nameFromMetavariableNode(metavariableNode),
-        metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
-        metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
-        metavariableAssigned = metavariableAssignment.assign(fileContext);
+            name = nameFromMetavariableNode(metavariableNode),
+            metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
+            metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+            metavariableAssigned = metavariableAssignment.assign(fileContext);
 
       if (metavariableAssigned) {
         metavariableVerified = true;

package/src/verify/equality.js

@@ -72,9 +72,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
 
                 verifiedAhead = verifyAhead();
 
-                if (!verifiedAhead) {
-                  assignments.pop();
-                }
+                assignments.pop();
               }
             }
 
@@ -123,9 +121,7 @@ function verifyStatedEquality(equalityNode, assignments, derived, localContext,
 
               verifiedAhead = verifyAhead();
 
-              if (!verifiedAhead) {
-                assignments.pop();
-              }
+              assignments.pop();
             }
 
             return verifiedAhead;

package/src/verify/lemma.js

@@ -4,6 +4,7 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,11 +46,11 @@ export default function verifyLemma(lemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);

package/src/verify/metaLemma.js

@@ -4,6 +4,7 @@ import MetaLemma from "../metaLemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,7 +46,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {

package/src/verify/metatheorem.js

@@ -4,6 +4,7 @@ import verifyProof from "../verify/proof";
 import Metatheorem from "../metatheorem";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -41,7 +42,7 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         const proofNode = proofNodeQuery(metatheoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               statementNode = consequent.getStatementNode(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);