occam-verify-cli 0.0.942 → 0.0.944

package/src/unify/variableAgainstTerm.js

@@ -1,14 +1,12 @@
 "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.findSubstitution((substitution) => {
@@ -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.addSubstitution(substitution);
-
-                  verifiedAhead = verifyAhead();
-
-                  if (!verifiedAhead) {
-                    substitutions.removeSubstitution(substitution);
-                  }
-                }
-              }
-
-              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 = [ ///

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/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

@@ -4,13 +4,11 @@ import Equality from "../equality";
 import verifyTerms from "../verify/terms";
 import EqualityAssignment from "../assignment/equality";
 
-import { nodeQuery } from "../utilities/query";
-import { first, second } from "../utilities/array";
+import { nodesQuery } from "../utilities/query";
 
-const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
+const termNodesQuery = nodesQuery("/equality/term");
 
-export default function verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
+export default function verifyEquality(equalityNode, assignments, derived, localContext) {
   let equalityVerified;
 
   const equalityString = localContext.nodeAsString(equalityNode);
@@ -23,7 +21,7 @@ export default function verifyEquality(equalityNode, assignments, derived, local
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
-    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext, verifyAhead);
+    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext);
 
     if (equalityVerified) {
       return true;
@@ -37,7 +35,7 @@ export default function verifyEquality(equalityNode, assignments, derived, local
   return equalityVerified;
 }
 
-function verifyDerivedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
+function verifyDerivedEquality(equalityNode, assignments, derived, localContext) {
   let derivedEqualityVerified = false;
 
   if (derived) {
@@ -46,20 +44,11 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
     localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
 
     const terms = [],
-          leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
-          termNodes = [
-            leftTermNode,
-            rightTermNode
-          ],
+          termNodes = termNodesQuery(equalityNode),
           termsVerified = verifyTerms(termNodes, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  secondTerm = second(terms),
-                  leftTerm = firstTerm, ///
-                  rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
+            const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
 
             if (equality !== null) {
               const equalityEqual = equality.isEqual(localContext);
@@ -70,11 +59,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
 
                 assignments.push(assignment);
 
-                verifiedAhead = verifyAhead();
-
-                if (!verifiedAhead) {
-                  assignments.pop();
-                }
+                verifiedAhead = true;
               }
             }
 
@@ -91,7 +76,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
   return derivedEqualityVerified;
 }
 
-function verifyStatedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatedEquality(equalityNode, assignments, derived, localContext) {
   let statedEqualityVerified = false;
 
   if (!derived) {
@@ -100,20 +85,11 @@ function verifyStatedEquality(equalityNode, assignments, derived, localContext,
     localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
 
     const terms = [],
-          leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
-          termNodes = [
-            leftTermNode,
-            rightTermNode
-          ],
+          termNodes = termNodesQuery(equalityNode),
           termsVerified = verifyTerms(termNodes, terms, localContext, () => {
             let verifiedAhead = false;
 
-            const firstTerm = first(terms),
-                  secondTerm = second(terms),
-                  leftTerm = firstTerm, ///
-                  rightTerm = secondTerm, ///
-                  equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
+            const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
 
             if (equality !== null) {
               const equalityAssignment = EqualityAssignment.fromEquality(equality),
@@ -121,11 +97,7 @@ function verifyStatedEquality(equalityNode, assignments, derived, localContext,
 
               assignments.push(assignment);
 
-              verifiedAhead = verifyAhead();
-
-              if (!verifiedAhead) {
-                assignments.pop();
-              }
+              verifiedAhead = true;
             }
 
             return verifiedAhead;