occam-verify-cli 0.0.526 → 0.0.527

package/src/verify/assertion/type.js

@@ -1,16 +1,16 @@
 "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);
@@ -27,16 +27,16 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, proof
     proofContext.error(`The ${typeName} type is not present.`);
   } 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) {
@@ -50,7 +50,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, proof
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let variableTypeAssertionVerified = false;
 
   const context = proofContext, ///
@@ -59,18 +59,28 @@ 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.`);
+      } 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(),
@@ -79,7 +89,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
         proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`);
       } 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 +104,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"),

package/src/verify/conjecture.js

@@ -0,0 +1,73 @@
+"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;
+
+  fileContext.begin(conjectureNode);
+
+  const labelNodes = labelNodesQuery(conjectureNode),
+        labelsString = fileContext.nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext);
+
+  fileContext.debug(`Verifying the '${labelsString}' conjecture...`);
+
+  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.`);
+  }
+
+  conjectureVerified ?
+    fileContext.complete(conjectureNode) :
+      fileContext.complete(conjectureNode);
+
+  return conjectureVerified;
+}

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!"),
@@ -30,6 +32,7 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         axiomNode = axiomNodeQuery(node),
         lemmaNode = lemmaNodeQuery(node),
         theoremNode = theoremNodeQuery(node),
+        conjectureNode = conjectureNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -53,6 +56,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);
 

package/src/verify/lemma.js

@@ -9,7 +9,6 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),

package/src/verify/metastatement/qualified.js

@@ -2,7 +2,6 @@
 
 import verifyMetastatement from "../../verify/metastatement";
 
-import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),

package/src/verify/metastatement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyMetastatement from "../metastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 

package/src/verify/rule.js

@@ -8,7 +8,6 @@ import MetaproofContext from "../context/metaproof";
 import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/rule/label"),

package/src/verify/statement/qualified.js

@@ -2,7 +2,6 @@
 
 import verifyStatement from "../../verify/statement";
 
-import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
@@ -20,24 +19,65 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
 
     proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
 
-    let ruleMatchesStatement = true;
-
     const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
-    if (referenceNode !== null) {
-      const referenceName = referenceNameFromReferenceNode(referenceNode),
-            rule = proofContext.findRuleByReferenceName(referenceName);
-
-      if (rule !== null) {
-        ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
-      }
-    }
-
-    if (ruleMatchesStatement) {
+    if (referenceNode === null) {
       const context = proofContext,
             statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
+    } else {
+      const referenceName = referenceNameFromReferenceNode(referenceNode);
+
+      if (!qualifiedStatementVerified) {
+        const rule = proofContext.findRuleByReferenceName(referenceName);
+
+        if (rule !== null) {
+          const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = ruleMatchesStatement;  ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const axiom = proofContext.findAxiomByReferenceName(referenceName);
+
+        if (axiom !== null) {
+          const axiomMatchesStatement = axiom.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = axiomMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const lemma = proofContext.findLemmaByReferenceName(referenceName);
+
+        if (lemma !== null) {
+          const lemmaMatchesStatement = lemma.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = lemmaMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const theorem = proofContext.findTheoremByReferenceName(referenceName);
+
+        if (theorem !== null) {
+          const theoremMatchesStatement = theorem.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = theoremMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const conjecture = proofContext.findConjectureByReferenceName(referenceName);
+
+        if (conjecture !== null) {
+          const conjectureMatchesStatement = conjecture.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = conjectureMatchesStatement; ///
+        }
+      }
     }
   }
 

package/src/verify/statement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyStatement from "../statement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 

package/src/verify/statement.js

@@ -2,7 +2,6 @@
 
 import Equality from "../equality";
 import verifyTerm from "../verify/term";
-import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
@@ -10,7 +9,6 @@ import { first } from "../utilities/array";
 import { objectType } from "../type";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
-import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
@@ -26,21 +24,21 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   context.begin(statementNode);
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
 
-    statementVerified = statementVerifiedAsEquality;  //
+    statementVerified = statementVerifiedAgainstCombinators;  ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, context);
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, derived, context);
 
     statementVerified = statementVerifiedAsTypeAssertion; ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
 
-    statementVerified = statementVerifiedAgainstCombinators;  ///
+    statementVerified = statementVerifiedAsEquality;  //
   }
 
   statementVerified ?
@@ -50,40 +48,14 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   return statementVerified;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
-  let statementVerifiedAsEquality = false;
-
-  const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
-
-  if (statementVerifiedAgainstCombinator) {
-    statementVerifiedAsEquality = true;
-
-    if (derived) {
-      const equality = Equality.fromStatementNode(statementNode),
-            proofSteps = context.getProofSteps(),
-            equalities = equalitiesFromProofSteps(proofSteps),
-            equalityEquates = equality.equate(equalities);
-
-      statementVerifiedAsEquality = equalityEquates; ///
-    }
-  }
-
-  return statementVerifiedAsEquality;
-}
-
-function verifyStatementAsTypeAssertion(statementNode, assertions, context) {
-  let statementVerifiedAsTypeAssertion = false;
-
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
-
-  if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, context);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-  }
+export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+        node = statementNode,  ///
+        combinatorNode = combinatorStatementNode, ///
+        nodeVerified = verifyNode(node, combinatorNode, context),
+        statementVerifiedAgainstCombinator = nodeVerified;  ///
 
-  return statementVerifiedAsTypeAssertion;
+  return statementVerifiedAgainstCombinator;
 }
 
 function verifyStatementAgainstCombinators(statementNode, context) {
@@ -111,14 +83,40 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context) {
-  const combinatorStatementNode = combinator.getStatementNode(),
-        node = statementNode,  ///
-        combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, context),
-        statementVerifiedAgainstCombinator = nodeVerified;  ///
+function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
+  let statementVerifiedAsTypeAssertion = false;
 
-  return statementVerifiedAgainstCombinator;
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, derived, context);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}
+
+function verifyStatementAsEquality(statementNode, derived, context) {
+  let statementVerifiedAsEquality = false;
+
+  const equality = Equality.fromStatementNode(statementNode, context);
+
+  if (equality !== null) {
+    statementVerifiedAsEquality = true; ///
+
+    if (derived) {
+      const equalities = context.getEqualities();
+
+      if (equalities !== null) {
+        const equalityEquates = equality.equate(equalities, context);
+
+        statementVerifiedAsEquality = equalityEquates; ///
+      }
+    }
+  }
+
+  return statementVerifiedAsEquality;
 }
 
 function verifyNode(node, combinatorNode, context) {
@@ -266,7 +264,7 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
     context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
   } else {
     const derived = false,
-          assertions = null,
+          assertions = [],
           statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
     if (statementVerified) {
@@ -290,21 +288,3 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
 
   return metaArgumentNodeVerified;
 }
-
-function equalitiesFromProofSteps(proofSteps) {
-  const start = -MAXIMUM_INDEXES_LENGTH;  ///
-
-  proofSteps = proofSteps.slice(start); ///
-
-  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
-    const equality = Equality.fromProofStep(proofStep);
-
-    if (equality !== null) {
-      equalities.push(equality);
-    }
-
-    return equalities;
-  }, []);
-
-  return equalities;
-}

package/src/verify/theorem.js

@@ -8,7 +8,6 @@ import verifySupposition from "./supposition";
 import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),