occam-verify-cli 0.0.526 → 0.0.529

package/src/verifier/termForVariable/supposition.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableVerifier from "../../verifier/termForVariable";
+
+class SuppositionTermForVariableVerifier extends TermForVariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const suppositionTermForVariableVerifier = new SuppositionTermForVariableVerifier();

package/src/verifier/termForVariable.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import Verifier from "../verifier";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+
+import { nodeQuery } from "../utilities/query";
+import { TERM_RULE_NAME } from "../ruleNames";
+import { variableNameFromVariableNode } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery('/term/variable!');
+
+export default class TermForVariableVerifier extends Verifier {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      const nonTerminalNodeARuleNameTermRuleName = (nonTerminalNodeARuleName === TERM_RULE_NAME),
+            nonTerminalNodeBRuleNameTermRuleName = (nonTerminalNodeBRuleName === TERM_RULE_NAME);
+
+      if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
+        const termNodeA = nonTerminalNodeA,  ///
+              termNodeB = nonTerminalNodeB,  ///
+              termNodeMatches = this.matchTermNode(termNodeA, termNodeB, substitutions);
+
+        if (termNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        }
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchTermNode(termNodeA, termNodeB, substitutions) {
+    let termNodeMatches = false;
+
+    const variableNodeA = variableNodeQuery(termNodeA);
+
+    if (variableNodeA !== null) {
+      const variableMatches = this.matchVariableNode(variableNodeA, termNodeB, substitutions);
+
+      termNodeMatches = variableMatches; ///
+    }
+
+    return termNodeMatches;
+  }
+
+  matchVariableNode(variableNodeB, termNodeB, substitutions) {
+    let variableMatches;
+
+    const variableNameA = variableNameFromVariableNode(variableNodeB),
+          substitution = substitutions.find((substitution) => {
+            const variableName = substitution.getVariableName();
+
+            if (variableName === variableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const termNode = termNodeB, ///
+            substitutionNodesMatch = substitution.matchTermNode(termNode);
+
+      variableMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const variableName = variableNameA, ///
+              termNode = termNodeB, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      variableMatches = true;
+    }
+
+    return variableMatches;
+  }
+}

package/src/verifier.js

@@ -0,0 +1,74 @@
+"use strict";
+
+export default class Verifier {
+  matchNode(nodeA, nodeB, substitutions) {
+    let nodeMatches = false;
+
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode();
+
+    if (nodeATerminalNode === nodeBTerminalNode) {
+      if (nodeATerminalNode) {
+        const terminalNodeA = nodeA,  ///
+              terminalNodeB = nodeB,  ///
+              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB);
+
+        nodeMatches = terminalNodeMatches;  ///
+      } else {
+        const nonTerminalNodeA = nodeA,  ///
+              nonTerminalNodeB = nodeB, ///
+              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+
+        nodeMatches = nonTerminalNodeMatches; ///
+      }
+    }
+
+    return nodeMatches;
+  }
+
+  matchNodes(nodesA, nodesB, substitutions) {
+    let nodesMatch = false;
+
+    const nodesALength = nodesA.length,
+          nodesBLength = nodesB.length;
+
+    if (nodesALength === nodesBLength) {
+      nodesMatch = nodesA.every((nodeA, index) => {
+        const nodeB = nodesB[index],
+              nodeMatches = this.matchNode(nodeA, nodeB, substitutions);
+
+        if (nodeMatches) {
+          return true;
+        }
+      })
+    }
+
+    return nodesMatch;
+  }
+
+  matchTerminalNode(terminalNodeA, terminalNodeB, substitutions) {
+    const matches = terminalNodeA.match(terminalNodeB),
+          terminalNodeMatches = matches;  ///
+
+    return terminalNodeMatches;
+  }
+
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            nodesA = nonTerminalNodeAChildNodes, ///
+            nodesB = nonTerminalNodeBChildNodes, ///
+            nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+
+      nonTerminalNodeMatches = nodesMatch; ///
+    }
+
+    return nonTerminalNodeMatches;
+  }
+}

package/src/verify/assertion/type.js

@@ -1,56 +1,50 @@
 "use strict";
 
+import Variable from "../../variable";
 import TypeAssertion from "../../assertion/type";
 
 import { first } from "../../utilities/array";
-import { nodeAsString } from "../../utilities/string";
+import { verifyTermAsVariable } from "../../verify/term";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, assertions, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let typeAssertionVerified = false;
 
-  proofContext.begin(typeAssertionNode);
-
   const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
+  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
         typePresent = proofContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`);
+    proofContext.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
-    if (!typeAssertionVerified) {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
-
-      typeAssertionVerified = termTypeAssertionVerified;  ///
-    }
+    // if (!typeAssertionVerified) {
+    //   const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
+    //
+    //   typeAssertionVerified = termTypeAssertionVerified;  ///
+    // }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`);
+    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
-  typeAssertionVerified ?
-    proofContext.complete(typeAssertionNode) :
-      proofContext.halt(typeAssertionNode);
-
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let variableTypeAssertionVerified = false;
 
   const context = proofContext, ///
@@ -59,27 +53,39 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
   if (termVerifiedAsVariable) {
-    if (assertions === null) {
-      variableTypeAssertionVerified = true;
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+          firstVariable = first(variables),
+          variable = firstVariable, ///
+          variableName = variable.getName(),
+          variableType = variable.getType();
+
+    if (derived) {
+      const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+
+      if (!variableTypeEqualToOrSubTypeOfAssertedType) {
+        const assertedTypeName = assertedType.getName(),
+              variableTypeName = variableType.getName();
+
+        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
+      } else {
+        variableTypeAssertionVerified = true;
+      }
     } else {
-      const typeNode = typeNodeQuery(typeAssertionNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            assertedTypeName = typeName,  ///
-            assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-            firstVariable = first(variables),
-            variable = firstVariable, ///
-            variableName = variable.getName(),
-            variableType = variable.getType(),
-            assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+      const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
       if (!assertedTypeEqualToOrSubTypeOfVariableType) {
         const assertedTypeName = assertedType.getName(),
               variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`);
+        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
       } else {
         const type = assertedType,  ///
-              typeAssertion = TypeAssertion.fromTypeAndVariableName(type, variableName),
+              name = variableName,  ///
+              variable = Variable.fromTypeAndName(type, name),
+              typeAssertion = TypeAssertion.fromVariable(variable),
               assertion = typeAssertion;  ///
 
         assertions.push(assertion);
@@ -92,46 +98,40 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
   return variableTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
-  let termTypeAssertionVerified = false;
-
-  const types = [],
-        context = proofContext, ///
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-
-  if (termVerifiedAgainstConstructors) {
-    if (assertions === null) {
-      termTypeAssertionVerified = true;
-    } else {
-      const typeNode = typeNodeQuery(typeAssertionNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            assertedTypeName = typeName,  ///
-            assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-            firstType = first(types),
-            termType = firstType,
-            termString = proofContext.nodeAsString(termNode),
-            assertedTypeEqualToTermType = (termType === null) ?
-                                             true : ///
-                                               assertedType.isEqualTo(termType);
-
-      if (!assertedTypeEqualToTermType) {
-        const termTypeName = termType.getName(),
-              assertedTypeName = assertedType.getName();
-
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`);
-      } else {
-        const type = assertedType,  ///
-              typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
-              assertion = typeAssertion;  ///
-
-        assertions.push(assertion);
-
-        termTypeAssertionVerified = true;
-      }
-    }
-  }
-
-  return termTypeAssertionVerified;
-}
+// function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
+//   let termTypeAssertionVerified = false;
+//
+//   const types = [],
+//         context = proofContext, ///
+//         termNode = termNodeQuery(typeAssertionNode),
+//         termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+//
+//   if (termVerifiedAgainstConstructors) {
+//     const typeNode = typeNodeQuery(typeAssertionNode),
+//           typeName = typeNameFromTypeNode(typeNode),
+//           assertedTypeName = typeName,  ///
+//           assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+//           firstType = first(types),
+//           termType = firstType,
+//           termString = proofContext.nodeAsString(termNode),
+//           termTypeEqualToOrSubTypeOfAssertedType = termType.isEqualToOrSubTypeOf(assertedType);
+//
+//     if (!termTypeEqualToOrSubTypeOfAssertedType) {
+//       const termTypeName = termType.getName(),
+//             assertedTypeName = assertedType.getName();
+//
+//       proofContext.error(`The '${termString}' term's '${termTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
+//     } else {
+//       const type = assertedType,  ///
+//             typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
+//             assertion = typeAssertion;  ///
+//
+//       assertions.push(assertion);
+//
+//       termTypeAssertionVerified = true;
+//     }
+//   }
+//
+//   return termTypeAssertionVerified;
+// }
 

package/src/verify/axiom.js

@@ -7,7 +7,6 @@ import verifySupposition from "../verify/supposition";
 import verifyConsequence from "../verify/consequence";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
@@ -17,13 +16,11 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  fileContext.begin(axiomNode);
-
   const labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' axiom...`);
+  fileContext.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -57,12 +54,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
   }
 
   if (axiomVerified) {
-    fileContext.info(`Verified the '${labelsString}' axiom.`);
+    fileContext.info(`Verified the '${labelsString}' axiom.`, axiomNode);
   }
 
-  axiomVerified ?
-    fileContext.complete(axiomNode) :
-      fileContext.complete(axiomNode);
-
   return axiomVerified;
 }

package/src/verify/conclusion.js

@@ -11,11 +11,9 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
   let conclusionVerified = false;
 
-  metaproofContext.begin(conclusionNode);
-
   const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
-  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`);
+  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
         assertions = [],
@@ -31,9 +29,5 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
     conclusionVerified = true;
   }
 
-  conclusionVerified ?
-    metaproofContext.complete(conclusionNode) :
-      metaproofContext.halt(conclusionNode);
-
   return conclusionVerified;
 }

package/src/verify/conjecture.js

@@ -0,0 +1,67 @@
+"use strict";
+
+import Conjecture from "../conjecture";
+import verifyProof from "../verify/proof";
+import ProofContext from "../context/proof";
+import verifyLabels from "../verify/labels";
+import verifySupposition from "./supposition";
+import verifyConsequence from "./consequence";
+
+import { first } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const proofNodeQuery = nodeQuery("/conjecture/proof!"),
+      labelNodesQuery = nodesQuery("/conjecture/label"),
+      consequenceNodeQuery = nodeQuery("/conjecture/consequence!"),
+      suppositionsNodeQuery = nodesQuery("/conjecture/supposition");
+
+export default function verifyConjecture(conjectureNode, fileContext) {
+  let conjectureVerified = false;
+
+  const labelNodes = labelNodesQuery(conjectureNode),
+        labelsString = fileContext.nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext);
+
+  fileContext.debug(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
+
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+
+  if (labelsVerified) {
+    const suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(conjectureNode),
+          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+
+            if (suppositionVerified) {
+              return true;
+            }
+          });
+
+    if (suppositionsVerified) {
+      const consequences = [],
+            consequenceNode = consequenceNodeQuery(conjectureNode),
+            consequenceVerified = verifyConsequence(consequenceNode, consequences, proofContext);
+
+      if (consequenceVerified) {
+        const proofNode = proofNodeQuery(conjectureNode),
+              firstConsequence = first(consequences),
+              consequence = firstConsequence; ///
+
+        verifyProof(proofNode, consequence, proofContext);
+
+        const conjecture = Conjecture.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+
+        fileContext.addConjecture(conjecture);
+
+        conjectureVerified = true;
+      }
+    }
+  }
+
+  if (conjectureVerified) {
+    fileContext.info(`Verified the '${labelsString}' conjecture.`, conjectureNode);
+  }
+
+  return conjectureVerified;
+}

package/src/verify/consequence.js

@@ -11,11 +11,9 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
 export default function verifyConsequence(consequenceNode, consequences, proofContext) {
   let consequenceVerified = false;
 
-  proofContext.begin(consequenceNode);
-
   const consequenceString = proofContext.nodeAsString(consequenceNode);
 
-  proofContext.debug(`Verifying the '${consequenceString}' consequence...`);
+  proofContext.debug(`Verifying the '${consequenceString}' consequence...`, consequenceNode);
 
   const derived = false,
         assertions = [],
@@ -31,9 +29,5 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
     consequenceVerified = true;
   }
 
-  consequenceVerified ?
-    proofContext.complete(consequenceNode) :
-      proofContext.halt(consequenceNode);
-
   return consequenceVerified;
 }

package/src/verify/declaration/combinator.js

@@ -9,16 +9,10 @@ const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 export default function verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext) {
   let combinatorDeclarationVerified;
 
-  fileContext.begin(combinatorDeclarationNode);
-
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
         statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
 
   combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
 
-  combinatorDeclarationVerified ?
-    fileContext.complete(combinatorDeclarationNode) :
-      fileContext.halt(combinatorDeclarationNode);
-
   return combinatorDeclarationVerified;
 }

package/src/verify/declaration/constructor.js

@@ -10,17 +10,11 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
 export default function verifyConstructorDeclaration(constructorDeclarationNode, fileContext) {
   let constructorDeclarationVerified;
 
-  fileContext.begin(constructorDeclarationNode);
-
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
         termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
 
   constructorDeclarationVerified = termVerifiedAsConstructor; ///
 
-  constructorDeclarationVerified ?
-    fileContext.complete(constructorDeclarationNode) :
-      fileContext.halt(constructorDeclarationNode);
-
   return constructorDeclarationVerified;
 }

package/src/verify/declaration/topLevel.js

@@ -4,6 +4,7 @@ import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyLemma from "../../verify/lemma";
 import verifyTheorem from "../../verify/theorem";
+import verifyConjecture from "../../verify/conjecture";
 import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
@@ -15,6 +16,7 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       lemmaNodeQuery = nodeQuery("/topLevelDeclaration/lemma!"),
       theoremNodeQuery = nodeQuery("/topLevelDeclaration/theorem!"),
+      conjectureNodeQuery = nodeQuery("/topLevelDeclaration/conjecture!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
@@ -23,13 +25,12 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
 export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
 
-  fileContext.begin(topLevelDeclarationNode);
-
   const node = topLevelDeclarationNode, ///
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
         lemmaNode = lemmaNodeQuery(node),
         theoremNode = theoremNodeQuery(node),
+        conjectureNode = conjectureNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -53,6 +54,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const theoremVerified = verifyTheorem(theoremNode, fileContext);
 
     topLevelDeclarationVerified = theoremVerified;  ///
+  } else if (conjectureNode !== null) {
+    const conjectureVerified = verifyConjecture(conjectureNode, fileContext);
+
+    topLevelDeclarationVerified = conjectureVerified;  ///
   } else if (typeDeclarationNode !== null) {
     const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 
@@ -71,9 +76,5 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
   }
 
-  topLevelDeclarationVerified ?
-    fileContext.complete(topLevelDeclarationNode) :
-      fileContext.halt(topLevelDeclarationNode);
-
   return topLevelDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -10,8 +10,6 @@ const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
 export default function verifyTypeDeclaration(typeDeclarationNode, fileContext) {
   let typeDeclarationVerified;
 
-  fileContext.begin(typeDeclarationNode);
-
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
@@ -21,9 +19,5 @@ export default function verifyTypeDeclaration(typeDeclarationNode, fileContext)
 
   typeDeclarationVerified = typeVerified; ///
 
-  typeDeclarationVerified ?
-    fileContext.complete(typeDeclarationNode) :
-      fileContext.halt(typeDeclarationNode);
-
   return typeDeclarationVerified;
 }

package/src/verify/declaration/variable.js

@@ -10,17 +10,11 @@ const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
 export default function verifyVariableDeclaration(variableDeclarationNode, fileContext) {
   let variableDeclarationVerified;
 
-  fileContext.begin(variableDeclarationNode);
-
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
         variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
 
   variableDeclarationVerified = variableVVerified;  ///
 
-  variableDeclarationVerified ?
-    fileContext.complete(variableDeclarationNode) :
-      fileContext.halt(variableDeclarationNode);
-
   return variableDeclarationVerified;
 }