occam-verify-cli 1.0.776 → 1.0.785

package/src/process/unify.js

@@ -14,8 +14,9 @@ const typeNodeQuery = nodeQuery("/type"),
       frameNodeQuery = nodeQuery("/frame"),
       metaTypeNodeQuery = nodeQuery("/metaType"),
       statementNodeQuery = nodeQuery("/statement"),
+      metavariableNodeQuery = nodeQuery("/metavariable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      frameAMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
@@ -89,7 +90,7 @@ class MetaLevelPass extends ZipPassBase {
       }
     },
     {
-      generalNodeQuery: frameAMetavariableNodeQuery,
+      generalNodeQuery: frameMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
       run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
@@ -147,6 +148,98 @@ class MetaLevelPass extends ZipPassBase {
   ];
 }
 
+class AssumptionPass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: statementMetavariableNodeQuery,
+      specificNodeQuery: statementNodeQuery,
+      run: (generalStatementMetavariableNode, specificStatementNode, generalContext, specificContext) => {
+        let success = false;
+
+        const statementNode = specificStatementNode, ///
+              metavariableNode = generalStatementMetavariableNode,  ///
+              metavariableName = metavariableNode.getMetavariableName();
+
+        let context;
+
+        context = generalContext; ///
+
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        const statement = context.findStatementByStatementNode(statementNode),
+              substitution = null,
+              statementUnifies = metavariable.unifyStatement(statement, substitution, generalContext, specificContext);
+
+        if (statementUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: metavariableNodeQuery,
+      specificNodeQuery: metavariableNodeQuery,
+      run: (generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) => {
+        let success = false;
+
+        let context,
+            metavariableNode;
+
+        context = generalContext; ///
+
+        metavariableNode = generalMetavariableNode;  ///
+
+        const metavariableName = metavariableNode.getMetavariableName(),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        metavariableNode = specificMetavariableNode; ///
+
+        const reference = context.findReferenceByMetavariableNode(metavariableNode),
+              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
+
+        if (referenceUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 class CombinatorPass extends ZipPass {
   static maps = [
     {
@@ -307,7 +400,7 @@ class MetavariablePass extends ZipPass {
 class SubstitutionPass extends ZipPass {
   static maps = [
     {
-      generalNodeQuery: frameAMetavariableNodeQuery,
+      generalNodeQuery: frameMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
       run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
@@ -399,6 +492,7 @@ class IntrinsicLevelPass extends ZipPass {
 }
 
 const metaLevelPass = new MetaLevelPass(),
+      assumptionPass = new AssumptionPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
@@ -421,14 +515,30 @@ export function unifyStatement(generalStatement, specificStatement, generalConte
   return statementUnifies;
 }
 
+export function unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext) {
+  let assumptionUnifies = false;
+
+  const generalAssumptionNode = generalAssumption.getNode(),
+        specificAssumptionNode = specificAssumption.getNode(),
+        generalNode = generalAssumptionNode, ///
+        specificNode = specificAssumptionNode,  ///
+        success = assumptionPass.run(generalNode, specificNode, generalContext, specificContext);
+
+  if (success) {
+    assumptionUnifies = true;
+  }
+
+  return assumptionUnifies;
+}
+
 export function unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext) {
   let substitutionUnifies = false;
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
-        specificSubstitutionNode = specificSubstitution.getNode(),
-        generalNode = generalSubstitutionNode, ///
-        specificNode = specificSubstitutionNode,  ///
-        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
+    specificSubstitutionNode = specificSubstitution.getNode(),
+    generalNode = generalSubstitutionNode, ///
+    specificNode = specificSubstitutionNode,  ///
+    success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = true;

package/src/ruleNames.js

@@ -78,7 +78,6 @@ export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
 export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
-export const META_LEVEL_SUBSTITUTION_RULE_NAME = "metaLevelSubstitution";
 export const TYPE_PREFIX_DECLARATION_RULE_NAME = "typePrefixDeclaration";
 export const SIMPLE_TYPE_DECLARATION_RULE_NAME = "simpleTypeDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/utilities/context.js

@@ -91,13 +91,7 @@ export function nominally(innerFunction) {
 }
 
 export function simplify(innerFunction, context) {
-  let contextExtraneousContext = isContextExtraneousContext(context);
-
-  while (contextExtraneousContext) {
-    context = context.getContext();
-
-    contextExtraneousContext = isContextExtraneousContext(context);
-  }
+  context = removeExtraneousContexts(context);
 
   const ephemeralContext = EphemeralContext.fromNothing(context);
 
@@ -124,14 +118,14 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export async function asyncRestrict(innerFunction, metaLevelSubstitutions, context) {
+export async function asyncRestrict(innerFunction, assumptions, context) {
   if (context === undefined) {
-    context = metaLevelSubstitutions;  ///
+    context = assumptions;  ///
 
-    metaLevelSubstitutions = null;
+    assumptions = null;
   }
 
-  const proofContext = ProofContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
+  const proofContext = ProofContext.fromAssumptions(assumptions, context);
 
   context = proofContext;  ///
 
@@ -158,3 +152,41 @@ function isContextExtraneousContext(context) {
 
   return contextExtraneousContext;
 }
+
+function removeExtraneousContexts(context) {
+  context = trimExtraneousContexts(context);
+
+  const firstContext = context; ///
+
+  let currentContext = context; ///
+
+  while (currentContext !== null) {
+    context = currentContext.getContext();
+
+    context = trimExtraneousContexts(context);
+
+    currentContext.setContext(context);
+
+    currentContext = context; ///
+  }
+
+  context = firstContext; ///
+
+  return context;
+}
+
+function trimExtraneousContexts(context) {
+  let contextExtraneousContext = isContextExtraneousContext(context);
+
+  while (contextExtraneousContext) {
+    context = context.getContext();
+
+    if (context === null) {
+      break;
+    }
+
+    contextExtraneousContext = isContextExtraneousContext(context);
+  }
+
+  return context;
+}

package/src/utilities/element.js

@@ -348,11 +348,11 @@ export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        metaLevelSubstitutions = metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, assumptions);
 
   return metaLemma;
 }
@@ -437,20 +437,6 @@ export function conclusionFromConclusionNode(conclusionNode, context) {
   return conclusion;
 }
 
-export function assumptionFromAssumptionNode(assumptionNode, context) {
-  const { Assumption } = elements,
-        node = assumptionNode, ///
-        string = context.nodeAsString(node),
-        reference = referenceFromAssumptionNode(assumptionNode, context),
-        statement = statementFromAssumptionNode(assumptionNode, context);
-
-  context = null;
-
-  const assumption = new Assumption(context, string, node, reference, statement);
-
-  return assumption;
-}
-
 export function derivationFromDerivationNode(derivationNode, context) {
   const { Derivation } = elements,
         node = derivationNode,  ///
@@ -478,6 +464,20 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
   return typePrefix;
 }
 
+export function assumptionFromAssumptionNode(assumptionNode, context) {
+  const { Assumption } = elements,
+        node = assumptionNode,  ///
+        string = context.nodeAsString(node),
+        reference = referenceFromAssumptionNode(assumptionNode, context),
+        statement = statementFromAssumptionNode(assumptionNode, context);
+
+  context = null;
+
+  const assumption = new Assumption(context, string, node, reference, statement);
+
+  return assumption;
+}
+
 export function constructorFromConstructorNode(constructorNode, context) {
   const { Constructor } = elements,
         node = constructorNode, ///
@@ -525,11 +525,11 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        metaLevelSubstitutions = metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, assumptions);
 
   return metatheorem;
 }
@@ -788,21 +788,6 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
   return statementSubstitution;
 }
 
-export function metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const { MetaLevelSubstitution } = elements,
-        node = metaLevelSubstitutionNode,  ///
-        string = context.nodeAsString(node),
-        targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-        replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-        ephemeralContext = context.retrieveEphemeralContext();
-
-  context = ephemeralContext; ///
-
-  const metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
-
-  return metaLevelSubstitution;
-}
-
 export function constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   const { ConstructorDeclaration } = elements,
         node = constructorDeclarationNode, ///
@@ -1813,6 +1798,12 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
+export function assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const assumptions = [];
+
+  return assumptions;
+}
+
 export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const provisional = simpleTypeDeclarationNode.isProvisional();
 
@@ -1891,17 +1882,9 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
 export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
         targetReferenceString = context.nodeAsString(targetReferenceNode),
-        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
+        targetReference = referenceFromReferenceString(targetReferenceString, context);
 
-  return targetRefernece;
-}
-
-export function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
-        targetReferenceString = context.nodeAsString(targetReferenceNode),
-        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
-
-  return targetRefernece;
+  return targetReference;
 }
 
 export function targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
@@ -1950,19 +1933,6 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
-export function replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const replacementStatementNode = metaLevelSubstitutionNode.getReplacementStatementNode(),
-        replacementStatement = statementFromStatementNode(replacementStatementNode, context);
-
-  return replacementStatement;
-}
-
-export function metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const metaLevelSubstitutions = [];
-
-  return metaLevelSubstitutions;
-}
-
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);

package/src/utilities/json.js

@@ -703,22 +703,6 @@ export function propertyRelationsFromJSON(json, context) {
   return propertyRelations;
 }
 
-export function metaLevelSubstitutionsFromJSON(json, context) {
-  let { metaLevelSubstitutions } = json;  ///
-
-  const { MetaLevelSubstitution } = elements,
-        metaLevelSubstitutionsJSON = metaLevelSubstitutions; ///
-
-  metaLevelSubstitutions = metaLevelSubstitutionsJSON.map((metaLevelSubstitutionJSON) => {
-    const json = metaLevelSubstitutionJSON,  ///
-          metaLevelSubstitution = MetaLevelSubstitution.fromJSON(json, context);
-
-    return metaLevelSubstitution;
-  });
-
-  return metaLevelSubstitutions;
-}
-
 export function nameToNameJSON(name) {
   const nameJSON = name;  ///
 
@@ -1127,16 +1111,6 @@ export function propertyRelationsToPropertyRelationsJSON(propertyRelations) {
   return propertyRelationsJSON;
 }
 
-export function metaLevelSubstitutionsToMetaLevelSubstitutionsJSON(metaLevelSubstitutions) {
-  const metaLevelSubstitutionsJSON = metaLevelSubstitutions.map((metaLevelSubstitution) => {
-    const metaLevelSubstitutionJSON = metaLevelSubstitution.toJSON();
-
-    return metaLevelSubstitutionJSON;
-  });
-
-  return metaLevelSubstitutionsJSON;
-}
-
 function findTypeByName(name, context) {
   const typeName = name,  ///
         type = context.findTypeByTypeName(typeName);

package/src/utilities/string.js

@@ -117,20 +117,6 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
-export function metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions) {
-  const metaLevelSubstitutionsString = metaLevelSubstitutions.reduce((metaLevelSubstitutionsString, metaLevelSubstitution) => {
-    const metaLevelSubstitutionString = metaLevelSubstitution.getString();
-
-    metaLevelSubstitutionsString = (metaLevelSubstitutionsString === null) ?
-                                     metaLevelSubstitutionString: ///
-                                      `${metaLevelSubstitutionsString}, ${metaLevelSubstitutionString}`;
-
-    return metaLevelSubstitutionsString;
-  }, null);
-
-  return metaLevelSubstitutionsString;
-}
-
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;
@@ -151,6 +137,14 @@ export function typeStringFromNominalTypeName(nominalTypeName) {
   return typeString;
 }
 
+export function assumptionStringFromStatementAndReference(statement, reference) {
+  const statementString = statement.getString(),
+        referneceString = reference.getString(),
+        assumptionString = `${referneceString} :: ${statementString}`;
+
+  return assumptionString;
+}
+
 export function termSubstitutionStringFromTermAndVariable(term, variable) {
   const termString = term.getString(),
         variableString = variable.getString(),
@@ -198,14 +192,6 @@ export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavaria
   return string;
 }
 
-export function metaLevelSubstitutionStringFromStatementAndReference(statement, reference) {
-  const statementString = statement.getString(),
-        referenceString = reference.getString(),
-        metaLevelSubstitutionString = `[${statementString} for ${referenceString}]`;
-
-  return metaLevelSubstitutionString;
-}
-
 export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {
   const procedureReferenceName = procedureReference.getName(),
         parametersString = parametersStringFromParameters(parameters),

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;
 
@@ -59,17 +55,17 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
         statementUnifiesWithReference = true;
       }
     } else {
-      const metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
+      const metaLevel = context.isMetaLevel();
 
-      if (metaLevelSubstitutions) {
-        const { MetaLevelSubstitution } = elements,
-              metaLevelSubstitution = MetaLevelSubstitution.fromStatementAndReference(statement, reference, context),
-              generalContext = context, ///
-              specificContext = context;  ///
+      if (metaLevel) {
+        descend((context) => {
+          const { Assumption } = elements,
+                assumption = Assumption.fromStatementAndReference(statement, reference, context);
 
-        metaLevelSubstitution.validate(generalContext, specificContext);
+          assumption.validate(context, metaLevel);
 
-        statementUnifiesWithReference = true;
+          statementUnifiesWithReference = true;
+        }, context);
       }
     }
 
@@ -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();