occam-verify-cli 1.0.776 → 1.0.781

package/src/element/assertion/type.js

@@ -5,9 +5,9 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateTypeAssertion } from "../../process/instantiate";
-import { termFromTypeAssertionNode } from "../../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
+import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -229,4 +229,11 @@ export default define(class TypeAssertion extends Assertion {
 
     return typeAssertion;
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          typeAssertion = typeAssertionFromStatementNode(statementNode, context);
+
+    return typeAssertion;
+  }
 });

package/src/element/assumption.js

@@ -41,28 +41,21 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstituion = false;
+  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
+    let comparesToMetaLevelSubstitution = false;
 
     const assumptionString = this.getString(),  ///
-          substitutionString = substitution.getString();
+          metaLevelSubstitutionString = metaLevelSubstitution.getString();
 
-    context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
+    context.trace(`Comparing the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution...`);
 
-    const statement = substitution.getStatement(),
-          metavariableName = substitution.getMetavariableName(),
-          statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariableName(metavariableName);
+    debugger
 
-    if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
-      comparesToSubstituion = true;
+    if (comparesToMetaLevelSubstitution) {
+      context.debug(`...compared the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution.`);
     }
 
-    if (comparesToSubstituion) {
-      context.debug(`...compared the '${substitutionString}' assumption to the '${assumptionString}' substitution.`);
-    }
-
-    return comparesToSubstituion;
+    return comparesToMetaLevelSubstitution;
   }
 
   findValidAssumption(context) {
@@ -208,7 +201,6 @@ export default define(class Assumption extends Element {
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' derived assumption...`);
-
     const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
 
     if (topLevelMetaAssertion !== null) {

package/src/element/equivalences.js

@@ -203,8 +203,11 @@ export default define(class Equivalences extends Element {
   static fromNothing(context) {
     const string = EMPTY_STRING,
           node = null,
-          array = [],
-          equivalences = new Equivalences(context, string, node, array);
+          array = [];
+
+    context = null;
+
+    const equivalences = new Equivalences(context, string, node, array);
 
     return equivalences;
   }

package/src/element/frame.js

@@ -46,22 +46,6 @@ export default define(class Frame extends Element {
     return metavariableName;
   }
 
-  matchFrameNode(frameNode) {
-    const node = frameNode, ///
-          nodeMatches = this.matchNode(node),
-          frameNodeMatches = nodeMatches; ///
-
-    return frameNodeMatches;
-  }
-
-  findValidFrame(context) {
-    const frameNode = this.getFrameNode(),
-          frame = context.findFrameByFrameNode(frameNode),
-          validFrame = frame; ///
-
-    return validFrame;
-  }
-
   isEqualTo(frame) {
     const frameNode = frame.getNode(),
           frameNodeMatches = this.matchFrameNode(frameNode),
@@ -77,6 +61,26 @@ export default define(class Frame extends Element {
     return singular;
   }
 
+  matchFrameNode(frameNode) {
+    const node = frameNode, ///
+          nodeMatches = this.matchNode(node),
+          frameNodeMatches = nodeMatches; ///
+
+    return frameNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariableNodeMatches = this.metavariable.matchMetavariableNode(metavariableNode);
+    }
+
+    return metavariableNodeMatches;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -97,26 +101,46 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
+  compareMetavariableName(metavariableName) {
+    let comparesToMetavariableName = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const metavariableNameA = metavariableName ///
+
+      metavariableName = this.getMetavariableName();
+
+      const metavariableNameB = metavariableName; ///
+
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    }
+
+    return comparesToMetavariableName;
+  }
+
   compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution = false;
+    let comparesToMetaLevelSubstitution;
 
     const frameString = this.getString(),  ///
-          metaLevelSubstitutioString = metaLevelSubstitution.getString();
+          metaLevelSubstitutionString = metaLevelSubstitution.getString();
 
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-level substitutio...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution...`);
 
-    if (!comparesToMetaLevelSubstitution) {
-      comparesToMetaLevelSubstitution = this.assumptions.some((assumption) => {
-        const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
+    const metavariableNode = this.metavariable.getNode(),
+          judgements = context.findJudgementsByMetavariableNode(metavariableNode),
+          assumptions = assumptionsFromJudgements(judgements);
 
-        if (assumptionComparesToSubstitution) {
-          return true;
-        }
-      });
-    }
+    comparesToMetaLevelSubstitution = assumptions.some((assumption) => {
+      const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
+
+      if (assumptionComparesToSubstitution) {
+        return true;
+      }
+    });
 
     if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-Level-substituution.`);
+      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution.`);
     }
 
     return comparesToMetaLevelSubstitution;
@@ -128,7 +152,7 @@ export default define(class Frame extends Element {
     const frameString = this.getString(),  ///
           metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
 
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitutio...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitution...`);
 
     comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
       const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
@@ -145,22 +169,12 @@ export default define(class Frame extends Element {
     return comparesToMetaLevelSubstitutions;
   }
 
-  compareMetavariableName(metavariableName) {
-    let comparesToMetavariableName = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
-    }
+  findValidFrame(context) {
+    const frameNode = this.getFrameNode(),
+          frame = context.findFrameByFrameNode(frameNode),
+          validFrame = frame; ///
 
-    return comparesToMetavariableName;
+    return validFrame;
   }
 
   validate(context) {
@@ -378,3 +392,12 @@ function assumptionsFromFrameNode(frameNode, context) {
   return assumptions;
 }
 
+function assumptionsFromJudgements(judgements) {
+  const assumptions = judgements.map((judgement) => {
+    const assumption = judgement.getAssumption();
+
+    return assumption;
+  });
+
+  return assumptions;
+}

package/src/element/judgement.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateJudgement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
+import { judgementFromStatementNode } from "../utilities/element";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -19,7 +20,7 @@ export default define(class Judgement extends Element {
     return this.frame;
   }
 
-  getDeclaration() {
+  getAssumption() {
     return this.assumption;
   }
 
@@ -47,6 +48,8 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
+
   compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
 
   findValidJudgement(context) {
@@ -235,6 +238,13 @@ export default define(class Judgement extends Element {
       return judgement;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          judgement = judgementFromStatementNode(statementNode, context);
+
+    return judgement;
+  }
 });
 
 function frameFromJudgementNode(judgementNode, context) {

package/src/element/metavariable.js

@@ -10,7 +10,7 @@ import { EMPTY_STRING } from "../constants";
 import { instantiateMetavariable } from "../process/instantiate";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
-import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode } from "../utilities/element";
+import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode, metavariableFromStatementNode } from "../utilities/element";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, term, type, metaType) {
@@ -58,6 +58,14 @@ export default define(class Metavariable extends Element {
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
+  matchMetavariableNode(metavariableNode) {
+    const node = metavariableNode, ///
+          nodeMatches = this.matchNode(node),
+          metavariableNodeMatches = nodeMatches; ///
+
+    return metavariableNodeMatches;
+  }
+
   compare(metavariable) {
     const metavariableName = metavariable.getName(),
           comparesToMetavariableName = this.compareMetavariableName(metavariableName),
@@ -73,14 +81,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const node = metavariableNode, ///
-          nodeMatches = this.matchNode(node),
-          metavariableNodeMatches = nodeMatches; ///
-
-    return metavariableNodeMatches;
-  }
-
   verify(context) {
     let verifies = false;
 
@@ -625,4 +625,11 @@ export default define(class Metavariable extends Element {
       return metavariable;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          metavariable = metavariableFromStatementNode(statementNode, context);
+
+    return metavariable;
+  }
 });

package/src/element/proofAssertion/step.js

@@ -2,11 +2,11 @@
 
 import { asynchronousUtilities } from "occam-languages";
 
+import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { propertyAssertionFromStatement } from "../../utilities/statement";
 import { derive, attempt, descend, asyncReconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities;
@@ -49,8 +49,9 @@ export default define(class Step extends ProofAssertion {
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
-    const statement = this.getStatement(),
-          propertyAssertion = propertyAssertionFromStatement(statement, context);
+    const { PropertyAssertion } = elements,
+          statement = this.getStatement(),
+          propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);

package/src/utilities/unification.js

@@ -5,10 +5,6 @@ import { arrayUtilities } from "necessary";
 import elements from "../elements";
 
 import { descend } from "./context";
-import { judgementFromStatement,
-         typeAssertionFromStatement,
-         propertyAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../utilities/statement";
 
 const { backwardsSome } = arrayUtilities;
 
@@ -84,7 +80,9 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
 async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsSatisfiesAssertion = false;
 
-  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+  const { SatisfiesAssertion } = elements;
+
+  satisfiesAssertion = SatisfiesAssertion.fromStatement(statement, context);
 
   if (satisfiesAssertion !== null) {
     const statementString = statement.getString();
@@ -202,7 +200,8 @@ async function unifyStatementAsJudgement(statement, reference, satisfiesAssertio
   let statementUnifiesAsJudgement = false;
 
   if (reference === null) {
-    const judgement = judgementFromStatement(statement, context);
+    const { Judgement } = elements,
+          judgement = Judgement.fromStatement(statement, context);
 
     if (judgement !== null) {
       const statementString = statement.getString();
@@ -224,7 +223,8 @@ async function unifyStatementAsTypeAssertion(statement, reference, satisfiesAsse
   let statementUnifiesAsTypeAssertion = false;
 
   if (reference === null) {
-    const typeAssertion = typeAssertionFromStatement(statement, context);
+    const { TypeAssertion } = elements,
+          typeAssertion = TypeAssertion.fromStatement(statement, context);
 
     if (typeAssertion !== null) {
       const statementString = statement.getString();
@@ -244,7 +244,8 @@ async function unifyStatementAsPropertyAssertion(statement, reference, satisfies
   let statementUnifiesAsPropertyAssertion = false;
 
   if (reference === null) {
-    const propertyAssertion = propertyAssertionFromStatement(statement, context);
+    const { PropertyAssertion } = elements,
+          propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       const statementString = statement.getString();

package/src/utilities/validation.js

@@ -4,14 +4,6 @@ import elements from "../elements";
 
 import { choose, descend } from "./context";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
-import { judgementFromStatement,
-         metavariableFromStatement,
-         typeAssertionFromStatement,
-         definedAssertionFromStatement,
-         propertyAssertionFromStatement,
-         subproofAssertionFromStatement,
-         containedAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../utilities/statement";
 
 function validateTermAsVariable(term, context, validateForwards) {
   let termValidatesAsVariable = false;
@@ -91,9 +83,11 @@ function unifyTermWithBracketedConstructor(term, context, validateForwards) {
 function validateStatementAsMetavariable(statement, context) {
   let statementValidatesAsMetavariable = false;
 
+  const { Metavariable } = elements;
+
   let metavariable;
 
-  metavariable = metavariableFromStatement(statement, context);
+  metavariable = Metavariable.fromStatement(statement, context);
 
   if (metavariable !== null) {
     const statementString = statement.getString();
@@ -206,7 +200,9 @@ function validateStatementAsJudgement(statement, context) {
 
   let judgement;
 
-  judgement = judgementFromStatement(statement, context);
+  const { Judgement } = elements;
+
+  judgement = Judgement.fromStatement(statement, context);
 
   if (judgement !== null) {
     const statementString = statement.getString();
@@ -230,9 +226,11 @@ function validateStatementAsJudgement(statement, context) {
 function validateStatementAsTypeAssertion(statement, context) {
   let validatesStatementAsTypeAssertion = false;
 
+  const { TypeAssertion } = elements;
+
   let typeAssertion;
 
-  typeAssertion = typeAssertionFromStatement(statement, context);
+  typeAssertion = TypeAssertion.fromStatement(statement, context);
 
   if (typeAssertion !== null) {
     const statementString = statement.getString();
@@ -256,9 +254,11 @@ function validateStatementAsTypeAssertion(statement, context) {
 function validateStatementAsDefinedAssertion(statement, context) {
   let validatesStatementAsDefinedAssertion = false;
 
+  const { DefinedAssertion } = elements;
+
   let definedAssertion;
 
-  definedAssertion = definedAssertionFromStatement(statement, context);
+  definedAssertion = DefinedAssertion.fromStatement(statement, context);
 
   if (definedAssertion !== null) {
     const statementString = statement.getString();
@@ -282,9 +282,11 @@ function validateStatementAsDefinedAssertion(statement, context) {
 function validateStatementAsPropertyAssertion(statement, context) {
   let statementValidatesAsPropertyAssertion = false;
 
+  const { PropertyAssertion } = elements;
+
   let propertyAssertion;
 
-  propertyAssertion = propertyAssertionFromStatement(statement, context);
+  propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
   if (propertyAssertion !== null) {
     const statementString = statement.getString();
@@ -308,9 +310,11 @@ function validateStatementAsPropertyAssertion(statement, context) {
 function validateStatementAsSubproofAssertion(statement, context) {
   let statementValidatesAsSubproofAssertion = false;
 
+  const { SubproofAssertion } = elements;
+
   let subproofAssertion;
 
-  subproofAssertion = subproofAssertionFromStatement(statement, context);
+  subproofAssertion = SubproofAssertion.fromStatement(statement, context);
 
   if (subproofAssertion !== null) {
     const statementString = statement.getString();
@@ -334,9 +338,11 @@ function validateStatementAsSubproofAssertion(statement, context) {
 function validateStatementAsContainedAssertion(statement, context) {
   let validatesStatementAsContainedAssertion = false;
 
+  const { ContainedAssertion } = elements;
+
   let containedAssertion;
 
-  containedAssertion = containedAssertionFromStatement(statement, context);
+  containedAssertion = ContainedAssertion.fromStatement(statement, context);
 
   if (containedAssertion !== null) {
     const statementString = statement.getString();
@@ -360,9 +366,11 @@ function validateStatementAsContainedAssertion(statement, context) {
 function validateStatementAsSatisfiesAssertion(statement, context) {
   let validatesAStatementsSatisfiesAssertion = false;
 
+  const { SatisfiesAssertion } = elements;
+
   let satisfiesAssertion;
 
-  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+  satisfiesAssertion = SatisfiesAssertion.fromStatement(statement, context);
 
   if (satisfiesAssertion !== null) {
     const statementString = statement.getString();

package/lib/utilities/statement.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get containedAssertionFromStatement () {
-        return containedAssertionFromStatement;
-    },
-    get definedAssertionFromStatement () {
-        return definedAssertionFromStatement;
-    },
-    get judgementFromStatement () {
-        return judgementFromStatement;
-    },
-    get metavariableFromStatement () {
-        return metavariableFromStatement;
-    },
-    get propertyAssertionFromStatement () {
-        return propertyAssertionFromStatement;
-    },
-    get satisfiesAssertionFromStatement () {
-        return satisfiesAssertionFromStatement;
-    },
-    get subproofAssertionFromStatement () {
-        return subproofAssertionFromStatement;
-    },
-    get typeAssertionFromStatement () {
-        return typeAssertionFromStatement;
-    }
-});
-const _element = require("../utilities/element");
-function judgementFromStatement(statement, context) {
-    const statementNode = statement.getNode(), judgement = (0, _element.judgementFromStatementNode)(statementNode, context);
-    return judgement;
-}
-function metavariableFromStatement(statement, context) {
-    const statementNode = statement.getNode(), metavariable = (0, _element.metavariableFromStatementNode)(statementNode, context);
-    return metavariable;
-}
-function typeAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), typeAssertion = (0, _element.typeAssertionFromStatementNode)(statementNode, context);
-    return typeAssertion;
-}
-function definedAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), definedAssertion = (0, _element.definedAssertionFromStatementNode)(statementNode, context);
-    return definedAssertion;
-}
-function propertyAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), propertyAssertion = (0, _element.propertyAssertionFromStatementNode)(statementNode, context);
-    return propertyAssertion;
-}
-function subproofAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), subproofAssertion = (0, _element.subproofAssertionFromStatementNode)(statementNode, context);
-    return subproofAssertion;
-}
-function containedAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), containedAssertion = (0, _element.containedAssertionFromStatementNode)(statementNode, context);
-    return containedAssertion;
-}
-function satisfiesAssertionFromStatement(statement, context) {
-    const statementNode = statement.getNode(), satisfiesAssertion = (0, _element.satisfiesAssertionFromStatementNode)(statementNode, context);
-    return satisfiesAssertion;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/utilities/statement.js

@@ -1,66 +0,0 @@
-"use strict";
-
-import { judgementFromStatementNode,
-         metavariableFromStatementNode,
-         typeAssertionFromStatementNode,
-         definedAssertionFromStatementNode,
-         propertyAssertionFromStatementNode,
-         subproofAssertionFromStatementNode,
-         containedAssertionFromStatementNode,
-         satisfiesAssertionFromStatementNode } from "../utilities/element";
-
-export function judgementFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        judgement = judgementFromStatementNode(statementNode, context);
-
-  return judgement;
-}
-
-export function metavariableFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        metavariable = metavariableFromStatementNode(statementNode, context);
-
-  return metavariable;
-}
-
-export function typeAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        typeAssertion = typeAssertionFromStatementNode(statementNode, context);
-
-  return typeAssertion;
-}
-
-export function definedAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        definedAssertion = definedAssertionFromStatementNode(statementNode, context);
-
-  return definedAssertion;
-}
-
-export function propertyAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        propertyAssertion = propertyAssertionFromStatementNode(statementNode, context);
-
-  return propertyAssertion;
-}
-
-export function subproofAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        subproofAssertion = subproofAssertionFromStatementNode(statementNode, context);
-
-  return subproofAssertion;
-}
-
-export function containedAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        containedAssertion = containedAssertionFromStatementNode(statementNode, context);
-
-  return containedAssertion;
-}
-
-export function satisfiesAssertionFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
-
-  return satisfiesAssertion;
-}