occam-verify-cli 0.0.501 → 0.0.503

package/src/supposition.js

@@ -0,0 +1,235 @@
+"use strict";
+
+import Substitution from "./substitution";
+
+import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { variableNameFromVariableNode } from "./utilities/query";
+import { statementNodeFromStatementString } from "./utilities/string";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+
+const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement/statement!"),
+      qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
+
+export default class Supposition {
+  constructor(statementNode) {
+    this.statementNode = statementNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  matchSubproofNode(subproofNode, substitutions) {
+    let subproofNodeMatches = false;
+
+    const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
+
+    if (subproofAssertionNode !== null) {
+      const subproofAssertionStatementNodes = statementNodesQuery(subproofAssertionNode),
+            unqualifiedStatementStatementNodes = unqualifiedStatementStatementNodesQuery(subproofNode),
+            qualifiedOrUnqualifiedStatementStatementNode = qualifiedOrUnqualifiedStatementStatementNodeQuery(subproofNode),
+            statementNodes = [
+              ...unqualifiedStatementStatementNodes,
+              qualifiedOrUnqualifiedStatementStatementNode
+            ],
+            statementNodesLength = statementNodes.length,
+            subproofAssertionStatementNodesLength = subproofAssertionStatementNodes.length;
+
+      if (statementNodesLength === subproofAssertionStatementNodesLength) {
+        subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
+                                    const statementNode = statementNodes[index],
+                                          nonTerminalNode = statementNode, ///
+                                          suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
+                                          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+
+                                    if (suppositionNonTerminalNodeMatches) {
+                                      return true;
+                                    }
+                                  });
+      }
+    }
+
+    return subproofNodeMatches;
+  }
+
+  matchStatementNode(statementNode, substitutions) {
+    const nonTerminalNode = statementNode,  ///
+          suppositionNonTerminalNode = this.statementNode,  ///
+          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = suppositionNonTerminalNodeMatches; ///
+
+    return statementNodeMatches;
+  }
+
+  toJSON() {
+    const statementString = nodeAsString(this.statementNode),
+          statement = statementString, ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    const { statement } = json,
+          statementString = statement,  ///
+          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          supposition = new Supposition(statementNode);
+
+    return supposition;
+  }
+
+  static fromStatementNode(statementNode) {
+    const supposition = new Supposition(statementNode);
+
+    return supposition;
+  }
+}
+
+function matchSuppositionNode(suppositionNode, node, substitutions) {
+  let suppositionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = suppositionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            suppositionTerminalNode = suppositionNode,  ///
+            suppositionTerminalNodeMatches = matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions);
+
+      suppositionNodeMatches = suppositionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            suppositionNonTerminalNode = suppositionNode,  ///
+            suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+
+      suppositionNodeMatches = suppositionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return suppositionNodeMatches;
+}
+
+function matchSuppositionNodes(suppositionNodes, nodes, substitutions) {
+  let suppositionNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        suppositionNodesLength = suppositionNodes.length;
+
+  if (nodesLength === suppositionNodesLength) {
+    suppositionNodesMatches = nodes.every((node, index) => {
+      const suppositionNode = suppositionNodes[index],
+            suppositionNodeMatches = matchSuppositionNode(suppositionNode, node, substitutions);
+
+      if (suppositionNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return suppositionNodesMatches;
+}
+
+function matchSuppositionVariable(suppositionVariableNode, nodes, substitutions) {
+  let suppositionVariableMatches;
+
+  const suppositionVariableName = variableNameFromVariableNode(suppositionVariableNode),
+        substitution = substitutions.find((substitution) => {
+          const variableName = substitution.getVariableName();
+
+          if (variableName === suppositionVariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (substitution !== null) {
+    const substitutionNodesMatch = substitution.matchNodes(nodes);
+
+    suppositionVariableMatches = substitutionNodesMatch;  ///
+  } else {
+    const variableName = suppositionVariableName, ///
+          substitution = Substitution.fromVariableNameAndNodes(variableName, nodes);
+
+    substitutions.push(substitution);
+
+    suppositionVariableMatches = true;
+  }
+
+  return suppositionVariableMatches;
+}
+
+function matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions) {
+  const matches = suppositionTerminalNode.match(terminalNode),
+        suppositionTerminalNodeMatches = matches;
+
+  return suppositionTerminalNodeMatches;
+}
+
+function matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions) {
+  let suppositionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        suppositionRuleName = suppositionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === suppositionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          suppositionNodes = suppositionChildNodes, ///
+          suppositionChildNodesMatches = matchSuppositionNodes(suppositionNodes, nodes, substitutions);
+
+    suppositionNonTerminalNodeMatches = suppositionChildNodesMatches; ///
+
+    if (!suppositionNonTerminalNodeMatches) {
+      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
+
+      if (ruleNameStatementRuleName) {
+        const statementNode = nonTerminalNode,  ///
+              suppositionStatementNode = suppositionNonTerminalNode,  ///
+              suppositionStatementNodeMatches = matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions);
+
+        suppositionNonTerminalNodeMatches = suppositionStatementNodeMatches; ///
+      }
+    }
+  }
+
+  return suppositionNonTerminalNodeMatches;
+}
+
+function matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions) {
+  let suppositionStatementNodeMatches = false;
+
+  const suppositionNonTerminalNode = suppositionStatementNode,  ///
+        suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
+        suppositionChildNodesLength = suppositionChildNodes.length;
+
+  if (suppositionChildNodesLength === 1) {
+    const firstSuppositionChildNode = first(suppositionChildNodes),
+          suppositionChildNode = firstSuppositionChildNode,  ///
+          suppositionChildNodeNonTerminalNode = suppositionChildNode.isNonTerminalNode();
+
+    if (suppositionChildNodeNonTerminalNode) {
+      const suppositionNonTerminalChildNode = suppositionChildNode,  ///
+            suppositionNonTerminalChildNodeRuleName = suppositionNonTerminalChildNode.getRuleName(),
+            suppositionNonTerminalChildNodeRuleNameVariableRuleName = (suppositionNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
+
+      if (suppositionNonTerminalChildNodeRuleNameVariableRuleName) {
+        const suppositionVariableNode = suppositionNonTerminalChildNode,  ///
+              nonTerminalNode = statementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              suppositionVariableMatches = matchSuppositionVariable(suppositionVariableNode, nodes, substitutions);
+
+        suppositionStatementNodeMatches = suppositionVariableMatches; ///
+      }
+    }
+  }
+
+  return suppositionStatementNodeMatches;
+}

package/src/theorem.js

@@ -9,5 +9,5 @@ export default class Theorem extends AxiomLemmaTheorem {
 
   static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
 
-  static fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent) { return AxiomLemmaTheorem.fromLabelsAntecedentsAndConsequent(Theorem, labels, antecedents, consequent); }
+  static fromLabelsSuppositionsAndConsequence(labels, antecedents, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, antecedents, consequence); }
 }

package/src/verify/axiom.js

@@ -3,16 +3,16 @@
 import Axiom from "../axiom";
 import ProofContext from "../context/proof";
 import verifyLabels from "../verify/labels";
-import verifyAntecedent from "../verify/antecedent";
-import verifyConsequent from "../verify/consequent";
+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"),
-      consequentNodeQuery = nodeQuery("/axiom/consequent!"),
-      antecedentsNodeQuery = nodesQuery("/axiom/antecedent");
+      consequenceNodeQuery = nodeQuery("/axiom/consequence!"),
+      suppositionsNodeQuery = nodesQuery("/axiom/supposition");
 
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
@@ -29,25 +29,25 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const antecedents = [],
-          antecedentNodes = antecedentsNodeQuery(axiomNode),
-          antecedentsVerified = antecedentNodes.every((antecedentNode) => {
-            const antecedentVerified = verifyAntecedent(antecedentNode, antecedents, proofContext);
+    const suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(axiomNode),
+          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
 
-            if (antecedentVerified) {
+            if (suppositionVerified) {
               return true;
             }
           });
 
-    if (antecedentsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(axiomNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+    if (suppositionsVerified) {
+      const consequences = [],
+            consequenceNode = consequenceNodeQuery(axiomNode),
+            consequenceVerified = verifyConsequence(consequenceNode, consequences, proofContext);
 
-      if (consequentVerified) {
-        const firstConsequent = first(consequents),
-              consequent = firstConsequent, ///
-              axiom = Axiom.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
+      if (consequenceVerified) {
+        const firstConsequence = first(consequences),
+              consequence = firstConsequence, ///
+              axiom = Axiom.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/consequence.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import Consequence from "../consequence";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+
+const statementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!/statement!");
+
+export default function verifyConsequence(consequenceNode, consequences, proofContext) {
+  let consequenceVerified = false;
+
+  proofContext.begin(consequenceNode);
+
+  const consequenceString = nodeAsString(consequenceNode);
+
+  proofContext.debug(`Verifying the ${consequenceString} consequence...`);
+
+  const statementNode = statementNodeQuery(consequenceNode);
+
+  if (statementNode !== null) {
+    const consequence = Consequence.fromStatementNode(statementNode);
+
+    consequences.push(consequence);
+
+    consequenceVerified = true;
+  }
+
+  consequenceVerified ?
+    proofContext.complete(consequenceNode) :
+      proofContext.halt(consequenceNode);
+
+  return consequenceVerified;
+}

package/src/verify/derivation.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import ProofContext from "../context/proof";
-import verifyAntecedent from "./antecedent";
+import verifySupposition from "./supposition";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -11,7 +11,7 @@ import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMEN
 
 const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      antecedentNodesQuery = nodesQuery("/subproof/antecedent"),
+      suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
 export default function verifyDerivation(derivationNode, proofContext) {
@@ -63,17 +63,17 @@ function verifySubproof(subproofNode, proofContext) {
 
   proofContext = ProofContext.fromProofContext(proofContext); ///
 
-  const antecedents = [],
-        antecedentNodes = antecedentNodesQuery(subproofNode),
-        antecedentsVerified = antecedentNodes.every((antecedentNode) => {
-          const antecedentVerified = verifyAntecedent(antecedentNode, antecedents, proofContext);
+  const suppositions = [],
+        suppositionNodes = suppositionNodesQuery(subproofNode),
+        suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+          const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
 
-          if (antecedentVerified) {
+          if (suppositionVerified) {
             return true;
           }
         });
 
-  if (antecedentsVerified) {
+  if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
           subDerivationVerified = verifySubDerivation(subDerivationNode, proofContext);
 

package/src/verify/lemma.js

@@ -4,8 +4,8 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import ProofContext from "../context/proof";
 import verifyLabels from "../verify/labels";
-import verifyAntecedent from "./antecedent";
-import verifyConsequent from "./consequent";
+import verifySupposition from "./supposition";
+import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -14,8 +14,8 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),
       labelNodesQuery = nodesQuery("/lemma/label"),
-      consequentNodeQuery = nodeQuery("/lemma/consequent!"),
-      antecedentsNodeQuery = nodesQuery("/lemma/antecedent");
+      consequenceNodeQuery = nodeQuery("/lemma/consequence!"),
+      suppositionsNodeQuery = nodesQuery("/lemma/supposition");
 
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
@@ -34,29 +34,29 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const antecedents = [],
-          antecedentNodes = antecedentsNodeQuery(lemmaNode),
-          antecedentsVerified = antecedentNodes.every((antecedentNode) => {
-            const antecedentVerified = verifyAntecedent(antecedentNode, antecedents, proofContext);
+    const suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(lemmaNode),
+          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
 
-            if (antecedentVerified) {
+            if (suppositionVerified) {
               return true;
             }
           });
 
-    if (antecedentsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(lemmaNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+    if (suppositionsVerified) {
+      const consequences = [],
+            consequenceNode = consequenceNodeQuery(lemmaNode),
+            consequenceVerified = verifyConsequence(consequenceNode, consequences, proofContext);
 
-      if (consequentVerified) {
+      if (consequenceVerified) {
         const proofNode = proofNodeQuery(lemmaNode),
-              firstConsequent = first(consequents),
-              consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, proofContext);
+              firstConsequence = first(consequences),
+              consequence = firstConsequence, ///
+              proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
+          const lemma = Lemma.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metaDerivation.js

@@ -2,7 +2,7 @@
 
 import MetaproofStep from "../step/metaproof";
 import MetaproofContext from "../context/metaproof";
-import verifyMetaAntecedent from "../verify/metaAntecedent";
+import verifyMetaSupposition from "../verify/metaSupposition";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
@@ -11,7 +11,7 @@ import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED
 
 const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      metaAntecedentNodesQuery = nodesQuery("/metaSubproof/metaAntecedent"),
+      metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
       metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
@@ -63,17 +63,17 @@ function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
 
   metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
 
-  const metaAntecedents = [],
-        metaAntecedentNodes = metaAntecedentNodesQuery(metaSubproofNode),
-        metaAntecedentsVerified = metaAntecedentNodes.every((metaAntecedentNode) => {
-          const metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, metaproofContext);
+  const metaSuppositions = [],
+        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
+        metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
+          const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, metaproofContext);
 
-          if (metaAntecedentVerified) {
+          if (metaSuppositionVerified) {
             return true;
           }
         });
 
-  if (metaAntecedentsVerified) {
+  if (metaSuppositionsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
           metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext);
 

package/src/verify/metaSupposition.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import MetaSupposition from "../metaSupposition";
+import verifyMetastatement from "./metastatement";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+
+const metastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!/metastatement!");
+
+export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, metaproofContext) {
+  let metaSuppositionVerified;
+
+  metaproofContext.begin(metaSuppositionNode);
+
+  const metaSuppositionString = nodeAsString(metaSuppositionNode);
+
+  metaproofContext.debug(`Verifying the ${metaSuppositionString} metaSupposition...`);
+
+  const metastatementNode = metastatementNodeQuery(metaSuppositionNode);
+
+  if (metastatementNode !== null) {
+    const qualified = false,
+          metastatementVerified = verifyMetastatement(metastatementNode, qualified, metaproofContext);
+
+    if (metastatementVerified) {
+      const metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
+            metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode);
+
+      metaSuppositions.push(metaSupposition);
+
+      metaproofContext.addMetaproofStep(metaproofStep);
+    }
+
+    metaSuppositionVerified = true;
+  }
+
+  metaSuppositionVerified ?
+    metaproofContext.complete(metaSuppositionNode) :
+      metaproofContext.halt(metaSuppositionNode);
+
+  return metaSuppositionVerified;
+}

package/src/verify/supposition.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import ProofStep from "../step/proof";
+import Supposition from "../supposition";
+import verifyStatement from "./statement";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+
+const statementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!/statement!");
+
+export default function verifySupposition(suppositionNode, suppositions, proofContext) {
+  let suppositionVerified;
+
+  proofContext.begin(suppositionNode);
+
+  const suppositionString = nodeAsString(suppositionNode);
+
+  proofContext.debug(`Verifying the ${suppositionString} supposition...`);
+
+  const statementNode = statementNodeQuery(suppositionNode);
+
+  if (statementNode !== null) {
+    const qualified = false,
+          statementVerified = verifyStatement(statementNode, qualified, proofContext);
+
+    if (statementVerified) {
+      const proofStep = ProofStep.fromStatementNode(statementNode),
+            supposition = Supposition.fromStatementNode(statementNode);
+
+      suppositions.push(supposition);
+
+      proofContext.addProofStep(proofStep);
+    }
+
+    suppositionVerified = true;
+  }
+
+  suppositionVerified ?
+    proofContext.complete(suppositionNode) :
+      proofContext.halt(suppositionNode);
+
+  return suppositionVerified;
+}

package/src/verify/theorem.js

@@ -4,8 +4,8 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import ProofContext from "../context/proof";
 import verifyLabels from "../verify/labels";
-import verifyAntecedent from "./antecedent";
-import verifyConsequent from "./consequent";
+import verifySupposition from "./supposition";
+import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
@@ -13,8 +13,8 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
       labelNodesQuery = nodesQuery("/theorem/label"),
-      consequentNodeQuery = nodeQuery("/theorem/consequent!"),
-      antecedentsNodeQuery = nodesQuery("/theorem/antecedent");
+      consequenceNodeQuery = nodeQuery("/theorem/consequence!"),
+      suppositionsNodeQuery = nodesQuery("/theorem/supposition");
 
 export default function verifyTheorem(theoremNode, fileContext) {
   let theoremVerified = false;
@@ -31,29 +31,29 @@ export default function verifyTheorem(theoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const antecedents = [],
-          antecedentNodes = antecedentsNodeQuery(theoremNode),
-          antecedentsVerified = antecedentNodes.every((antecedentNode) => {
-            const antecedentVerified = verifyAntecedent(antecedentNode, antecedents, proofContext);
+    const suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(theoremNode),
+          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
 
-            if (antecedentVerified) {
+            if (suppositionVerified) {
               return true;
             }
           });
 
-    if (antecedentsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(theoremNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+    if (suppositionsVerified) {
+      const consequences = [],
+            consequenceNode = consequenceNodeQuery(theoremNode),
+            consequenceVerified = verifyConsequence(consequenceNode, consequences, proofContext);
 
-      if (consequentVerified) {
+      if (consequenceVerified) {
         const proofNode = proofNodeQuery(theoremNode),
-              firstConsequent = first(consequents),
-              consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, proofContext);
+              firstConsequence = first(consequences),
+              consequence = firstConsequence, ///
+              proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
+          const theorem = Theorem.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
 
           fileContext.addTheorem(theorem);