occam-verify-cli 1.0.444 → 1.0.457

package/src/element/{supposition.js → proofAssertion/supposition.js}

@@ -1,25 +1,19 @@
 "use strict";
 
-import Element from "../element";
-import elements from "../elements";
-import TemporaryContext from "../context/temporary";
-import assignAssignments from "../process/assign";
+import ProofAssertion from "../proofAssertion";
+import TransientContext from "../../context/transient";
+import assignAssignments from "../../process/assign";
 
-import { define } from "../elements";
-import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
+import { define } from "../../elements";
+import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
 
-export default define(class Supposition extends Element {
+export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getProcedureCall() {
     return this.procedureCall;
   }
@@ -27,32 +21,32 @@ export default define(class Supposition extends Element {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           suppositionString = this.getString(); ///
 
     context.trace(`Verifying the '${suppositionString}' supposition...`, node);
 
-    if ((this.statement === null) && (this.procedureCall === null)) {
+    const statement = this.getStatement();
+
+    if ((statement === null) && (this.procedureCall === null)) {
       context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);
     } else {
-      if (this.statement !== null) {
+      if (statement !== null) {
         const stated = true,
               assignments = [],
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
-            const { Step } = elements,
-                  step = Step.fromStatement(this.statement, context),
-                  stepOrSubproof = step;  ///
+            const subproofOrProofAssertion = this;  ///
 
-            context.addStepOrSubproof(stepOrSubproof);
+            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
             verifies = true;
           }
@@ -82,10 +76,9 @@ export default define(class Supposition extends Element {
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString();
+    const suppositionString = this.getString();
 
-    context.trace(`Unifying the '${suppositionString}' supposition independently...`, node);
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
     const specificContext = context;  ///
 
@@ -95,8 +88,10 @@ export default define(class Supposition extends Element {
 
     context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    const statement = this.getStatement();
+
+    if (statement !== null) {
+      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -112,119 +107,125 @@ export default define(class Supposition extends Element {
     }
 
     if (unifiesIndependently) {
-      context.debug(`...unified the '${suppositionString}' supposition independenly.`, node);
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`);
     }
 
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
-    let stepOrSubproofUnifies = false;
+  unifySubproofOrProosAssertion(subproofOrProofAssertion, substitutions, context) {
+    let subproofOrProofAssertionUnifies = false;
 
-    const stepOrSubProofStep = stepOrSubproof.isStep(),
-          subproof = stepOrSubProofStep ?
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+          subproof = subproofOrProofAssertionProofAssertion ?
                         null :
-                          stepOrSubproof,
-          step = stepOrSubProofStep ?
-                   stepOrSubproof :
-                     null;
+                          subproofOrProofAssertion,
+          proofAssertion = subproofOrProofAssertionProofAssertion ?
+                             subproofOrProofAssertion :
+                               null;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
-      stepOrSubproofUnifies = subproofUnifies; ///
+      if (subproofUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
 
-      stepOrSubproofUnifies = statementUnifies;  ///
+      if (proofAssertionUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (stepOrSubproofUnifies) {
+    if (subproofOrProofAssertionUnifies) {
       substitutions.resolve(context);
     }
 
-    stepOrSubproofUnifies ?
+    subproofOrProofAssertionUnifies ?
       substitutions.continue() :
         substitutions.rollback(context);
 
-    return stepOrSubproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
-    let subproofUnifies = false;
+  unifyProofAssertion(proofAssertion, substitutions, context) {
+    let proofAssertionUnifies = false;
 
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    context.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+    const suppositionString = this.getString(),
+          proofAssertionString = proofAssertion.getString();
 
-    const specificContext = context;  ///
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition...`);
 
     context = this.getContext();
 
-    const generalContext = context;  ///
+    const generalContext = context; ///
 
-    context = specificContext;  ///
+    context = proofAssertion.getContext();
 
-    if (this.statement !== null) {
-      const node = this.getNode(),
-            assertionNode = node, /// 
-            assertion = context.findAssertionByAssertionNode(assertionNode);
+    const specificContext = context;  ///
 
-      if (assertion !== null) {}
+    context = specificContext;  ///
 
-      if (subproofAssertion !== null) {
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-      }
+    const statement = proofAssertion.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
     }
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
     }
 
-    return subproofUnifies;
+    return proofAssertionUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies;
+  unifySubproof(subproof, substitutions, context) {
+    let subproofUnifies = false;
 
-    context = step.getContext();
+    const node = this.getNode(),
+          subproofString = subproof.getString(),
+          suppositionString = this.getString();
 
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, context);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`, node);
 
-    stepUnifies = statementUnifies;  ///
+    const specificContext = context;  ///
 
-    return stepUnifies;
-  }
+    context = this.getContext();
 
-  unifyStatement(statement, substitutions, context) {
-    let statementUnifies;
+    const generalContext = context; ///
+
+    context = specificContext;  ///
 
-    const supposition = this, ///
-          statementString = statement.getString(),
-          suppositionString = supposition.getString();
+    const statement = this.getStatement();
+
+    if (statement !== null) {
+      const statementNode = statement.getNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              assertionNode = subproofAssertionNode,  ///
+              assertion = context.findAssertionByAssertionNode(assertionNode)
 
-    if (this.statement !== null) {
-      const generalContext = this.context,  ///
-            specificContext = context;  ///
+        if (assertion !== null) {
+          const subproofAssertion = assertion;  ///
 
-      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        }
+      }
     }
 
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`, node);
     }
 
-    return statementUnifies;
+    return subproofUnifies;
   }
 
   unifySupposition(supposition, substitutions, generalContext, specificContext) {
@@ -286,7 +287,7 @@ export default define(class Supposition extends Element {
           frames = framesFromJSON(json, context),
           statement = statementFromJSON(json, context),
           procedureCall = procedureCallFromJSON(json, context),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -300,7 +301,7 @@ export default define(class Supposition extends Element {
 
     const node = null;
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const supposition = new Supposition(context, string, node, statement, procedureCall);
 

package/src/element/proofAssertion.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import Element from "../element";
+
+import { equateStatements } from "../process/equate";
+
+export default class ProofAssertion extends Element {
+  constructor(context, string, node, statement) {
+    super(context, string, node);
+
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  isProofAssertion() {
+    const proofAssertion = true;
+
+    return proofAssertion;
+  }
+
+  compareStatement(statement, context) {
+    let comparesToStatement = false;
+
+    const statementString = statement.getString(),
+          proofAssertionString = this.getString();
+
+    context.trace(`Comparing the '${statementString}' statement to the '${proofAssertionString}' proof assertion...`);
+
+    const leftStatement = statement,  ///
+          rightStatement = this.statement,  ///
+          leftStatementNode = leftStatement.getNode(),
+          rightStatementNode = rightStatement.getNode(),
+          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
+
+    if (statementsEquate) {
+      comparesToStatement = true;
+    }
+
+    if (comparesToStatement) {
+      context.debug(`...compared the '${statementString}' statement to the '${proofAssertionString}' proof assertion.`);
+    }
+
+    return comparesToStatement;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnifies = false;
+
+    if (this.statement !== null) {
+      const node = this.getNode(),
+            context = specificContext, ///
+            statementString = statement.getString(),
+            proorAssertionString = this.getString();  ///
+
+      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`, node);
+
+      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      if (statementUnifies) {
+        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`, node);
+      }
+    }
+
+    return statementUnifies;
+  }
+}

package/src/element/reference.js

@@ -4,7 +4,8 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { referenceMetaTypeFromNothing } from "../metaTypes";
+import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
@@ -39,45 +40,48 @@ export default define(class Reference extends Element {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
 
-  verify(context) {
-    let verifies = false;
+  validate(context) {
+    let validate = false;
 
     const referenceString = this.getString(); ///
 
-    context.trace(`Verifying the '${referenceString}' reference...`);
+    context.trace(`Validating the '${referenceString}' reference...`);
 
-    if (!verifies) {
+    if (!validate) {
       const metavariableValidates = this.validateMetavariable(context);
 
-      verifies = metavariableValidates; ///
+      validate = metavariableValidates; ///
     }
 
-    if (!verifies) {
+    if (!validate) {
       const reference = this, ///
             labelPresent = context.isLabelPresentByReference(reference);
 
-      verifies = labelPresent;  ///
+      validate = labelPresent;  ///
     }
 
-    if (verifies) {
+    if (validate) {
       const reference = this; ///
 
       context.addReference(reference);
 
-      context.debug(`...verified the '${referenceString}' reference.`);
+      context.debug(`...validated the '${referenceString}' reference.`);
     }
 
-    return verifies;
+    return validate;
   }
 
   validateMetavariable(context) {
-    let metavariableValidates;
+    let metavariableValidates = false;
 
-    const referenceMetaType = referenceMetaTypeFromNothing(),
+    const metaTypeName = REFERENCE_META_TYPE_NAME,
+          referenceMetaType = findMetaTypeByMetaTypeName(metaTypeName),
           metaType = referenceMetaType, ///
           metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
-    metavariableValidates = metavariableValidatesGivenMetaType; ///
+    if (metavariableValidatesGivenMetaType) {
+      metavariableValidates = true;
+    }
 
     return metavariableValidates;
   }
@@ -139,27 +143,27 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUnifies;
 
     const reference = this, ///
           referenceString = reference.getString(),
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
     const { Substitutions } = elements,
-          label = metaLemmaMetatheorem.getLabel(),
+          label = topLevelMetaAssertion.getLabel(),
           substitutions = Substitutions.fromNothing(),
           labelUnifies = this.unifyLabel(label, substitutions, context);
 
-    metaLemmaMetatheoremUnifies = labelUnifies;  ///
+    topLevelMetaAssertionUnifies = labelUnifies;  ///
 
-    if (metaLemmaMetatheoremUnifies) {
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${referenceString}' reference.`);
+    if (topLevelMetaAssertionUnifies) {
+      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
     }
 
-    return metaLemmaMetatheoremUnifies;
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/rule.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { define } from "../elements";
 import { labelsFromJSON,
@@ -70,9 +70,9 @@ export default define(class Rule extends Element {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromNothing(context);
+      const scopedContext = ScopedContext.fromNothing(context);
 
-      context = localContext; ///
+      context = scopedContext; ///
 
       const premisesVerify = this.verifyPremises(context);
 
@@ -165,68 +165,68 @@ export default define(class Rule extends Element {
     return statementUnifiesWithConclusion;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementAndStepsOrSubproofsUnify = false;
+  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
+    let statementAndSubproofOrProofAssertionsUnify = false;
 
     const { Substitutions } = elements,
           substitutions = Substitutions.fromNothing(),
           statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
 
     if (statementUnifiesWithConclusion) {
-      const stepsOrSubproofsUnifiesWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context);
+      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context);
 
-      if (stepsOrSubproofsUnifiesWithPremises) {
+      if (subproofOrProofAssertionsUnifiesWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
         if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
+          statementAndSubproofOrProofAssertionsUnify = true;
         }
       }
     }
 
-    return statementAndStepsOrSubproofsUnify;
+    return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context) {
-    let stepsOrSubproofsUnifiesWithPremise = false;
+  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremise = false;
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
       const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
 
       if (premiseUnifiesIndependently) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, context);
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithPremise;
+    return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context);
+    const subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context);
 
       if (stepUnifiesWithPremise) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifiesWithPremises;
+    return subproofOrProofAssertionsUnifiesWithPremises;
   }
 
   toJSON() {

package/src/element/section.js

@@ -45,11 +45,11 @@ export default define(class Section extends Element {
     const hypothesesVerify = this.verifyHypotheses();
 
     if (hypothesesVerify) {
-      const axiomLemmaTheoremOrConjecture = (this.axiom || this.lemma || this.theorem || this.conjecture),
-            axiomLemmaTheoremOrConjectureVerifies = axiomLemmaTheoremOrConjecture.verify(this.context);
+      const topLevelAssertion = (this.axiom || this.lemma || this.theorem || this.conjecture),
+            topLevelAssertionVerifies = topLevelAssertion.verify(this.context);
 
-      if (axiomLemmaTheoremOrConjectureVerifies) {
-        axiomLemmaTheoremOrConjecture.setHypotheses(this.hypotheses);
+      if (topLevelAssertionVerifies) {
+        topLevelAssertion.setHypotheses(this.hypotheses);
 
         verifies = true;
       }

package/src/element/statement.js

@@ -18,15 +18,8 @@ export default define(class Statement extends Element {
   }
 
   getMetavariableName() {
-    let metavariableName = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const node = this.getNode();
-
-      metavariableName = node.getMetavariableName();
-    }
+    const node = this.getNode(),
+          metavariableName = node.getMetavariableName();
 
     return metavariableName;
   }
@@ -254,19 +247,19 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  compareStepsOrSubproofs(stepsOrSubproofs, context) {
-    let comparesToStepsOrSubproofs;
+  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
+    let comparesToSubproofOrProofAssertions;
 
-    comparesToStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
       const statement = this, ///
-            stepOrSubproofComparesToStatement = stepOrSubproof.compareStatement(statement, context);
+            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
 
-      if (stepOrSubproofComparesToStatement) {
+      if (subproofOrProofAssertionComparesToStatement) {
         return true;
       }
     });
 
-    return comparesToStepsOrSubproofs;
+    return comparesToSubproofOrProofAssertions;
   }
 
   toJSON() {