occam-verify-cli 1.0.438 → 1.0.448

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,
@@ -97,10 +97,10 @@ export default class FileContext {
     return equivalences;
   }
 
-  getStepsOrSubproofs() {
-    const stepsOrSubproofs = [];
+  getSubproofOrProofAssertions() {
+    const subproofOrProofAssertions = [];
 
-    return stepsOrSubproofs;
+    return subproofOrProofAssertions;
   }
 
   getLabels(includeRelease = true) {
@@ -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

@@ -7,12 +7,12 @@ import elements from "../elements";
 const { last } = arrayUtilities;
 
 class LocalContext {
-  constructor(context, variables, judgements, equivalences, stepsOrSubproofs) {
+  constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {
     this.context = context;
     this.variables = variables;
     this.judgements = judgements;
     this.equivalences = equivalences;
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
   getContext() {
@@ -55,41 +55,41 @@ class LocalContext {
     return equivalences;
   }
 
-  getSteps() {
-    const stepsOrSubproofs = this.getStepsOrSubproofs(),
-          steps = stepsOrSubproofs.filter((stepOrSubproof) => {
-            const stepOrSubproofStep = stepOrSubproof.isStep();
+  getProofAssertions() {
+    const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),
+          proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {
+            const subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();
 
-            if (stepOrSubproofStep) {
+            if (subproofOrProofAssertionproofAssertion) {
               return true;
             }
           });
 
-    return steps;
+    return proofAssertions;
   }
 
-  getLastStep() {
-    let lastStep = null;
+  getLastProofAssertion() {
+    let lastProofAssertion = null;
 
-    const steps = this.getSteps(),
-          stepsLength = steps.length;
+    const proofAssertions = this.getProofAssertions(),
+          proofAssertionsLength = proofAssertions.length;
 
-    if (stepsLength > 0) {
-      lastStep = last(steps);
+    if (proofAssertionsLength > 0) {
+      lastProofAssertion = last(proofAssertions);
     }
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
-  getStepsOrSubproofs() {
-    let stepsOrSubproofs = this.context.getStepsOrSubproofs();
+  getSubproofOrProofAssertions() {
+    let subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();
 
-    stepsOrSubproofs = [  ///
-      ...stepsOrSubproofs,
-      ...this.stepsOrSubproofs
+    subproofOrProofAssertions = [  ///
+      ...subproofOrProofAssertions,
+      ...this.subproofOrProofAssertions
     ];
 
-    return stepsOrSubproofs;
+    return subproofOrProofAssertions;
   }
 
   getFilePath() { return this.context.getFilePath(); }
@@ -187,8 +187,8 @@ class LocalContext {
     return judgementAdded;
   }
 
-  addStepOrSubproof(stepOrSubproof) {
-    this.stepsOrSubproofs.push(stepOrSubproof);
+  addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    this.subproofOrProofAssertions.push(subproofOrProofAssertion);
   }
 
   findProcedureByName(name) { return this.context.findProcedureByName(name); }
@@ -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);
+          proofAssertions = this.getProofAssertions(),
+          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
+            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
 
-            if (termAndPropertyRelationMatches) {
+            if (comparesToTermAndPropertyRelation) {
               return true;
             }
           });
 
-    return termAndPropertyRelationMatches;
+    return comparesToTermAndPropertyRelation;
   }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
@@ -377,8 +377,8 @@ class LocalContext {
           variables = [],
           judgements = [],
           equivalences = Equivalences.fromNothing(),
-          stepsOrSubproofs = [],
-          localContext = new LocalContext(context, variables, judgements, equivalences, stepsOrSubproofs);
+          subproofOrProofAssertions = [],
+          localContext = new LocalContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
 
     return localContext;
   }

package/src/context/release.js

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

package/src/context/temporary.js

@@ -159,9 +159,9 @@ export default class TemporaryContext {
 
   findTermByTermNode(termNode) {
     const term = this.terms.find((term) => {
-      const termMatchesTermNode = term.matchTermNode(termNode);
+      const termNodeMatches = term.matchNode(termNode);
 
-      if (termMatchesTermNode) {
+      if (termNodeMatches) {
         return true;
       }
     }) || null;
@@ -171,9 +171,9 @@ export default class TemporaryContext {
 
   findFrameByFrameNode(frameNode) {
     const frame = this.frames.find((frame) => {
-      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+      const frameNodeMatches = frame.matchNode(frameNode);
 
-      if (frameMatchesFrameNode) {
+      if (frameNodeMatches) {
         return true;
       }
     }) || null;
@@ -183,9 +183,9 @@ export default class TemporaryContext {
 
   findStatementByStatementNode(statementNode) {
     const statement = this.statements.find((statement) => {
-      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+      const statementNodeMatches = statement.matchNode(statementNode);
 
-      if (statementMatchesStatementNode) {
+      if (statementNodeMatches) {
         return true;
       }
     }) || null;
@@ -195,9 +195,9 @@ export default class TemporaryContext {
 
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
-      const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
+      const assertionNodeMatches = assertion.matchNode(assertionNode);
 
-      if (assertionMatchesAssertionNode) {
+      if (assertionNodeMatches) {
         return true;
       }
     }) || null;
@@ -219,9 +219,9 @@ export default class TemporaryContext {
 
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionMatchesSubtitutionNode = substitution.matchSubstitutionNode(substitutionNode);
+      const substitutionNodeMatches = substitution.matchNode(substitutionNode);
 
-      if (substitutionMatchesSubtitutionNode) {
+      if (substitutionNodeMatches) {
         return true;
       }
     }) || null;
@@ -235,11 +235,11 @@ export default class TemporaryContext {
 
   getEquivalences() { return this.context.getEquivalences(); }
 
-  getSteps() { return this.context.getSteps(); }
+  getProofAssertions() { return this.context.getProofAssertions(); }
 
-  getLastStep() { return this.context.getLastStep(); }
+  getLastProofAssertion() { return this.context.getLastProofAssertion(); }
 
-  getStepsOrSubproofs() { return this.context.getStepsOrSubproofs(); }
+  getSubproofOrProofAssertions() { return this.context.getSubproofOrProofAssertions(); }
 
   getFilePath() { return this.context.getFilePath(); }
 
@@ -273,7 +273,7 @@ export default class TemporaryContext {
 
   addJudgement(judgement) { return this.context.addJudgement(judgement); }
 
-  addStepOrSubproof(stepOrSubproof) { this.context.addStepOrSubproof(stepOrSubproof); }
+  addSubproofOrProofAssertion(subproofOrProofAssertion) { this.context.addSubproofOrProofAssertion(subproofOrProofAssertion); }
 
   findProcedureByName(name) { return this.context.findProcedureByName(name); }
 
@@ -349,7 +349,7 @@ export default class TemporaryContext {
 
   isMetavariableDefined(metavariable) { return this.context.isMetavariableDefined(metavariable); }
 
-  matchTermAndPropertyRelation(term, propertyRelation) { return this.context.matchTermAndPropertyRelation(term, propertyRelation); }
+  compareTermAndPropertyRelation(term, propertyRelation) { return this.context.compareTermAndPropertyRelation(term, propertyRelation); }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
 

package/src/element/assertion/contained.js

@@ -3,12 +3,11 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { containedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(string, node, term, frame, negated, statement) {
-    super(string, node);
+  constructor(cpontext, string, node, term, frame, negated, statement) {
+    super(context, string, node);
 
     this.term = term;
     this.frame = frame;
@@ -39,11 +38,11 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context),
+    const termValidates = this.validateTerm(assignments, stated, context),
           frameVerifies = this.verifyFrame(assignments, stated, context),
-          statementVerifies = this.verifyStatement(assignments, stated, context)
+          statementValidates = this.validateStatement(assignments, stated, context)
 
-    if (termVerifies || frameVerifies || statementVerifies) {
+    if (termValidates || frameVerifies || statementValidates) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -65,32 +64,32 @@ export default define(class ContainedAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies = false;
+  validateTerm(assignments, stated, context) {
+    let termValidates = false;
 
     if (this.term !== null) {
       const termString = this.term.getString();
 
-      context.trace(`Verifying the '${termString}' term...`);
+      context.trace(`Validating the '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        termVerifies = this.term.verify(context, () => {
+        termValidates = this.term.validate(context, () => {
           const verifiesAhead = true;
 
           return verifiesAhead;
         });
 
-        if (termVerifies) {
-          context.debug(`...verified the '${termString}' term.`);
+        if (termValidates) {
+          context.debug(`...validated the '${termString}' term.`);
         }
       }
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyFrame(assignments, stated, context) {
@@ -121,26 +120,26 @@ export default define(class ContainedAssertion extends Assertion {
     return frameVerifies;
   }
 
-  verifyStatement(assignments, stated, context) {
-    let statementVerifies = false;
+  validateStatement(assignments, stated, context) {
+    let statementValidates = false;
 
     if (this.statement !== null) {
       const statementString = this.statement.getString();
 
-      context.trace(`Verifying the '${statementString}' statement...`);
+      context.trace(`Validating the '${statementString}' statement...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      statementVerifies = this.statement.verify(assignments, stated, context);
+      statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
-        context.debug(`...verified the '${statementString}' statement.`);
+      if (statementValidates) {
+        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
-    return statementVerifies;
+    return statementValidates;
   }
 
   verifyWhenStated(assignments, context) {

package/src/element/assertion/defined.js

@@ -4,12 +4,11 @@ import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { definedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class DefinedAssertion extends Assertion {
-  constructor(string, node, term, frame, negated) {
-    super(string, node);
+  constructor(context, string, node, term, frame, negated) {
+    super(context, string, node);
 
     this.term = term;
     this.frame= frame;
@@ -35,10 +34,10 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context),
+    const termValidates = this.validateTerm(assignments, stated, context),
           frameVerifies = this.verifyFrame(assignments, stated, context);
 
-    if (termVerifies || frameVerifies) {
+    if (termValidates || frameVerifies) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -60,32 +59,32 @@ export default define(class DefinedAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies = false;
+  validateTerm(assignments, stated, context) {
+    let termValidates = false;
 
     if (this.term !== null) {
       const termString = this.term.getString(); ///
 
-      context.trace(`Verifying the '${termString}' term...`);
+      context.trace(`Validating the '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        termVerifies = this.term.verify(context, () => {
+        termValidates = this.term.validate(context, () => {
           const verifiesAhead = true;
 
           return verifiesAhead;
         });
 
-        if (termVerifies) {
-          context.debug(`...verified the '${termString}' term.`);
+        if (termValidates) {
+          context.debug(`...validated the '${termString}' term.`);
         }
       }
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyFrame(assignments, stated, context) {