occam-verify-cli 1.0.437 → 1.0.444

package/lib/utilities/validation.js

@@ -0,0 +1,251 @@
+"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 validateStatements () {
+        return validateStatements;
+    },
+    get validateTerms () {
+        return validateTerms;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_default(require("../elements"));
+var _statement = require("../utilities/statement");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function unifyTermWithBracketedConstructor(term, context, validateAhead) {
+    var termUnifiesWithBracketedConstructor;
+    var BracketedConstructor = _elements.default.BracketedConstructor, bracketedConstructor = BracketedConstructor.fromNothing();
+    termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);
+    return termUnifiesWithBracketedConstructor;
+}
+function unifyTermWithConstructors(term, context, validateAhead) {
+    var termUnifiesWithConstructors;
+    var constructors = context.getConstructors();
+    termUnifiesWithConstructors = constructors.some(function(constructor) {
+        var unifiesWithConstructor = constructor.unifyTerm(term, context, validateAhead);
+        if (unifiesWithConstructor) {
+            return true;
+        }
+    });
+    return termUnifiesWithConstructors;
+}
+function validateTermAsVariable(term, context, validateAhead) {
+    var termValidatesAsVariable = false;
+    var Variable = _elements.default.Variable, termNode = term.getNode(), singularVariableNode = termNode.getSingularVariableNode();
+    if (singularVariableNode !== null) {
+        var variable;
+        var termString = term.getString(), variableNode = singularVariableNode; ///
+        variable = Variable.fromVariableNode(variableNode, context);
+        context.trace("Verifying the '".concat(termString, "' term as a variable..."));
+        var variableValidates = variable.validate(context);
+        if (variableValidates) {
+            var verifiesAhead;
+            var variableIdentifier = variable.getIdentifier();
+            variable = context.findVariableByVariableIdentifier(variableIdentifier);
+            var type = variable.getType();
+            term.setType(type);
+            verifiesAhead = validateAhead();
+            termValidatesAsVariable = verifiesAhead; ///
+        }
+        if (termValidatesAsVariable) {
+            context.debug("...verified the '".concat(termString, "' term as a variable."));
+        }
+    }
+    return termValidatesAsVariable;
+}
+function validateStatementAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+    var statementValidatesAsMetavariableAndSubstitution = false;
+    var metavariable = (0, _statement.metavariableFromStatement)(statement, context);
+    if (metavariable !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a metavariable and substitution..."));
+        var metavariableValidates = metavariable.validate(context);
+        if (metavariableValidates) {
+            var TermSubstitution = _elements.default.TermSubstitution, FrameSubstitution = _elements.default.FrameSubstitution, frameSubstitution = FrameSubstitution.fromStatement(statement, context), termSubstitution = TermSubstitution.fromStatement(statement, context), substitution = termSubstitution || frameSubstitution;
+            if (substitution !== null) {
+                var substitutionValidates = substitution.validate(context);
+                if (substitutionValidates) {
+                    statementValidatesAsMetavariableAndSubstitution = true;
+                }
+            } else {
+                statementValidatesAsMetavariableAndSubstitution = true;
+            }
+        }
+        if (statementValidatesAsMetavariableAndSubstitution) {
+            context.debug("...validated the '".concat(statementString, "' statement as a metavariable and substitution."));
+        }
+    }
+    return statementValidatesAsMetavariableAndSubstitution;
+}
+function unifyStatementWithBracketedCombinator(statement, assignments, stated, context) {
+    stated = true; ///
+    assignments = null; ///
+    var BracketedCombinator = _elements.default.BracketedCombinator, bracketedCombinator = BracketedCombinator.fromNothing(), statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
+    return statementUnifiesWithBracketedCombinator;
+}
+function unifyStatementWithCombinators(statement, assignments, stated, context) {
+    stated = true; ///
+    assignments = null; ///
+    var combinators = context.getCombinators(), statementUnifiesWithCombinators = combinators.some(function(combinator) {
+        var unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
+        if (unifiesWithCombinator) {
+            return true;
+        }
+    });
+    return statementUnifiesWithCombinators;
+}
+function validateStatementAsEquality(statement, assignments, stated, context) {
+    var statementValidatesAsEquality = false;
+    var equality = (0, _statement.equalityFromStatement)(statement, context);
+    if (equality !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as an equality..."));
+        var equalityValidates = equality.validate(assignments, stated, context);
+        statementValidatesAsEquality = equalityValidates; ///
+        if (statementValidatesAsEquality) {
+            context.debug("...validated the '".concat(statementString, "' statement as an equality."));
+        }
+    }
+    return statementValidatesAsEquality;
+}
+function validateStatementAsJudgement(statement, assignments, stated, context) {
+    var validatesStatementAsJudgement = false;
+    var judgement = (0, _statement.judgementFromStatement)(statement, context);
+    if (judgement !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a judgement..."));
+        var judgementValidates = judgement.validate(assignments, stated, context);
+        validatesStatementAsJudgement = judgementValidates; ///
+        if (validatesStatementAsJudgement) {
+            context.debug("...validated the '".concat(statementString, "' statement as a judgement."));
+        }
+    }
+    return validatesStatementAsJudgement;
+}
+function validateStatementAsTypeAssertion(statement, assignments, stated, context) {
+    var validatesStatementAsTypeAssertion = false;
+    var typeAssertion = (0, _statement.typeAssertionFromStatement)(statement, context);
+    if (typeAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a type assertion..."));
+        var typeAssertionValidates = typeAssertion.validate(assignments, stated, context);
+        validatesStatementAsTypeAssertion = typeAssertionValidates; ///
+        if (validatesStatementAsTypeAssertion) {
+            var assertion = typeAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a type assertion."));
+        }
+    }
+    return validatesStatementAsTypeAssertion;
+}
+function validateStatementAsDefinedAssertion(statement, assignments, stated, context) {
+    var validatesStatementAsDefinedAssertion = false;
+    var definedAssertion = (0, _statement.definedAssertionFromStatement)(statement, context);
+    if (definedAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a defined assertion..."));
+        var definedAssertionValidates = definedAssertion.validate(assignments, stated, context);
+        validatesStatementAsDefinedAssertion = definedAssertionValidates; ///
+        if (validatesStatementAsDefinedAssertion) {
+            var assertion = definedAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a defined assertion."));
+        }
+    }
+    return validatesStatementAsDefinedAssertion;
+}
+function validateStatementAsPropertyAssertion(statement, assignments, stated, context) {
+    var statementValidatesAsPropertyAssertion = false;
+    var propertyAssertion = (0, _statement.propertyAssertionFromStatement)(statement, context);
+    if (propertyAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a property assertion..."));
+        var propertyAssertionValidates = propertyAssertion.validate(assignments, stated, context);
+        statementValidatesAsPropertyAssertion = propertyAssertionValidates; ///
+        if (statementValidatesAsPropertyAssertion) {
+            var assertion = propertyAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a property assertion."));
+        }
+    }
+    return statementValidatesAsPropertyAssertion;
+}
+function validateStatementAsSubproofAssertion(statement, assignments, stated, context) {
+    var statementValidatesAsSubproofAssertion = false;
+    var subproofAssertion = (0, _statement.subproofAssertionFromStatement)(statement, context);
+    if (subproofAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a subproof assertion..."));
+        var subproofAssertionValidates = subproofAssertion.validate(assignments, stated, context);
+        statementValidatesAsSubproofAssertion = subproofAssertionValidates; ///
+        if (statementValidatesAsSubproofAssertion) {
+            var assertion = subproofAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a subproof assertion."));
+        }
+    }
+    return statementValidatesAsSubproofAssertion;
+}
+function validateStatementAsContainedAssertion(statement, assignments, stated, context) {
+    var validatesStatementAsContainedAssertion = false;
+    var containedAssertion = (0, _statement.containedAssertionFromStatement)(statement, context);
+    if (containedAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a contained assertion..."));
+        var containedAssertionValidates = containedAssertion.validate(assignments, stated, context);
+        validatesStatementAsContainedAssertion = containedAssertionValidates; ///
+        if (validatesStatementAsContainedAssertion) {
+            var assertion = containedAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a contained assertion."));
+        }
+    }
+    return validatesStatementAsContainedAssertion;
+}
+function validateStatementAsSatisfiesAssertion(statement, assignments, stated, context) {
+    var validatesAStatementsSatisfiesAssertion = false;
+    var satisfiesAssertion = (0, _statement.satisfiesAssertionFromStatement)(statement, context);
+    if (satisfiesAssertion !== null) {
+        var statementString = statement.getString();
+        context.trace("Validating the '".concat(statementString, "' statement as a satisfies assertion..."));
+        var satisfiesAssertionValidates = satisfiesAssertion.validate(assignments, stated, context);
+        validatesAStatementsSatisfiesAssertion = satisfiesAssertionValidates; ///
+        if (validatesAStatementsSatisfiesAssertion) {
+            var assertion = satisfiesAssertion; ///
+            context.addAssertion(assertion);
+            context.debug("...validated the '".concat(statementString, "' statement as a satisfies assertion."));
+        }
+    }
+    return validatesAStatementsSatisfiesAssertion;
+}
+var validateTerms = [
+    unifyTermWithBracketedConstructor,
+    unifyTermWithConstructors,
+    validateTermAsVariable
+];
+var validateStatements = [
+    validateStatementAsMetavariableAndSubstitution,
+    unifyStatementWithBracketedCombinator,
+    unifyStatementWithCombinators,
+    validateStatementAsEquality,
+    validateStatementAsJudgement,
+    validateStatementAsTypeAssertion,
+    validateStatementAsDefinedAssertion,
+    validateStatementAsPropertyAssertion,
+    validateStatementAsSubproofAssertion,
+    validateStatementAsContainedAssertion,
+    validateStatementAsSatisfiesAssertion
+];
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/validation.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\n\nimport { equalityFromStatement,\n         judgementFromStatement,\n         metavariableFromStatement,\n         typeAssertionFromStatement,\n         definedAssertionFromStatement,\n         propertyAssertionFromStatement,\n         subproofAssertionFromStatement,\n         containedAssertionFromStatement,\n         satisfiesAssertionFromStatement } from \"../utilities/statement\";\n\nfunction unifyTermWithBracketedConstructor(term, context, validateAhead) {\n  let termUnifiesWithBracketedConstructor;\n\n  const { BracketedConstructor } = elements,\n    bracketedConstructor = BracketedConstructor.fromNothing();\n\n  termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);\n\n  return termUnifiesWithBracketedConstructor;\n}\n\nfunction unifyTermWithConstructors(term, context, validateAhead) {\n  let termUnifiesWithConstructors;\n\n  const constructors = context.getConstructors();\n\n  termUnifiesWithConstructors = constructors.some((constructor) => {\n    const unifiesWithConstructor = constructor.unifyTerm(term, context, validateAhead);\n\n    if (unifiesWithConstructor) {\n      return true;\n    }\n  });\n\n  return termUnifiesWithConstructors;\n}\n\nfunction validateTermAsVariable(term, context, validateAhead) {\n  let termValidatesAsVariable = false;\n\n  const { Variable } = elements,\n    termNode = term.getNode(),\n    singularVariableNode = termNode.getSingularVariableNode();\n\n  if (singularVariableNode !== null) {\n    let variable;\n\n    const termString = term.getString(),\n      variableNode = singularVariableNode;  ///\n\n    variable = Variable.fromVariableNode(variableNode, context);\n\n    context.trace(`Verifying the '${termString}' term as a variable...`);\n\n    const variableValidates = variable.validate(context);\n\n    if (variableValidates) {\n      let verifiesAhead;\n\n      const variableIdentifier = variable.getIdentifier();\n\n      variable = context.findVariableByVariableIdentifier(variableIdentifier);\n\n      const type = variable.getType();\n\n      term.setType(type);\n\n      verifiesAhead = validateAhead();\n\n      termValidatesAsVariable = verifiesAhead; ///\n    }\n\n    if (termValidatesAsVariable) {\n      context.debug(`...verified the '${termString}' term as a variable.`);\n    }\n  }\n\n  return termValidatesAsVariable;\n}\n\nfunction validateStatementAsMetavariableAndSubstitution(statement, assignments, stated, context) {\n  let statementValidatesAsMetavariableAndSubstitution = false;\n\n  const metavariable = metavariableFromStatement(statement, context);\n\n  if (metavariable !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a metavariable and substitution...`);\n\n    const metavariableValidates = metavariable.validate(context);\n\n    if (metavariableValidates) {\n      const { TermSubstitution, FrameSubstitution } = elements,\n            frameSubstitution = FrameSubstitution.fromStatement(statement, context),\n            termSubstitution = TermSubstitution.fromStatement(statement, context),\n            substitution = (termSubstitution || frameSubstitution);\n\n      if (substitution !== null) {\n        const substitutionValidates = substitution.validate(context);\n\n        if (substitutionValidates) {\n          statementValidatesAsMetavariableAndSubstitution = true;\n        }\n      } else {\n        statementValidatesAsMetavariableAndSubstitution = true;\n      }\n    }\n\n    if (statementValidatesAsMetavariableAndSubstitution) {\n      context.debug(`...validated the '${statementString}' statement as a metavariable and substitution.`);\n    }\n  }\n\n  return statementValidatesAsMetavariableAndSubstitution;\n}\n\nfunction unifyStatementWithBracketedCombinator(statement, assignments, stated, context) {\n  stated = true;  ///\n\n  assignments = null; ///\n\n  const { BracketedCombinator } = elements,\n        bracketedCombinator = BracketedCombinator.fromNothing(),\n        statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);\n\n  return statementUnifiesWithBracketedCombinator;\n}\n\nfunction unifyStatementWithCombinators(statement, assignments, stated, context) {\n  stated = true;  ///\n\n  assignments = null; ///\n\n  const combinators = context.getCombinators(),\n        statementUnifiesWithCombinators = combinators.some((combinator) => {\n          const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);\n\n          if (unifiesWithCombinator) {\n            return true;\n          }\n        });\n\n  return statementUnifiesWithCombinators;\n}\n\nfunction validateStatementAsEquality(statement, assignments, stated, context) {\n  let statementValidatesAsEquality = false;\n\n  const equality = equalityFromStatement(statement, context);\n\n  if (equality !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as an equality...`);\n\n    const equalityValidates = equality.validate(assignments, stated, context);\n\n    statementValidatesAsEquality = equalityValidates; ///\n\n    if (statementValidatesAsEquality) {\n      context.debug(`...validated the '${statementString}' statement as an equality.`);\n    }\n  }\n\n  return statementValidatesAsEquality;\n}\n\nfunction validateStatementAsJudgement(statement, assignments, stated, context) {\n  let validatesStatementAsJudgement = false;\n\n  const judgement = judgementFromStatement(statement, context);\n\n  if (judgement !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a judgement...`);\n\n    const judgementValidates = judgement.validate(assignments, stated, context);\n\n    validatesStatementAsJudgement = judgementValidates;  ///\n\n    if (validatesStatementAsJudgement) {\n      context.debug(`...validated the '${statementString}' statement as a judgement.`);\n    }\n  }\n\n  return validatesStatementAsJudgement;\n}\n\nfunction validateStatementAsTypeAssertion(statement, assignments, stated, context) {\n  let validatesStatementAsTypeAssertion = false;\n\n  const typeAssertion = typeAssertionFromStatement(statement, context);\n\n  if (typeAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a type assertion...`);\n\n    const typeAssertionValidates = typeAssertion.validate(assignments, stated, context);\n\n    validatesStatementAsTypeAssertion = typeAssertionValidates; ///\n\n    if (validatesStatementAsTypeAssertion) {\n      const assertion = typeAssertion;  ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a type assertion.`);\n    }\n  }\n\n  return validatesStatementAsTypeAssertion;\n}\n\nfunction validateStatementAsDefinedAssertion(statement, assignments, stated, context) {\n  let validatesStatementAsDefinedAssertion = false;\n\n  const definedAssertion = definedAssertionFromStatement(statement, context);\n\n  if (definedAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a defined assertion...`);\n\n    const definedAssertionValidates = definedAssertion.validate(assignments, stated, context);\n\n    validatesStatementAsDefinedAssertion = definedAssertionValidates; ///\n\n    if (validatesStatementAsDefinedAssertion) {\n      const assertion = definedAssertion;  ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a defined assertion.`);\n    }\n  }\n\n  return validatesStatementAsDefinedAssertion;\n}\n\nfunction validateStatementAsPropertyAssertion(statement, assignments, stated, context) {\n  let statementValidatesAsPropertyAssertion = false;\n\n  const propertyAssertion = propertyAssertionFromStatement(statement, context);\n\n  if (propertyAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a property assertion...`);\n\n    const propertyAssertionValidates = propertyAssertion.validate(assignments, stated, context);\n\n    statementValidatesAsPropertyAssertion = propertyAssertionValidates; ///\n\n    if (statementValidatesAsPropertyAssertion) {\n      const assertion = propertyAssertion; ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a property assertion.`);\n    }\n  }\n\n  return statementValidatesAsPropertyAssertion;\n}\n\nfunction validateStatementAsSubproofAssertion(statement, assignments, stated, context) {\n  let statementValidatesAsSubproofAssertion = false;\n\n  const subproofAssertion = subproofAssertionFromStatement(statement, context);\n\n  if (subproofAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a subproof assertion...`);\n\n    const subproofAssertionValidates = subproofAssertion.validate(assignments, stated, context);\n\n    statementValidatesAsSubproofAssertion = subproofAssertionValidates; ///\n\n    if (statementValidatesAsSubproofAssertion) {\n      const assertion = subproofAssertion; ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a subproof assertion.`);\n    }\n  }\n\n  return statementValidatesAsSubproofAssertion;\n}\n\nfunction validateStatementAsContainedAssertion(statement, assignments, stated, context) {\n  let validatesStatementAsContainedAssertion = false;\n\n  const containedAssertion = containedAssertionFromStatement(statement, context);\n\n  if (containedAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a contained assertion...`);\n\n    const containedAssertionValidates = containedAssertion.validate(assignments, stated, context);\n\n    validatesStatementAsContainedAssertion = containedAssertionValidates; ///\n\n    if (validatesStatementAsContainedAssertion) {\n      const assertion = containedAssertion; ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a contained assertion.`);\n    }\n  }\n\n  return validatesStatementAsContainedAssertion;\n}\n\nfunction validateStatementAsSatisfiesAssertion(statement, assignments, stated, context) {\n  let validatesAStatementsSatisfiesAssertion = false;\n\n  const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);\n\n  if (satisfiesAssertion !== null) {\n    const statementString = statement.getString();\n\n    context.trace(`Validating the '${statementString}' statement as a satisfies assertion...`);\n\n    const satisfiesAssertionValidates = satisfiesAssertion.validate(assignments, stated, context);\n\n    validatesAStatementsSatisfiesAssertion = satisfiesAssertionValidates; ///\n\n    if (validatesAStatementsSatisfiesAssertion) {\n      const assertion = satisfiesAssertion; ///\n\n      context.addAssertion(assertion);\n\n      context.debug(`...validated the '${statementString}' statement as a satisfies assertion.`);\n    }\n  }\n\n  return validatesAStatementsSatisfiesAssertion;\n}\n\nexport const validateTerms = [\n  unifyTermWithBracketedConstructor,\n  unifyTermWithConstructors,\n  validateTermAsVariable\n];\n\nexport const validateStatements = [\n  validateStatementAsMetavariableAndSubstitution,\n  unifyStatementWithBracketedCombinator,\n  unifyStatementWithCombinators,\n  validateStatementAsEquality,\n  validateStatementAsJudgement,\n  validateStatementAsTypeAssertion,\n  validateStatementAsDefinedAssertion,\n  validateStatementAsPropertyAssertion,\n  validateStatementAsSubproofAssertion,\n  validateStatementAsContainedAssertion,\n  validateStatementAsSatisfiesAssertion\n];\n"],"names":["validateStatements","validateTerms","unifyTermWithBracketedConstructor","term","context","validateAhead","termUnifiesWithBracketedConstructor","BracketedConstructor","elements","bracketedConstructor","fromNothing","unifyTerm","unifyTermWithConstructors","termUnifiesWithConstructors","constructors","getConstructors","some","constructor","unifiesWithConstructor","validateTermAsVariable","termValidatesAsVariable","Variable","termNode","getNode","singularVariableNode","getSingularVariableNode","variable","termString","getString","variableNode","fromVariableNode","trace","variableValidates","validate","verifiesAhead","variableIdentifier","getIdentifier","findVariableByVariableIdentifier","type","getType","setType","debug","validateStatementAsMetavariableAndSubstitution","statement","assignments","stated","statementValidatesAsMetavariableAndSubstitution","metavariable","metavariableFromStatement","statementString","metavariableValidates","TermSubstitution","FrameSubstitution","frameSubstitution","fromStatement","termSubstitution","substitution","substitutionValidates","unifyStatementWithBracketedCombinator","BracketedCombinator","bracketedCombinator","statementUnifiesWithBracketedCombinator","unifyStatement","unifyStatementWithCombinators","combinators","getCombinators","statementUnifiesWithCombinators","combinator","unifiesWithCombinator","validateStatementAsEquality","statementValidatesAsEquality","equality","equalityFromStatement","equalityValidates","validateStatementAsJudgement","validatesStatementAsJudgement","judgement","judgementFromStatement","judgementValidates","validateStatementAsTypeAssertion","validatesStatementAsTypeAssertion","typeAssertion","typeAssertionFromStatement","typeAssertionValidates","assertion","addAssertion","validateStatementAsDefinedAssertion","validatesStatementAsDefinedAssertion","definedAssertion","definedAssertionFromStatement","definedAssertionValidates","validateStatementAsPropertyAssertion","statementValidatesAsPropertyAssertion","propertyAssertion","propertyAssertionFromStatement","propertyAssertionValidates","validateStatementAsSubproofAssertion","statementValidatesAsSubproofAssertion","subproofAssertion","subproofAssertionFromStatement","subproofAssertionValidates","validateStatementAsContainedAssertion","validatesStatementAsContainedAssertion","containedAssertion","containedAssertionFromStatement","containedAssertionValidates","validateStatementAsSatisfiesAssertion","validatesAStatementsSatisfiesAssertion","satisfiesAssertion","satisfiesAssertionFromStatement","satisfiesAssertionValidates"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.437",
+  "version": "1.0.444",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,11 +12,11 @@
   "dependencies": {
     "argumentative": "^2.0.36",
     "necessary": "^17.0.9",
-    "occam-custom-grammars": "^5.0.1336",
-    "occam-entities": "^1.0.441",
-    "occam-file-system": "^6.0.456",
-    "occam-furtle": "^2.0.275",
-    "occam-grammars": "^1.3.430",
+    "occam-custom-grammars": "^5.0.1339",
+    "occam-entities": "^1.0.443",
+    "occam-file-system": "^6.0.458",
+    "occam-furtle": "^2.0.277",
+    "occam-grammars": "^1.3.435",
     "occam-lexers": "^23.1.34",
     "occam-parsers": "^23.1.37",
     "occam-query": "^4.1.142"

package/src/context/file.js

@@ -4,8 +4,8 @@ import { arrayUtilities } from "necessary";
 
 import elements from "../elements";
 
-import { baseType } from "../element/type";
 import { verifyFile } from "../process/verify";
+import { baseTypeFromNothing } from "../types";
 import { nodeAsString, nodesAsString } from "../utilities/node";
 import { typesFromJSON,
          rulesFromJSON,
@@ -329,9 +329,9 @@ export default class FileContext {
   findMetaLemmaByReference(reference) {
     const metaLemmas = this.getMetaLemmas(),
           metaLemma = metaLemmas.find((metaLemma) => {
-            const referenceMatches = metaLemma.matchReference(reference);
+            const metaLemmaComparesToReference = metaLemma.compareReference(reference);
 
-            if (referenceMatches) {
+            if (metaLemmaComparesToReference) {
               return true;
             }
           }) || null;
@@ -342,9 +342,9 @@ export default class FileContext {
   findMetatheoremByReference(reference) {
     const metatheorems = this.getMetatheorems(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const referenceMatches = metatheorem.matchReference(reference);
+            const metatheoremComparesToReference = metatheorem.compareReference(reference);
 
-            if (referenceMatches) {
+            if (metatheoremComparesToReference) {
               return true;
             }
           }) || null;
@@ -356,9 +356,9 @@ export default class FileContext {
     const rules = this.getRules(),
           metavariableName = reference.getMetavariableName(),
           rule = rules.find((rule) => {
-            const metavariableNameMatches = rule.matchMetavariableName(metavariableName);
+            const ruleComparesToMetavariableName = rule.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (ruleComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -370,9 +370,9 @@ export default class FileContext {
     const axioms = this.getAxioms(),
           metavariableName = reference.getMetavariableName(),
           axiom = axioms.find((axiom) => {
-            const metavariableNameMatches = axiom.matchMetavariableName(metavariableName);
+            const axiomComparesToMetavariableName = axiom.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (axiomComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -384,9 +384,9 @@ export default class FileContext {
     const lemmas = this.getLemmas(),
           metavariableName = reference.getMetavariableName(),
           lemma = lemmas.find((lemma) => {
-            const metavariableNameMatches = lemma.matchMetavariableName(metavariableName);
+            const lemmaComparesToMetavariableName = lemma.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (lemmaComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -398,9 +398,9 @@ export default class FileContext {
     const theorems = this.getTheorems(),
           metavariableName = reference.getMetavariableName(),
           theorem = theorems.find((theorem) => {
-            const metavariableNameMatches = theorem.matchMetavariableName(metavariableName);
+            const theoremComparesToMetavariableName = theorem.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (theoremComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -425,9 +425,9 @@ export default class FileContext {
     const conjectures = this.getConjectures(),
           metavariableName = reference.getMetavariableName(),
           conjecture = conjectures.find((conjecture) => {
-            const metavariableNameMatches = conjecture.matchMetavariableName(metavariableName);
+            const conjectureComparesToMetavariableName = conjecture.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (conjectureComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -519,15 +519,17 @@ export default class FileContext {
   findTypeByTypeName(typeName, includeRelease = true, includeDependencies = true) {
     let types = this.getTypes(includeRelease, includeDependencies);
 
+    const baseType = baseTypeFromNothing();
+
     types = [
       ...types,
       baseType
     ];
 
     const type = types.find((type) => {
-      const typeNameMatches = type.matchTypeName(typeName);
+      const typeComparesToTypeName = type.compareTypeName(typeName);
 
-      if (typeNameMatches) {
+      if (typeComparesToTypeName) {
         return true;
       }
     }) || null;
@@ -538,15 +540,17 @@ export default class FileContext {
   findTypeByNominalTypeName(nominalTypeName) {
     let types = this.getTypes();
 
+    const baseType = baseTypeFromNothing();
+
     types = [
       ...types,
       baseType
     ];
 
     const type = types.find((type) => {
-      const typeNameMatches = type.matchNominalTypeName(nominalTypeName);
+      const typeComparesToNominalTypeName = type.compareNominalTypeName(nominalTypeName);
 
-      if (typeNameMatches) {
+      if (typeComparesToNominalTypeName) {
         return true;
       }
     }) || null;
@@ -557,15 +561,17 @@ export default class FileContext {
   findTypeByPrefixedTypeName(prefixedTypeName) {
     let types = this.getTypes();
 
+    const baseType = baseTypeFromNothing();
+
     types = [
       ...types,
       baseType
     ];
 
     const type = types.find((type) => {
-      const typeNameMatches = type.matchPrefixedTypeName(prefixedTypeName);
+      const typeComparesToPrefixedTypeName = type.comparePrefixedTypeName(prefixedTypeName);
 
-      if (typeNameMatches) {
+      if (typeComparesToPrefixedTypeName) {
         return true;
       }
     }) || null;
@@ -576,9 +582,9 @@ export default class FileContext {
   findMetaTypeByMetaTypeName(metaTypeName) {
     const metaTypes = this.getMetaTypes(),
           metaType = metaTypes.find((metaType) => {
-            const metaTypeNameMatches = metaType.matchMetaTypeName(metaTypeName);
+            const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
 
-            if (metaTypeNameMatches) {
+            if (metaTypeComparesToMetaTypeName) {
               return true;
             }
           }) || null;
@@ -589,9 +595,9 @@ export default class FileContext {
   findTypePrefixByTypePrefixName(typePrefixName) {
     const typePrefixes = this.getTypePrefixes(),
           typePrefix = typePrefixes.find((typePrefix) => {
-            const typePrefixNameMatches = typePrefix.matchTypePrefixName(typePrefixName);
+            const typePrefixComparesToTypePrefixName = typePrefix.compareTypePrefixName(typePrefixName);
 
-            if (typePrefixNameMatches) {
+            if (typePrefixComparesToTypePrefixName) {
               return true;
             }
           }) || null;
@@ -602,9 +608,9 @@ export default class FileContext {
   findVariableByVariableIdentifier(variableIdentifier) {
     const variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const variableIdentifierMatches = variable.matchVariableIdentifier(variableIdentifier);
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
-            if (variableIdentifierMatches) {
+            if (variableComparesToVariableIdentifier) {
               return true;
             }
           }) || null;
@@ -615,9 +621,9 @@ export default class FileContext {
   findLabelByMetavariableName(metavariableName) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
-            const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+            const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (labelComparesToMetavariableName) {
               return true;
             }
           }) || null;
@@ -659,9 +665,9 @@ export default class FileContext {
   findMetavariableByMetavariableName(metavariableName) {
     const metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const metavariableNameMatches = metavariable.matchMetavariableName(metavariableName);
+            const metavariableComparesToMetavariableName = metavariable.compareMetavariableName(metavariableName);
 
-            if (metavariableNameMatches) {
+            if (metavariableComparesToMetavariableName) {
               return true;
             }
           }) || null;

package/src/context/local.js

@@ -216,9 +216,9 @@ class LocalContext {
   findVariableByVariableIdentifier(variableIdentifier, nested = true) {
     const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
-            const variableIdentifierMatches = variable.matchVariableIdentifier(variableIdentifier);
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
-            if (variableIdentifierMatches) {
+            if (variableComparesToVariableIdentifier) {
               return true;
             }
           }) || null;
@@ -306,7 +306,7 @@ class LocalContext {
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
         const groundedTermNode = groundedTerm.getNode(),
-              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
+              groundedTermNodeMatches = term.matchNode(groundedTermNode);
 
             if (groundedTermNodeMatches) {
               return true;
@@ -344,18 +344,18 @@ class LocalContext {
     return metavariableDefined
   }
 
-  matchTermAndPropertyRelation(term, propertyRelation) {
+  compareTermAndPropertyRelation(term, propertyRelation) {
     const context = this, ///
           steps = this.getSteps(),
-          termAndPropertyRelationMatches = steps.some((step) => {
-            const termAndPropertyRelationMatches = step.matchTermAndPropertyRelation(term, propertyRelation, context);
+          comparesToTermAndPropertyRelation = steps.some((step) => {
+            const comparesToTermAndPropertyRelation = step.compareTermAndPropertyRelation(term, propertyRelation, context);
 
-            if (termAndPropertyRelationMatches) {
+            if (comparesToTermAndPropertyRelation) {
               return true;
             }
           });
 
-    return termAndPropertyRelationMatches;
+    return comparesToTermAndPropertyRelation;
   }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }

package/src/context/release.js

@@ -10,8 +10,8 @@ import FileContext from "../context/file";
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";
 
-import { frameMetaType, referenceMetaType, statementMetaType } from "../element/metaType";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
+import { frameMetaTypeFromNothing, referenceMetaTypeFromNothing, statementMetaTypeFromNothing } from "../metaTypes";
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
@@ -58,11 +58,14 @@ export default class ReleaseContext {
   }
 
   getMetaTypes() {
-    const metaTypes = [
-      frameMetaType,
-      referenceMetaType,
-      statementMetaType
-    ];
+    const frameMetaType = frameMetaTypeFromNothing(),
+          referenceMetaType = referenceMetaTypeFromNothing(),
+          statementMetaType = statementMetaTypeFromNothing(),
+          metaTypes = [
+            frameMetaType,
+            referenceMetaType,
+            statementMetaType
+          ];
 
     return metaTypes;
   }