occam-verify-cli 1.0.438 → 1.0.448

package/src/element/assertion/property.js

@@ -7,8 +7,8 @@ import { define } from "../../elements";
 import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class PropertyAssertion extends Assertion {
-  constructor(string, node, term, propertyRelation) {
-    super(string, node);
+  constructor(context, string, node, term, propertyRelation) {
+    super(context, string, node);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -22,14 +22,14 @@ export default define(class PropertyAssertion extends Assertion {
     return this.propertyRelation;
   }
 
-  matchTermAndPropertyRelation(term, propertyRelation, context) {
-    let propertyMatchesTermAndPropertyRelation = false;
+  compareTermAndPropertyRelation(term, propertyRelation, context) {
+    let comparesToTermAndPropertyRelation = false;
 
     const termString = term.getString(),
           propertyRelationString = propertyRelation.getString(),
-          propertyAssertionString = this.getString();
+          propertyAssertionString = this.getString(); ///
 
-    context.trace(`Matching the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion...`);
+    context.trace(`Comparing the '${propertyAssertionString}' property assertion to the '${termString}' term and '${propertyRelationString}' property relation...`);
 
     const termA = term,
           termB = this.term, ///
@@ -38,14 +38,14 @@ export default define(class PropertyAssertion extends Assertion {
     if (termAEqualToTermB) {
       const propertyRelationEqualToPropertyRelation = this.propertyRelation.isEqualTo(propertyRelation);
 
-      propertyMatchesTermAndPropertyRelation = propertyRelationEqualToPropertyRelation;  ///
+      comparesToTermAndPropertyRelation = propertyRelationEqualToPropertyRelation;  ///
     }
 
-    if (propertyMatchesTermAndPropertyRelation) {
-      context.debug(`...matched the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion.`);
+    if (comparesToTermAndPropertyRelation) {
+      context.debug(`...compared the '${propertyAssertionString}' property assertion to the '${termString}' term and '${propertyRelationString}' property relation.`);
     }
 
-    return propertyMatchesTermAndPropertyRelation;
+    return comparesToTermAndPropertyRelation;
   }
 
   verify(assignments, stated, context) {
@@ -55,9 +55,9 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context);
+    const termValidates = this.validateTerm(assignments, stated, context);
 
-    if (termVerifies) {
+    if (termValidates) {
       const propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);
 
       if (propertyRelationVerifies) {
@@ -89,24 +89,24 @@ export default define(class PropertyAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies;
+  validateTerm(assignments, stated, context) {
+    let termValidates;
 
     const termString = this.term.getString();
 
-    context.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Validating the '${termString}' term...`);
 
-    termVerifies = this.term.verify(context, () => {
+    termValidates = this.term.verify(context, () => {
       const verifiesAhead = true;
 
       return verifiesAhead;
     });
 
-    if (termVerifies) {
-      context.debug(`...verified the '${termString}' term.`);
+    if (termValidates) {
+      context.debug(`...validated the '${termString}' term.`);
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyPropertyRelation(assignments, stated, context) {
@@ -126,7 +126,7 @@ export default define(class PropertyAssertion extends Assertion {
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+    let verifiesWhenStated;
 
     const propertyAssertionString = this.getString(); ///
 

package/src/element/assertion/satisfies.js

@@ -6,8 +6,8 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 
 export default define(class SatisfiesAssertion extends Assertion {
-  constructor(string, node, signature, reference) {
-    super(string, node);
+  constructor(context, string, node, signature, reference) {
+    super(context, string, node);
 
     this.signature = signature;
     this.reference = reference;
@@ -97,9 +97,9 @@ export default define(class SatisfiesAssertion extends Assertion {
 
       substitutions = Substitutions.fromNothing();
 
-      const signatureMatches = axiom.matchSignature(this.signature, substitutions, context);
+      const axiomComparesToSignature = axiom.compareSignature(this.signature, substitutions, context);
 
-      if (signatureMatches) {
+      if (axiomComparesToSignature) {
         const substitutionsB = substitutions; ///
 
         substitutions = Substitutions.fromNothing();
@@ -108,9 +108,9 @@ export default define(class SatisfiesAssertion extends Assertion {
 
         if (statementUnifies) {
           const substitutionsA = substitutions, ///
-                substitutionsMatch = substitutionsA.correlateSubstitutions(substitutionsB);
+                substitutionsCorrelate = substitutionsA.correlateSubstitutions(substitutionsB);
 
-          if (!substitutionsMatch) {
+          if (!substitutionsCorrelate) {
             const substitutionsAString = substitutionsA.asString(),
                   substitutionsBString = substitutionsB.asString();
 

package/src/element/assertion/subproof.js

@@ -10,8 +10,8 @@ import { unifyStatement } from "../../process/unify";
 const { match } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
-  constructor(string, node, statements) {
-    super(string, node);
+  constructor(context, string, node, statements) {
+    super(context, string, node);
 
     this.statements = statements;
   }
@@ -20,38 +20,40 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
-  verify(assignments, stated, context) {
-    let verifies;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const subproofAssertionString = this.getString();  ///
 
-    context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
+    context.trace(`Validating the '${subproofAssertionString}' subproof assertion...`);
 
-    const statementsVerify = this.verifyStatements(assignments, stated, context);
+    const statementsValidate = this.validateStatements(assignments, stated, context);
 
-    verifies = statementsVerify;  ///
+    if (statementsValidate) {
+      validates = true;
+    }
 
-    if (verifies) {
-      context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyStatements(assignments, stated, context) {
+  validateStatements(assignments, stated, context) {
     stated = true;  ///
 
     assignments = null; ///
 
-    const statementsVerify = this.statements.map((statement) => {
-      const statementVerifies = statement.verify(assignments, stated, context);
+    const statementsValidate = this.statements.map((statement) => {
+      const statementValidates = statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
+      if (statementValidates) {
         return true;
       }
     });
 
-    return statementsVerify;
+    return statementsValidate;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {

package/src/element/assertion/type.js

@@ -7,8 +7,8 @@ import { define } from "../../elements";
 import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(string, node, term, type) {
-    super(string, node);
+  constructor(context, string, node, term, type) {
+    super(context, string, node);
 
     this.term = term;
     this.type = type;

package/src/element/assertion.js

@@ -6,6 +6,4 @@ export default class Assertion extends Element {
   constructor(context, string, node) {
     super(context, string, node);
   }
-
-  matchAssertionNode(assertionNode) { return this.node.match(assertionNode); }
 }

package/src/element/assumption.js

@@ -31,13 +31,13 @@ export default define(class Assumption extends Element {
     return simple;
   }
 
-  matchSubstitution(substitution, context) {
-    let substitutionMatches = false;
+  compareSubstitution(substitution, context) {
+    let comparesToSubstituion = false;
 
     const assumptionString = this.string,  ///
           substitutionString = substitution.getString();
 
-    context.trace(`Matching the '${substitutionString}' substitution against the '${assumptionString}' assumption...`);
+    context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
 
     const simple = this.isSimple();
 
@@ -46,9 +46,12 @@ export default define(class Assumption extends Element {
             judgement = context.findJudgementByMetavariable(metavariable);
 
       if (judgement !== null) {
-        const assumption = judgement.getDeclaration();
+        const assumption = judgement.getDeclaration(),
+              assumptionComaresToSubstitution = assumption.compareSubstitution(substitution, context);
 
-        substitutionMatches = assumption.matchSubstitution(substitution, context);
+        if (assumptionComaresToSubstitution) {
+          comparesToSubstituion = true;
+        }
       }
     } else {
       const statement = substitution.getStatement(),
@@ -57,15 +60,15 @@ export default define(class Assumption extends Element {
             referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualToMetavariable(metavariable);
 
       if (statementEqualToStatement && referenceMetavariableEqualToMetavariable) {
-        substitutionMatches = true;
+        comparesToSubstituion = true;
       }
     }
 
-    if (substitutionMatches) {
-      context.debug(`...matches the '${assumptionString}' substitution against the '${substitutionString}' assumption.`);
+    if (comparesToSubstituion) {
+      context.debug(`...compared the '${substitutionString}' assumption to the '${assumptionString}' substitution.`);
     }
 
-    return substitutionMatches;
+    return comparesToSubstituion;
   }
 
   verify(assignments, stated, context) {
@@ -85,9 +88,9 @@ export default define(class Assumption extends Element {
       const referenceVerified = this.verifyReference(assignments, stated, context);
 
       if (referenceVerified) {
-        const statementVerifies = this.verifyStatement(assignments, stated, context);
+        const statementValidates = this.validateStatement(assignments, stated, context);
 
-        if (statementVerifies) {
+        if (statementValidates) {
           let verifiesWhenStated = false,
               verifiesWhenDerived = false;
 
@@ -128,28 +131,28 @@ export default define(class Assumption extends Element {
     return referenceVerified;
   }
 
-  verifyStatement(assignments, stated, context) {
-    let statementVerifies;
+  validateStatement(assignments, stated, context) {
+    let statementValidates;
 
     if (this.statement === null) {
-      statementVerifies = true;
+      statementValidates = true;
     } else {
       const statementString = this.statement.getString();
 
-      context.trace(`Verifying the '${statementString}' statement...`);
+      context.trace(`Validating the '${statementString}' statement...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      statementVerifies = this.statement.verify(assignments, stated, context);
+      statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
-        context.debug(`...verified the '${statementString}' statement.`);
+      if (statementValidates) {
+        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
-    return statementVerifies;
+    return statementValidates;
   }
 
   verifyReferenceAsMetavariable(assignments, stated, context) {

package/src/element/axiom.js

@@ -56,8 +56,8 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return signatureVerifies;
   }
 
-  matchSignature(signature, substitutions, context) {
-    let signatureMatches = false;
+  compareSignature(signature, substitutions, context) {
+    let comparesToSignature = false;
 
     const satisfiable = this.isSatisfiable();
 
@@ -73,10 +73,10 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
 
       const generalContext = context;  ///
 
-      signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
+      comparesToSignature = signatureA.compare(signatureB, substitutions, generalContext, specificContext);
     }
 
-    return signatureMatches;
+    return comparesToSignature;
   }
 
   unifyStep(step, substitutions, context) {
@@ -93,7 +93,7 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     const unconditional = this.isUnconditional();
 
     if (!unconditional) {
-      context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
+      context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
     } else {
       const statement = step.getStatement(),
             statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
@@ -110,29 +110,6 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return stepUnifies;
   }
 
-  unifyLastStep(lastStep, substitutions, context) {
-    let lastStepUnifies = false;
-
-    const node = this.getNode(),
-          axiomString = this.getString(),
-          lastStepString = lastStep.getString();
-
-    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)
-
-    const statement = lastStep.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
-
-    if (statementUnifiesWithDeduction) {
-      lastStepUnifies = true;
-    }
-
-    if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`, node)
-    }
-
-    return lastStepUnifies;
-  }
-
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
@@ -145,12 +122,12 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     const unconditional = this.isUnconditional();
 
     if (unconditional) {
-      context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
+      context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
-      const lastStep = subproof.getLastStep(),
-            lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
+      const lastProofAssertion = subproof.getLastProofAssertion(),
+            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, substitutions, context);
 
-      if (lastStepUnifies) {
+      if (lastProofAssertionUnifies) {
         const suppositions = subproof.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, substitutions, context);
 
@@ -213,22 +190,41 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     if (generalSuppositionsLength === specificSuppositionsLength) {
       suppositions = specificSuppositions;  ///
 
-      const suppositionsMatch = suppositions.every((supposition, index) => {
+      suppositionsUnify = suppositions.every((supposition, index) => {
         const suppositionUnifies = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
 
         if (suppositionUnifies) {
           return true;
         }
       });
-
-      if (suppositionsMatch) {
-        suppositionsUnify = true;
-      }
     }
 
     return suppositionsUnify;
   }
 
+  unifyLastProofAssertion(lastProofAssertion, substitutions, context) {
+    let lastProofAssertionUnifies = false;
+
+    const node = this.getNode(),
+          axiomString = this.getString(),
+          lastProofAssertionString = lastProofAssertion.getString();
+
+    context.trace(`Unifying the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom...`, node)
+
+    const statement = lastProofAssertion.getStatement(),
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+
+    if (statementUnifiesWithDeduction) {
+      lastProofAssertionUnifies = true;
+    }
+
+    if (lastProofAssertionUnifies) {
+      context.debug(`...unified the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom.`, node)
+    }
+
+    return lastProofAssertionUnifies;
+  }
+
   unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
     let axiomLemmaTheoremOrConjectureUnifies = false;
 

package/src/element/axiomLemmaTheoremConjecture.js

@@ -81,16 +81,45 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return supposition;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = this.labels.some((label) => {
-      const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = this.labels.some((label) => {
+      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
 
-      if (metavariableNameMatches) {
+      if (labelComparesToMetavariableName) {
         return true;
       }
     });
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
+  }
+
+  correlateHypotheses(context) {
+    let correlatesToHypotheses;
+
+    const hypothetical = this.isHypothetical();
+
+    if (hypothetical) {
+      const proofAssertions = context.getProofAssertions(),
+            axiomLemmaTheoremConjectureString = this.getString();  ///
+
+      context.trace(`Correlating the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`, this.node);
+
+      correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
+        const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
+
+        if (hypothesesComparesToStep) {
+          return true;
+        }
+      });
+
+      if (correlatesToHypotheses) {
+        context.debug(`...correlated the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`, this.node);
+      }
+    } else {
+      correlatesToHypotheses = true
+    }
+
+    return correlatesToHypotheses;
   }
 
   verify() {
@@ -171,35 +200,6 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return proofVerifies;
   }
 
-  correlateHypotheses(context) {
-    let hypothesesCorrelate;
-
-    const hypothetical = this.isHypothetical();
-
-    if (hypothetical) {
-      const steps = context.getSteps(),
-            topLevelAssertionString = this.string;  ///
-
-      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);
-
-      hypothesesCorrelate = correlate(this.hypotheses, steps, (hypothesis, step) => {
-        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
-
-        if (hypothesesEqualToStep) {
-          return true;
-        }
-      });
-
-      if (hypothesesCorrelate) {
-        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);
-      }
-    } else {
-      hypothesesCorrelate = true
-    }
-
-    return hypothesesCorrelate;
-  }
-
   unifyStatementWithDeduction(statement, substitutions, context) {
     let statementUnifiesWithDeduction = false;
 
@@ -212,18 +212,18 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementUnifiesWithDeduction;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
+  unifyStatementAndStepsOrSubproofs(statement, subproofOrProofAssertions, substitutions, context) {
     let statementAndStepsOrSubproofsUnifies = false;
 
-    const hypothesesCorrelate = this.correlateHypotheses(context);
+    const correlatesToHypotheses = this.correlateHypotheses(context);
 
-    if (hypothesesCorrelate) {
+    if (correlatesToHypotheses) {
       const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
-        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);
+        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, context);
 
-        if (stepsOrSubproofsUnifyWithSuppositions) {
+        if (subproofOrProofAssertionsUnifyWithSuppositions) {
           const substitutionsResolved = substitutions.areResolved();
 
           if (substitutionsResolved) {
@@ -236,43 +236,43 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementAndStepsOrSubproofsUnifies;
   }
 
-  unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiesWithSupposition = false;
+  unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
+    let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
     const context = specificContext,  ///
           suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
 
     if (suppositionUnifiesIndependently) {
-      stepsOrSubproofsUnifiesWithSupposition = true;
+      subproofOrProofAssertionsUnifiesWithSupposition = true;
     } else {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithSupposition = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithSupposition = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithSupposition;
+    return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
-  unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const stepsOrSubproofsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+    const subproofOrProofAssertionsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiesWithSupposition) {
+      if (subproofOrProofAssertionsUnifiesWithSupposition) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifyWithSuppositions;
+    return subproofOrProofAssertionsUnifyWithSuppositions;
   }
 
   toJSON() {
@@ -310,23 +310,4 @@ export default class AxiomLemmaTheoremConjecture extends Element {
 
     return axiomLemmaTheoremConjecture;
   }
-
-  static fromNode(Class, node, context) {
-    const topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNodes = topLevelAssertionNode.getLabelNodes(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          signatureNode = topLevelAssertionNode.getSignatureNode(),
-          proof = proofFromProofNode(proofNode, context),
-          labels = labelsFromLabelNodes(labelNodes, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          signature = signatureFromSignatureNode(signatureNode, context),
-          hypotheses = [],
-          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
-
-    return axiomLemmaTheoremConjecture;
-  }
 }