occam-verify-cli 0.0.679 → 0.0.680

package/src/equality.js

@@ -1,14 +1,10 @@
 "use strict";
 
-import verifyTerm from "./verify/term";
-import NodesVerifier from "./verifier/nodes";
 import equalityStatementNode from "./node/statement/equality";
+import equalityNodesVerifier from "./verifier/nodes/equality";
 
 import { nodeQuery } from "./utilities/query";
-import { first, second } from "./utilities/array";
-import { TERM_RULE_NAME } from "./ruleNames";
 import { EQUALITY_DEPTH } from "./constants";
-import { verifyTermAsVariable } from "./verify/term";
 
 const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
@@ -78,10 +74,10 @@ export default class Equality {
     return matches;
   }
 
-  verify(equalities, context) {
+  verify(equalities, context, verifyAhead) {
     const leftNonTerminalNode = this.leftTermNode,  ///
           rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context),
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context, verifyAhead),
           verified = nonTerminalNodeVerified; ///
 
     return verified;
@@ -93,157 +89,35 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const depth = EQUALITY_DEPTH,
-            statementNodeMatchesEqualityStatementNode = statementNode.match(equalityStatementNode, depth);
-
-      if (statementNodeMatchesEqualityStatementNode) {
-        const leftTermNode = leftTermNodeQuery(statementNode),
-              rightTermNode = rightTermNodeQuery(statementNode);
-
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
+      equality = Equality.fromStatementNode(statementNode);
     }
 
     return equality;
   }
 
   static fromStatementNode(statementNode) {
-    const leftTermNode = leftTermNodeQuery(statementNode),
-          rightTermNode = rightTermNodeQuery(statementNode),
-          equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-}
-
-class EqualityNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context) {
-    let nonTerminalNodeVerified = false;
-
-    const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
-          rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
-
-    if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
-      const ruleName = leftNonTerminalNodeRuleName, ///
-            ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
-
-      if (ruleNameTermRuleName) {
-        const leftTermNode = leftNonTerminalNode, ///
-              rightTermNode = rightNonTerminalNode, ///
-              termNodeVerified = this.verifyTermNode(leftTermNode, rightTermNode, equalities, context);
+    let equality = null;
 
-        nonTerminalNodeVerified = termNodeVerified;  ///
-      }
+    const depth = EQUALITY_DEPTH,
+          statementNodeMatchesEqualityStatementNode = statementNode.match(equalityStatementNode, depth);
 
-      if (!nonTerminalNodeVerified) {
-        const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-              rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-              leftChildNodes = leftNonTerminalNodeChildNodes, ///
-              rightChildNodes = rightNonTerminalNodeChildNodes, ///
-              childNodesVerified = this.verifyChildNodes(leftChildNodes, rightChildNodes, equalities, context);
+    if (statementNodeMatchesEqualityStatementNode) {
+      const leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode);
 
-        nonTerminalNodeVerified = childNodesVerified; ///
-      }
+      equality = new Equality(leftTermNode, rightTermNode);
     }
 
-    return nonTerminalNodeVerified;
+    return equality;
   }
 
-  verifyTermNode(leftTermNode, rightTermNode, equalities, context) {
-    let termNodeVerified = false;
-
-    const variables = [],
-          leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
-          rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
-
-    let equality = null;
-
-    if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
-      const firstVariable = first(variables),
-            secondVariable = second(variables),
-            leftVariable = firstVariable, ///
-            rightVariable = secondVariable, ///
-            leftVariableType = leftVariable.getType(),
-            rightVariableType = rightVariable.getType(),
-            leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
-
-      if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else if (leftTermVerifiedAsVariable) {
-      const types = [];
-
-      verifyTerm(rightTermNode, types, context);
-
-      const firstType = first(types),
-            firstVariable = first(variables),
-            leftVariable = firstVariable, ///
-            rightTermType = firstType,  ///
-            leftVariableType = leftVariable.getType(),
-            leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
-
-      if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else if (rightTermVerifiedAsVariable) {
-      const types = [];
-
-      verifyTerm(leftTermNode, types, context);
-
-      const firstType = first(types),
-            firstVariable = first(variables),
-            leftTermType = firstType,  ///
-            rightVariable = firstVariable, ///
-            rightVariableType = rightVariable.getType(),
-            rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
-
-      if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else {
-      const types = [];
-
-      verifyTerm(leftTermNode, types, context);
-
-      verifyTerm(rightTermNode, types, context);
-
-      const firstType = first(types),
-            secondType = second(types),
-            leftTermType = firstType, ///
-            rightTermType = secondType, ///
-            leftTermTypeEqualToOrSubTypeOfOfSuperTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOfOfSuperTypeOf(rightTermType);
-
-      if (leftTermTypeEqualToOrSubTypeOfOfSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    }
-
-    if (equality !== null) {
-      const equalityA = equality, ///
-            equalitiesB = equalities, ///
-            equalityMatches = equalitiesB.some((equalityB) => { ///
-              const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
-
-              if (equalityAMatchesEqualityB) {
-                return true;
-              }
-            });
-
-      termNodeVerified = equalityMatches;  ///
-    }
+  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
+    const equality = new Equality(leftTermNode, rightTermNode);
 
-    return termNodeVerified;
+    return equality;
   }
 }
 
-const equalityNodesVerifier = new EqualityNodesVerifier();
-
 function filterEqualities(equalities, equality) {
   const equalityA = equality; ///
 

package/src/premise.js

@@ -46,7 +46,11 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
                 proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
+                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -63,7 +67,11 @@ export default class Premise {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB),
+          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
@@ -92,7 +100,11 @@ export default class Premise {
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
                 metaproofContextB = metastatementMetaproofContext,  ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -109,7 +121,11 @@ export default class Premise {
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
           metaproofContextB = metastatementMetaproofContext,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB),
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           metastatementNodeMatches = nonTerminalNodeVerified; ///
 
     return metastatementNodeMatches;

package/src/supposition.js

@@ -43,7 +43,11 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 proofContextA = proofContext, ///
                 proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -60,7 +64,11 @@ export default class Supposition {
           nonTerminalNodeB = statementNode,  ///
           proofContextA = proofContext, ///
           proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB),
+          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, filter } = arrayUtilities;
+export const { first, second, last, push, prune, filter, clear } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/verifier/node/metastatement.js

@@ -6,7 +6,7 @@ import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
 import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 class MetastatementNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, metaproofContext) {
+  verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName(); ///
@@ -14,7 +14,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
     switch (ruleName) {
       case METAVARIABLE_RULE_NAME: {
         const metavariableNode = nonTerminalNode, ///
-              metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext),
+              metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext, verifyAhead),
               metavariableNodeVerified = metavariableVerified;  ///
 
         nonTerminalNodeVerified = metavariableNodeVerified; ///
@@ -23,7 +23,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, metaproofContext);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead);
 
         break;
       }
@@ -37,7 +37,7 @@ const metastatementNodeVerifier = new MetastatementNodeVerifier();
 
 export default metastatementNodeVerifier;
 
-function verifyMetavariable(metavariableNode, metaproofContext) {
+function verifyMetavariable(metavariableNode, metaproofContext, verifyAhead) {
   let metavariableVerified;
 
   const metavariableString = metaproofContext.nodeAsString(metavariableNode);
@@ -47,7 +47,11 @@ function verifyMetavariable(metavariableNode, metaproofContext) {
   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
         metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
 
-  metavariableVerified = metavariablePresent;
+  if (metavariablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    metavariableVerified = verifiedAhead; ///
+  }
 
   if (metavariableVerified) {
     metaproofContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);

package/src/verifier/node/termAsConstructor.js

@@ -82,7 +82,7 @@ export function verifyType(typeNode, fileContext, verifyAhead) {
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    fileContext.info(`The type '${typeName}' is not present.`, typeNode);
+    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
   } else {
     fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
 

package/src/verifier/nodes/equality.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import Equality from "../../equality";
+import verifyTerms from "../../verify/terms";
+import NodesVerifier from "../../verifier/nodes";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
+          rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
+
+    if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
+      const leftNonTerminalNodeRuleNameTermRuleName = (leftNonTerminalNodeRuleName === TERM_RULE_NAME),
+            rightNonTerminalNodeRuleNameTermRuleName = (rightNonTerminalNodeRuleName === TERM_RULE_NAME);
+
+      if (leftNonTerminalNodeRuleNameTermRuleName && rightNonTerminalNodeRuleNameTermRuleName) {
+        const leftTermNode = leftNonTerminalNode, ///
+              rightTermNode = rightNonTerminalNode, ///
+              termNodeVerified = this.verifyTermNode(leftTermNode, rightTermNode, equalities, context, verifyAhead);
+
+        nonTerminalNodeVerified = termNodeVerified;  ///
+      }
+
+      if (!nonTerminalNodeVerified) {
+        const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+              rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+              leftChildNodes = leftNonTerminalNodeChildNodes, ///
+              rightChildNodes = rightNonTerminalNodeChildNodes, ///
+              childNodesVerified = this.verifyChildNodes(leftChildNodes, rightChildNodes, equalities, context, verifyAhead);
+
+        nonTerminalNodeVerified = childNodesVerified; ///
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyTermNode(leftTermNode, rightTermNode, equalities, context, verifyAhead) {
+    let termNodeVerified = false;
+
+    const termsVerified = verifyTerms(leftTermNode, rightTermNode, context, verifyAhead);
+
+    if (termsVerified) {
+      const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+            equalityA = equality, ///
+            equalitiesB = equalities, ///
+            equalityMatches = equalitiesB.some((equalityB) => { ///
+              const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
+
+              if (equalityAMatchesEqualityB) {
+                return true;
+              }
+            });
+
+      termNodeVerified = equalityMatches;  ///
+    }
+
+    return termNodeVerified;
+  }
+}
+
+const equalityNodesVerifier = new EqualityNodesVerifier();
+
+export default equalityNodesVerifier;

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -10,7 +10,7 @@ import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
 export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -23,28 +23,28 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
+              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
 
         if (metastatementNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let metastatementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
     }
@@ -52,7 +52,7 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
     return metastatementNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
+  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),

package/src/verifier/nodes/statement.js

@@ -71,21 +71,23 @@ function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, contex
         combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
   if (statementNode === null) {
-    context.info(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+    context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
   } else {
     if (combinatorMetaTYpeNode === null) {
       const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
-      context.info(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+      context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
     } else {
       const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
             content = combinatorMetaTypeTerminalNode.getContent(),
             contentStatementMetaType = (content === STATEMENT_META_TYPE);
 
       if (!contentStatementMetaType) {
-        context.info(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+        context.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
       } else {
-        metaArgumentVerified = true;
+        const verifiedAhead = verifyAhead();
+
+        metaArgumentVerified = verifiedAhead; ///
       }
     }
   }

package/src/verifier/nodes/term.js

@@ -55,7 +55,7 @@ export function verifyArgument(argumentNode, constructorArgumentNode, context, v
   const typeNode = typeNodeQuery(argumentNode);
 
   if (typeNode !== null) {
-    context.info(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
+    context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
   } else {
     const termNode = termNodeQuery(argumentNode);
 
@@ -83,15 +83,10 @@ export function verifyArgument(argumentNode, constructorArgumentNode, context, v
                 const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
                       firstType = first(types),
                       termType = firstType, ///
-                      termTypeName = termType.getName(),
                       constructorType = context.findTypeByTypeName(constructorTypeName),
                       termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 
                 if (termTypeEqualToOrSubTypeOfType) {
-                  const termString = context.nodeAsString(termNode);
-
-                  context.trace(`The '${termTypeName}' type of the '${termString}' term is equal to or a sub-type of the '${constructorTypeName}' type in the constructor.`, argumentNode);
-
                   verifiedAhead = verifyAhead();
                 }
 

package/src/verifier/nodes/termForVariable.js

@@ -12,7 +12,7 @@ import { variableNameFromVariableNode } from "../../utilities/query";
 const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -25,28 +25,28 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
 
         if (termNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
+  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
     let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
 
       termNodeVerified = variableVerified; ///
     }
@@ -54,8 +54,8 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
-    let variableVerified;
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
+    let variableVerified = false;
 
     const variableNameA = variableNameFromVariableNode(variableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -70,7 +70,11 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
       const termNode = termNodeB, ///
             substitutionNodesVerified = substitution.matchTermNode(termNode);
 
-      variableVerified = substitutionNodesVerified;  ///
+      if (substitutionNodesVerified) {
+        const verifiedAhead = verifyAhead();
+
+        variableVerified = verifiedAhead;  ///
+      }
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -83,23 +87,31 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
           const types = [],
                 context = proofContextB, ///
                 termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, types, context, verifyAhead);
+                termVerified = verifyTerm(termNode, types, context, () => {
+                  let verifiedAhead = false;
 
-          if (termVerified) {
-            const firstType = first(types),
-                  termType = firstType,
-                  variableType = variable.getType(),
-                  variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                  const firstType = first(types),
+                        termType = firstType,
+                        variableType = variable.getType(),
+                        variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
-            if (variableTypeEqualToOrSuperTypeOfTermType) {
-              const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
-                    substitution = termForVariableSubstitution;  ///
+                  if (variableTypeEqualToOrSuperTypeOfTermType) {
+                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                          substitution = termForVariableSubstitution;  ///
 
-              substitutions.push(substitution);
+                    substitutions.push(substitution);
 
-              variableVerified = true;
-            }
-          }
+                    verifiedAhead = verifyAhead();
+
+                    if (!verifiedAhead) {
+                      substitutions.pop();
+                    }
+                  }
+
+                  return verifiedAhead;
+                });
+
+          variableVerified = termVerified;  ///
         }
       }
     }

package/src/verify/file.js

@@ -23,7 +23,7 @@ export default function verifyFile(filePath, releaseContext) {
           errorNodesLength = errorNodes.length;
 
     if (errorNodesLength > 0) {
-      releaseContext.info(`The '${filePath}' file cannot be verified because it contains errors.`);
+      releaseContext.warning(`The '${filePath}' file cannot be verified because it contains errors.`);
     } else {
       const topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
             topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {

package/src/verify/label.js

@@ -17,7 +17,7 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   if (labelPresent) {
     const labelString = fileContext.nodeAsString(labelNode);
 
-    fileContext.info(`The '${labelString}' label is already present.`, labelNode);
+    fileContext.debug(`The '${labelString}' label is already present.`, labelNode);
   } else {
     const label = Label.fromLabelNode(labelNode);