occam-verify-cli 0.0.465 → 0.0.467

package/src/theorem.js

@@ -1,103 +1,13 @@
 "use strict";
 
-import Label from "./label";
+import AxiomLemmaTheorem from "./axiomLemmaTheorem";
 
 import { THEOREM_KIND } from "./kinds";
-import { nodeAsString } from "./utilities/string";
 
-import { unqualifiedStatementNodeFromUnqualifiedStatementString, indicativeConditionalNodeFromIndicativeConditionalString } from "./utilities/string";
+export default class Theorem extends AxiomLemmaTheorem {
+  static kind = THEOREM_KIND;
 
-export default class Theorem {
-  constructor(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    this.labels = labels;
-    this.unqualifiedStatementNode = unqualifiedStatementNode;
-    this.indicativeConditionalNode = indicativeConditionalNode;
-  }
+  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
 
-  getLabels() {
-    return this.labels;
-  }
-
-  getUnqualifiedStatementNode() {
-    return this.unqualifiedStatementNode;
-  }
-
-  getIndicativeConditionalNode() {
-    return this.indicativeConditionalNode;
-  }
-
-  matchLabelName(labelName) {
-    const matchesLabelName = this.labels.some((label) => {
-      const name = labelName, ///
-            labelMatchesName = label.matchName(name);
-
-      if (labelMatchesName) {
-        return true;
-      }
-    });
-
-    return matchesLabelName;
-  }
-
-  toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          unqualifiedStatementString = nodeAsString(this.unqalifiedStatementNode),
-          indicativeConditionalString = nodeAsString(this.indicativeConditionalNode),
-          kind = THEOREM_KIND,
-          labels = labelsJSON,  ///
-          unqualifiedStatement = unqualifiedStatementString,  ///
-          indicativeConditional = indicativeConditionalString,  ///
-          json = {
-            kind,
-            labels,
-            unqualifiedStatement,
-            indicativeConditional
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, releaseContext) {
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-                const json = labelJSON, ///
-                      label = Label.fromJSON(json, releaseContext);
-
-                return label;
-              });
-
-    let { unqualifiedStatement, indicativeConditional } = json;
-
-    let unqualifiedStatementNode = null,
-        indicativeConditionalNode = null;
-
-    if (unqualifiedStatement !== null) {
-      const unqualifiedStatementString = unqualifiedStatement;  ///
-
-      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext);
-    }
-
-    if (indicativeConditional !== null) {
-      const indicativeConditionalString = indicativeConditional;  ///
-
-      indicativeConditionalNode = indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext);
-    }
-
-    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return theorem;
-  }
-
-  static fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return theorem;
-  }
+  static fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent) { return AxiomLemmaTheorem.fromLabelsAntecedentsAndConsequent(Theorem, labels, antecedents, consequent); }
 }

package/src/utilities/statement.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { first, second, third } from "../utilities/array";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_STATEMENT_CHILD_NODES_LENGTH } from "../constants";
+
+export function bracketedStatementChildNodeFromChildNodes(childNodes) {
+  let bracketedStatementChildNode = null;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_STATEMENT_CHILD_NODES_LENGTH) {
+    const firstChildNode = first(childNodes),
+          thirdChildNode = third(childNodes),
+          secondChildNode = second(childNodes),
+          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
+          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
+          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
+
+    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
+      const nonTerminalNode = secondChildNode,  ///
+            firstTerminalNode = firstChildNode, ///
+            secondTerminalNode = thirdChildNode,  ///
+            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
+            firstTerminalNodeContent = firstTerminalNode.getContent(),
+            secondTerminalNodeContent = secondTerminalNode.getContent(),
+            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
+            nonTerminalNodeRuleNameStatementRuleName = (nonTerminalNodeRuleName === STATEMENT_RULE_NAME);
+
+      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameStatementRuleName && secondTerminalNodeContentRightBracket) {
+        bracketedStatementChildNode = nonTerminalNode;  ///
+      }
+    }
+  }
+
+  return bracketedStatementChildNode;
+}
+
+export function matchBracketedStatementChildNode(childNodes, callback) {
+  let bracketedStatementChildNodeMatches = false;
+
+  const bracketedStatementChildNode = bracketedStatementChildNodeFromChildNodes(childNodes);
+
+  if (bracketedStatementChildNode !== null) {
+    bracketedStatementChildNodeMatches = callback(bracketedStatementChildNode);
+  }
+
+  return bracketedStatementChildNodeMatches;
+}

package/src/utilities/string.js

@@ -5,7 +5,7 @@ import { nodeQuery } from "../utilities/query";
 import { TERM_RULE_NAME,
          LABEL_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
-         INDICATIVE_CONDITIONAL_RULE_NAME,
+         CONDITIONAL_INDICATIVE_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME} from "../ruleNames";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
@@ -104,11 +104,11 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifi
   return unqualifiedStatementNode;
 }
 
-export function indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext) {
-  const ruleName = INDICATIVE_CONDITIONAL_RULE_NAME,
-        content = indicativeConditionalString, ///
+export function conditionalIndicativeNodeFromConditionalIndicativeString(conditionalIndicativeString, releaseContext) {
+  const ruleName = CONDITIONAL_INDICATIVE_RULE_NAME,
+        content = conditionalIndicativeString, ///
         node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        indicativeConditionalNode = node;  ///
+        conditionalIndicativeNode = node;  ///
 
-  return indicativeConditionalNode;
+  return conditionalIndicativeNode;
 }

package/src/verify/antecedentOrAntecedents.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import Assertion from "../assertion";
+import Antecedent from "../antecedent";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      unqualifiedStatementNodesQuery = nodesQuery("/antecedent|antecedents/unqualifiedStatement");
+
+export default function verifyAntecedentOrAntecedents(antecedentOrAntecedentsNode, antecedents, proofContext) {
+  let antecedentOrAntecedentsVerified;
+
+  proofContext.begin(antecedentOrAntecedentsNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(antecedentOrAntecedentsNode);
+
+  antecedentOrAntecedentsVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode),
+            antecedent = Antecedent.fromStatementNode(statementNode);
+
+      antecedents.push(antecedent);
+
+      proofContext.addAssertion(assertion);
+
+      return true;
+    }
+  });
+
+  antecedentOrAntecedentsVerified ?
+    proofContext.complete(antecedentOrAntecedentsNode) :
+      proofContext.halt(antecedentOrAntecedentsNode);
+
+  return antecedentOrAntecedentsVerified;
+}

package/src/verify/axiom.js

@@ -1,17 +1,18 @@
 "use strict";
 
 import Axiom from "../axiom";
-import verifyLabels from "../verify/labels";
 import ProofContext from "../context/proof";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyIndicativeConditional from "../verify/indicativeConditional";
+import verifyLabels from "../verify/labels";
+import verifyConditionalIndicative from "../verify/conditinalIndicative";
+import verifyUnconditionalIndicative from "../verify/unconditionalIndicative";
 
+import { first } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
-      unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
-      indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
+      conditionalIndicativeNodeQuery = nodeQuery("/axiom/conditionalIndicative!"),
+      unconditionalIndicativeNodeQuery = nodeQuery("/axiom/unconditionalIndicative!");
 
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
@@ -28,22 +29,26 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
-          indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
+    const antecedents = [],
+          consequents = [],
+          conditionalIndicativeNode = conditionalIndicativeNodeQuery(axiomNode),
+          unconditionalIndicativeNode = unconditionalIndicativeNodeQuery(axiomNode);
 
-    let unqualifiedStatementVerified = false,
-        indicativeConditionalVerified = false;
+    let conditionalIndicativeVerified = false,
+      unconditionalIndicativeVerified = false;
 
-    if (unqualifiedStatementNode !== null) {
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    if (conditionalIndicativeNode !== null) {
+      conditionalIndicativeVerified = verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext);
     }
 
-    if (indicativeConditionalNode !== null) {
-      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    if (unconditionalIndicativeNode !== null) {
+      unconditionalIndicativeVerified = verifyUnconditionalIndicative(unconditionalIndicativeNode, consequents, proofContext);
     }
 
-    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
-      const axiom = Axiom.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
+    if (conditionalIndicativeVerified || unconditionalIndicativeVerified) {
+      const firstConsequent = first(consequents),
+            consequent = firstConsequent, ///
+            axiom = Axiom.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
 
       fileContext.addAxiom(axiom);
 
@@ -57,7 +62,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
   axiomVerified ?
     fileContext.complete(axiomNode) :
-      fileContext.halt(axiomNode);
+      fileContext.complete(axiomNode);
 
   return axiomVerified;
 }

package/src/verify/conditinalIndicative.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import verifyConsequent from "../verify/consequent";
+import verifyAntecedentOrAntecedents from "../verify/antecedentOrAntecedents";
+
+import { nodeQuery } from "../utilities/query";
+
+const consequentNodeQuery = nodeQuery("/conditionalIndicative/consequent!"),
+      antecedentOrAntecedentsNodeQuery = nodeQuery("/conditionalIndicative/antecedent|antecedents!");
+
+export default function verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext) {
+  let conditionalIndicativeVerified = false;
+
+  proofContext.begin(conditionalIndicativeNode);
+
+  const consequentNode = consequentNodeQuery(conditionalIndicativeNode),
+        antecedentOrAntecedentsNode = antecedentOrAntecedentsNodeQuery(conditionalIndicativeNode),
+        antecedentOrAntecedentsVerified = verifyAntecedentOrAntecedents(antecedentOrAntecedentsNode, antecedents, proofContext);
+
+  if (antecedentOrAntecedentsVerified) {
+    const consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+
+    conditionalIndicativeVerified = consequentVerified;  ///
+  }
+
+  conditionalIndicativeVerified ?
+    proofContext.complete(conditionalIndicativeNode) :
+      proofContext.halt(conditionalIndicativeNode);
+
+  return conditionalIndicativeVerified;
+}

package/src/verify/conditionalIndicative.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodesQuery } from "../utilities/query";
+
+const unqualifiedStatementNodesQuery = nodesQuery("/conditionalIndicative/unqualifiedStatement");
+
+export default function verifyConditionalIndicative(conditionalIndicativeNode, proofContext) {
+  let conditionalIndicativeVerified;
+
+  proofContext.begin(conditionalIndicativeNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(conditionalIndicativeNode);
+
+  conditionalIndicativeVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  conditionalIndicativeVerified ?
+    proofContext.complete(conditionalIndicativeNode) :
+      proofContext.halt(conditionalIndicativeNode);
+
+  return conditionalIndicativeVerified;
+}

package/src/verify/consequent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import Consequent from "../consequent";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+
+const statementNodeQuery = nodeQuery("/*/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/consequent/unqualifiedStatement!");
+
+export default function verifyConsequent(consequentNode, consequents, proofContext) {
+  let consequentVerified = false;
+
+  proofContext.begin(consequentNode);
+
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
+
+  if (unqualifiedStatementNode !== null) {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            consequent = Consequent.fromStatementNode(statementNode);
+
+      consequents.push(consequent);
+
+      consequentVerified = true;
+    }
+  }
+
+  consequentVerified ?
+    proofContext.complete(consequentNode) :
+      proofContext.halt(consequentNode);
+
+  return consequentVerified;
+}

package/src/verify/lemma.js

@@ -1,17 +1,21 @@
 "use strict";
 
 import Lemma from "../lemma";
-import verifyLabels from "../verify/labels";
+import verifyProof from "../verify/proof";
 import ProofContext from "../context/proof";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyIndicativeConditional from "../verify/indicativeConditional";
+import verifyLabels from "../verify/labels";
+import verifyConditionalIndicative from "../verify/conditinalIndicative";
+import verifyUnconditionalIndicative from "../verify/unconditionalIndicative";
 
+import { first } from "../utilities/array";
+import { EMPTY_STRING } from "../constants";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/lemma/label"),
-      unqualifiedStatementNodeQuery = nodeQuery("/lemma/unqualifiedStatement!"),
-      indicativeConditionalNodeQuery = nodeQuery("/lemma/indicativeConditional!");
+const proofNodeQuery = nodeQuery("/lemma/proof!"),
+      labelNodesQuery = nodesQuery("/lemma/label"),
+      conditionalIndicativeNodeQuery = nodeQuery("/lemma/conditionalIndicative!"),
+      unconditionalIndicativeNodeQuery = nodeQuery("/lemma/unconditionalIndicative!");
 
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
@@ -22,42 +26,55 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsString = nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+  (labelsString === EMPTY_STRING) ?
+    fileContext.debug(`Verifying a lemma...`) :
+      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(lemmaNode),
-          indicativeConditionalNode = indicativeConditionalNodeQuery(lemmaNode);
+    const antecedents = [],
+          consequents = [],
+          conditionalIndicativeNode = conditionalIndicativeNodeQuery(lemmaNode),
+          unconditionalIndicativeNode = unconditionalIndicativeNodeQuery(lemmaNode);
 
-    let unqualifiedStatementVerified = false,
-        indicativeConditionalVerified = false;
+    let conditionalIndicativeVerified = false,
+        unconditionalIndicativeVerified = false;
 
-    if (unqualifiedStatementNode !== null) {
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    if (conditionalIndicativeNode !== null) {
+      conditionalIndicativeVerified = verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext);
     }
 
-    if (indicativeConditionalNode !== null) {
-      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    if (unconditionalIndicativeNode !== null) {
+      unconditionalIndicativeVerified = verifyUnconditionalIndicative(unconditionalIndicativeNode, consequents, proofContext);
     }
 
-    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
-      const lemma = Lemma.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
+    if (conditionalIndicativeVerified || unconditionalIndicativeVerified) {
+      const proofNode = proofNodeQuery(lemmaNode),
+            firstConsequent = first(consequents),
+            consequent = firstConsequent, ///
+            proofVerified = verifyProof(proofNode, consequent, proofContext);
+
+      if (proofVerified) {
+        const lemma = Lemma.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
 
-      fileContext.addLemma(lemma);
+        fileContext.addLemma(lemma);
 
-      lemmaVerified = true;
+        lemmaVerified = true;
+      }
     }
   }
 
   if (lemmaVerified) {
-    fileContext.info(`Verified the '${labelsString}' lemma.`);
+    (labelsString === EMPTY_STRING) ?
+      fileContext.info(`Verified the lemma.`) :
+        fileContext.info(`Verified the '${labelsString}' lemma.`);
   }
 
   lemmaVerified ?
     fileContext.complete(lemmaNode) :
-      fileContext.halt(lemmaNode);
+      fileContext.complete(lemmaNode);
 
   return lemmaVerified;
 }

package/src/verify/metaproof.js

@@ -9,7 +9,7 @@ import { nodeQuery } from "../utilities/query";
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
       qualifiedMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
 
-export default function verifyMetaproof(metaproofNode, metastatementNode, metaproofContext) {
+export default function verifyMetaproof(metaproofNode, conclusion, metaproofContext) {
   let metaproofVerified = false;
 
   metaproofContext.begin(metaproofNode);
@@ -37,6 +37,7 @@ export default function verifyMetaproof(metaproofNode, metastatementNode, metapr
   if (metaDerivationVerified || qualifiedMetastatementVerified) {
     const lastMetaAssertion = metaproofContext.getLastMetaAssertion(),
           metaAssertion = lastMetaAssertion, ///
+          metastatementNode = conclusion.getMetastatementNode(),
           metaAssertionMetastatementNode = metaAssertion.getMetastatementNode(),
           metaAssertionMetastatementNodeMatches = matchMetaProofMetastatementNode(metaAssertionMetastatementNode, metastatementNode);
 

package/src/verify/rule.js

@@ -55,9 +55,7 @@ export default function verifyRule(ruleNode, fileContext) {
       let metaproofVerified = true;
 
       if (metaproofNode !== null) {
-        const metastatementNode = conclusion.getMetastatementNode();
-
-        metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, metaproofContext);
+        metaproofVerified = verifyMetaproof(metaproofNode, conclusion, metaproofContext);
       }
 
       if (metaproofVerified) {

package/src/verify/theorem.js

@@ -1,19 +1,20 @@
 "use strict";
 
 import Theorem from "../theorem";
-import verifyProof from "./proof";
-import verifyLabels from "../verify/labels";
+import verifyProof from "../verify/proof";
 import ProofContext from "../context/proof";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyIndicativeConditional from "../verify/indicativeConditional";
+import verifyLabels from "../verify/labels";
+import verifyConditionalIndicative from "../verify/conditinalIndicative";
+import verifyUnconditionalIndicative from "../verify/unconditionalIndicative";
 
+import { first } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const proofNodeQuery = nodeQuery("/theorem/proof"),
+const proofNodeQuery = nodeQuery("/theorem/proof!"),
       labelNodesQuery = nodesQuery("/theorem/label"),
-      unqualifiedStatementNodeQuery = nodeQuery("/theorem/unqualifiedStatement!"),
-      indicativeConditionalNodeQuery = nodeQuery("/theorem/indicativeConditional!");
+      conditionalIndicativeNodeQuery = nodeQuery("/theorem/conditionalIndicative!"),
+      unconditionalIndicativeNodeQuery = nodeQuery("/theorem/unconditionalIndicative!");
 
 export default function verifyTheorem(theoremNode, fileContext) {
   let theoremVerified = false;
@@ -30,30 +31,35 @@ export default function verifyTheorem(theoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(theoremNode),
-          indicativeConditionalNode = indicativeConditionalNodeQuery(theoremNode);
+    const antecedents = [],
+          consequents = [],
+          conditionalIndicativeNode = conditionalIndicativeNodeQuery(theoremNode),
+          unconditionalIndicativeNode = unconditionalIndicativeNodeQuery(theoremNode);
 
-    let unqualifiedStatementVerified = false,
-        indicativeConditionalVerified = false;
+    let conditionalIndicativeVerified = false,
+        unconditionalIndicativeVerified = false;
 
-    if (unqualifiedStatementNode !== null) {
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    if (conditionalIndicativeNode !== null) {
+      conditionalIndicativeVerified = verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext);
     }
 
-    if (indicativeConditionalNode !== null) {
-      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    if (unconditionalIndicativeNode !== null) {
+      unconditionalIndicativeVerified = verifyUnconditionalIndicative(unconditionalIndicativeNode, consequents, proofContext);
     }
 
-    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
+    if (conditionalIndicativeVerified || unconditionalIndicativeVerified) {
       const proofNode = proofNodeQuery(theoremNode),
-            statements =
-            proofVerified = verifyProof(proofNode, fileContext);
+            firstConsequent = first(consequents),
+            consequent = firstConsequent, ///
+            proofVerified = verifyProof(proofNode, consequent, proofContext);
 
-      const theorem = Theorem.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
+      if (proofVerified) {
+        const theorem = Theorem.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
 
-      fileContext.addTheorem(theorem);
+        fileContext.addTheorem(theorem);
 
-      theoremVerified = true;
+        theoremVerified = true;
+      }
     }
   }
 
@@ -63,7 +69,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
 
   theoremVerified ?
     fileContext.complete(theoremNode) :
-      fileContext.halt(theoremNode);
+      fileContext.complete(theoremNode);
 
   return theoremVerified;
 }

package/src/verify/unconditionalIndicative.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import verifyConsequent from "../verify/consequent";
+
+import { nodeQuery } from "../utilities/query";
+
+const consequentNodeQuery = nodeQuery("/unconditionalIndicative/consequent!");
+
+export default function verifyUnconditionalIndicative(conditionalIndicativeNode, consequents, proofContext) {
+  let unconditionalIndicativeVerified;
+
+  proofContext.begin(conditionalIndicativeNode);
+
+  const consequentNode = consequentNodeQuery(conditionalIndicativeNode),
+        consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+
+  unconditionalIndicativeVerified = consequentVerified;  ///
+
+  unconditionalIndicativeVerified ?
+    proofContext.complete(conditionalIndicativeNode) :
+      proofContext.halt(conditionalIndicativeNode);
+
+  return unconditionalIndicativeVerified;
+}