occam-verify-cli 1.0.612 → 1.0.631

package/src/context/file/nominal.js

@@ -10,6 +10,7 @@ import NominalParser from "../../nominal/parser";
 
 import { verifyFile } from "../../process/verify";
 import { baseTypeFromNothing } from "../../utilities/type";
+import { findMetaTypeByMetaTypeName } from "../../metaTypes";
 import { typesFromJSON,
          rulesFromJSON,
          axiomsFromJSON,
@@ -94,6 +95,7 @@ export default class NominalFileContext extends FileContext {
 
   getEquivalences() {
     const { Equivalences } = elements,
+          context = this, ///
           equivalences = Equivalences.fromNothing(context);
 
     return equivalences;
@@ -259,93 +261,155 @@ export default class NominalFileContext extends FileContext {
 
   addType(type) {
     this.types.push(type);
+
+    const filePath = this.getFilePath(),
+          typeString = type.toString();
+
+    this.trace(`Added the '${typeString}' type to the '${filePath}' file context.`)
   }
 
   addRule(rule) {
     this.rules.push(rule);
+
+    const filePath = this.getFilePath(),
+          ruleString = rule.toString();
+
+    this.trace(`Added the '${ruleString}' rule to the '${filePath}' file context.`)
   }
 
   addAxiom(axiom) {
     this.axioms.push(axiom);
+
+    const filePath = this.getFilePath(),
+          axiomString = axiom.toString();
+
+    this.trace(`Added the '${axiomString}' axiom to the '${filePath}' file context.`)
   }
 
   addLemma(lemma) {
     this.lemmas.push(lemma);
+
+    const filePath = this.getFilePath(),
+          lemmaString = lemma.toString();
+
+    this.trace(`Added the '${lemmaString}' lemma to the '${filePath}' file context.`)
   }
 
   addTheorem(theorem) {
     this.theorems.push(theorem);
+
+    const filePath = this.getFilePath(),
+          theoremString = theorem.toString();
+
+    this.trace(`Added the '${theoremString}' theorem to the '${filePath}' file context.`)
   }
 
   addVariable(variable) {
     this.variables.push(variable);
+
+    const filePath = this.getFilePath(),
+          variableString = variable.toString();
+
+    this.trace(`Added the '${variableString}' variable to the '${filePath}' file context.`)
   }
 
   addMetaLemma(metaLemma) {
     this.metaLemmas.push(metaLemma);
+
+    const filePath = this.getFilePath(),
+          metaLemmaString = metaLemma.toString();
+
+    this.trace(`Added the '${metaLemmaString}' meta-lemma to the '${filePath}' file context.`)
   }
 
   addConjecture(conjecture) {
     this.conjectures.push(conjecture);
+
+    const filePath = this.getFilePath(),
+          ocnjectureString = ocnjecture.toString();
+
+    this.trace(`Added the '${ocnjectureString}' ocnjecture to the '${filePath}' file context.`)
   }
 
   addCombinator(combinator) {
     this.combinators.push(combinator);
+
+    const filePath = this.getFilePath(),
+          combinatorString = combinator.toString();
+
+    this.trace(`Added the '${combinatorString}' combinator to the '${filePath}' file context.`)
   }
 
   addTypePrefix(typePrefix) {
     this.typePrefixes.push(typePrefix);
+
+    const filePath = this.getFilePath(),
+          typePrefixString = typePrefix.toString();
+
+    this.trace(`Added the '${typePrefixString}' type-prefix to the '${filePath}' file context.`)
   }
 
   addConstructor(constructor) {
     this.constructors.push(constructor);
+
+    const filePath = this.getFilePath(),
+          constructorString = constructor.toString();
+
+    this.trace(`Added the '${constructorString}' constructor to the '${filePath}' file context.`)
   }
 
   addMetatheorem(metatheorem) {
     this.metatheorems.push(metatheorem);
+
+    const filePath = this.getFilePath(),
+          metatheoremString = metatheorem.toString();
+
+    this.trace(`Added the '${metatheoremString}' metatheorem to the '${filePath}' file context.`)
   }
 
   addMetavariable(metavariable) {
     this.metavariables.push(metavariable);
+
+    const filePath = this.getFilePath(),
+          metavariableString = metavariable.toString();
+
+    this.trace(`Added the '${metavariableString}' metavariable to the '${filePath}' file context.`)
   }
 
-  findLabelByReference(reference, context) {
-    const labels = this.getLabels(),
-          label = labels.find((label) => {
-            const metavariableUnifies = label.unifyReference(reference, context);
+  findMetavariable(metavariable) {
+    const metavariables = this.getMetavariables(),
+          specificMetavariable = metavariable;  ///
 
-            if (metavariableUnifies) {
-              return true;
-            }
-          }) || null;
+    metavariable = metavariables.find((metavariable) => {
+      const context = this, ///
+            generalMetavariable = metavariable, ///
+            metavariableUnifies = generalMetavariable.unifyMetavariable(specificMetavariable, context);
 
-    return label;
+      if (metavariableUnifies) {
+        return true;
+      }
+    }) || null;
+
+    return metavariable;
   }
 
-  findMetaLemmaByReference(reference) {
-    const metaLemmas = this.getMetaLemmas(),
-          metaLemma = metaLemmas.find((metaLemma) => {
-            const metaLemmaComparesToReference = metaLemma.compareReference(reference);
+  findLabelByMetavariable(metavariable) {
+    const labels = this.getLabels(),
+          label = labels.find((label) => {
+            const labelMetavariableComparesToMetavariable = label.compareMetavariable(metavariable);
 
-            if (metaLemmaComparesToReference) {
+            if (labelMetavariableComparesToMetavariable) {
               return true;
             }
           }) || null;
 
-    return metaLemma;
+    return label;
   }
 
-  findMetatheoremByReference(reference) {
-    const metatheorems = this.getMetatheorems(),
-          metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremComparesToReference = metatheorem.compareReference(reference);
-
-            if (metatheoremComparesToReference) {
-              return true;
-            }
-          }) || null;
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
-    return metatheorem;
+    return metaType;
   }
 
   findRuleByReference(reference) {
@@ -404,17 +468,17 @@ export default class NominalFileContext extends FileContext {
     return theorem;
   }
 
-  findProcedureByName(name) {
-    const procedures = this.getProcedures(),
-          procedure = procedures.find((procedure) => {
-            const nameMatches = procedure.matchName(name);
+  findMetaLemmaByReference(reference) {
+    const metaLemmas = this.getMetaLemmas(),
+          metaLemma = metaLemmas.find((metaLemma) => {
+            const metaLemmaComparesToReference = metaLemma.compareReference(reference);
 
-            if (nameMatches) {
+            if (metaLemmaComparesToReference) {
               return true;
             }
           }) || null;
 
-    return procedure;
+    return metaLemma;
   }
 
   findConjectureByReference(reference) {
@@ -447,6 +511,19 @@ export default class NominalFileContext extends FileContext {
     return metaLemmas;
   }
 
+  findMetatheoremByReference(reference) {
+    const metatheorems = this.getMetatheorems(),
+      metatheorem = metatheorems.find((metatheorem) => {
+        const metatheoremComparesToReference = metatheorem.compareReference(reference);
+
+        if (metatheoremComparesToReference) {
+          return true;
+        }
+      }) || null;
+
+    return metatheorem;
+  }
+
   findMetatheoremsByReference(reference) {
     const metatheorems = this.getMetatheorems();
 
@@ -463,6 +540,16 @@ export default class NominalFileContext extends FileContext {
     return metatheorems;
   }
 
+  findTopLevelAssertionByReference(reference) {
+    const axiom = this.findAxiomByReference(reference),
+          lemma = this.findLemmaByReference(reference),
+          theorem = this.findTheoremByReference(reference),
+          conjecture = this.findConjectureByReference(reference),
+          topLevelAssertion = (axiom || lemma || theorem || conjecture);
+
+    return topLevelAssertion;
+  }
+
   findTopLevelMetaAssertionByReference(reference) {
     const metaLemma = this.findMetaLemmaByReference(reference),
           metatheorem = this.findMetatheoremByReference(reference),
@@ -482,33 +569,6 @@ export default class NominalFileContext extends FileContext {
     return topLevelMetaAssertions;
   }
 
-  findTopLevelAssertionByReference(reference) {
-    const axiom = this.findAxiomByReference(reference),
-          lemma = this.findLemmaByReference(reference),
-          theorem = this.findTheoremByReference(reference),
-          conjecture = this.findConjectureByReference(reference),
-          topLevelAssertion = (axiom || lemma || theorem || conjecture);
-
-    return topLevelAssertion;
-  }
-
-  findMetavariable(metavariable) {
-    const metavariables = this.getMetavariables(),
-          specificMetavariable = metavariable;  ///
-
-    metavariable = metavariables.find((metavariable) => {
-      const context = this, ///
-            generalMetavariable = metavariable, ///
-            metavariableUnifies = generalMetavariable.unifyMetavariable(specificMetavariable, context);
-
-      if (metavariableUnifies) {
-        return true;
-      }
-    }) || null;
-
-    return metavariable;
-  }
-
   findTypeByTypeName(typeName, includeRelease = true, includeDependencies = true) {
     let types = this.getTypes(includeRelease, includeDependencies);
 
@@ -585,19 +645,6 @@ export default class NominalFileContext extends FileContext {
     return typePrefix;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
-    const variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
-
-            if (variableComparesToVariableIdentifier) {
-              return true;
-            }
-          }) || null;
-
-    return variable;
-  }
-
   findLabelByMetavariableName(metavariableName) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
@@ -611,30 +658,30 @@ export default class NominalFileContext extends FileContext {
     return label;
   }
 
-  findLabelByMetavariable(metavariable) {
-    const labels = this.getLabels(),
-          label = labels.find((label) => {
-            const labelMetavariableComparesToMetavariable = label.compareMetavariable(metavariable);
+  findJudgementByMetavariableName(metavariableName) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
 
-            if (labelMetavariableComparesToMetavariable) {
+            if (judgementMetavariableComparesToMetavariable) {
               return true;
             }
           }) || null;
 
-    return label;
+    return judgement;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
-    const judgements = this.getJudgements(),
-          judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.matchMetavariableName(metavariableName);
+  findVariableByVariableIdentifier(variableIdentifier) {
+    const variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
-            if (judgementMetavariableComparesToMetavariable) {
+            if (variableComparesToVariableIdentifier) {
               return true;
             }
           }) || null;
 
-    return judgement;
+    return variable;
   }
 
   findMetavariableByMetavariableName(metavariableName) {
@@ -650,6 +697,19 @@ export default class NominalFileContext extends FileContext {
     return metavariable;
   }
 
+  findProcedureByProcedureName(procedureName) {
+    const procedures = this.getProcedures(),
+          procedure = procedures.find((procedure) => {
+            const procedureComparesToProcedureName = procedure.compareProcedureName(procedureName);
+
+            if (procedureComparesToProcedureName) {
+              return true;
+            }
+          }) || null;
+
+    return procedure;
+  }
+
   isMetavariablePresent(metavariable) {
     metavariable = this.findMetavariable(metavariable);
 
@@ -658,6 +718,48 @@ export default class NominalFileContext extends FileContext {
     return metavariablePresent;
   }
 
+  isLabelPresentByMetavariable(metavariable) {
+    const label = this.findLabelByMetavariable(metavariable),
+          labelPresent = (label !== null);
+
+    return labelPresent;
+  }
+
+  isLabelPresentByReference(reference) {
+    const labels = this.getLabels(),
+          labelPresent = labels.some((label) => {
+            const context = this, ///
+              labelUnifies = reference.unifyLabel(label, context);
+
+            if (labelUnifies) {
+              return true;
+            }
+          });
+
+    return labelPresent;
+  }
+
+  isMetavariablePresentByReference(reference) {
+    const metavariables = this.getMetavariables(),
+          metavariablePresent = metavariables.some((metavariable) => {
+            const context = this, ///
+              metavariableUnifies = reference.unifyMetavariable(metavariable, context);
+
+            if (metavariableUnifies) {
+              return true;
+            }
+          });
+
+    return metavariablePresent;
+  }
+
+  isTopLevelMetaAssertionPresentByReference(reference) {
+    const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference),
+          topLevelMetaAssertionPresent = (topLevelMetaAssertion !== null);
+
+    return topLevelMetaAssertionPresent;
+  }
+
   isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) {
     const type = this.findTypeByTypeName(typeName, includeRelease, includeDependencies),
           typePresent = (type !== null);
@@ -679,6 +781,13 @@ export default class NominalFileContext extends FileContext {
     return typePresent;
   }
 
+  isLabelPresentByMetavariableName(metavariableName) {
+    const label = this.findLabelByMetavariableName(metavariableName),
+          labelPresent = (label !== null);
+
+    return labelPresent;
+  }
+
   isTypePrefixPresentByTypePrefixName(typePrefixName) {
     const typePrefix = this.findTypePrefixByTypePrefixName(typePrefixName),
           typePrefixPresent = (typePrefix !== null);
@@ -693,20 +802,6 @@ export default class NominalFileContext extends FileContext {
     return variablePresent;
   }
 
-  isLabelPresentByMetavariableName(metavariableName) {
-    const label = this.findLabelByMetavariableName(metavariableName),
-          labelPresent = (label !== null);
-
-    return labelPresent;
-  }
-
-  isLabelPresentByMetavariable(metavariable) {
-    const label = this.findLabelByMetavariable(metavariable),
-          labelPresent = (label !== null);
-
-    return labelPresent;
-  }
-
   isMetavariablePresentByMetavariableName(metavariableName) {
     const metavariable = this.findMetavariableByMetavariableName(metavariableName),
           metavariablePresent = (metavariable !== null);
@@ -714,48 +809,13 @@ export default class NominalFileContext extends FileContext {
     return metavariablePresent;
   }
 
-  isLabelPresentByReference(reference) {
-    const labels = this.getLabels(),
-          labelPresent = labels.some((label) => {
-            const context = this, ///
-                  labelUnifies = reference.unifyLabel(label, context);
-
-            if (labelUnifies) {
-              return true;
-            }
-          });
-
-    return labelPresent;
-  }
-
-  isProcedurePresentByName(name) {
-    const procedure = this.findProcedureByName(name),
+  isProcedurePresentByProcedureName(procedureName) {
+    const procedure = this.findProcedureByProcedureName(procedureName),
           procedurePresent = (procedure !== null);
 
     return procedurePresent;
   }
 
-  isMetavariablePresentByReference(reference) {
-    const metavariables = this.getMetavariables(),
-          metavariablePresent = metavariables.some((metavariable) => {
-            const context = this, ///
-                  metavariableUnifies = reference.unifyMetavariable(metavariable, context);
-
-            if (metavariableUnifies) {
-              return true;
-            }
-          });
-
-    return metavariablePresent;
-  }
-
-  isTopLevelMetaAssertionPresentByReference(reference) {
-    const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference),
-          topLevelMetaAssertionPresent = (topLevelMetaAssertion !== null);
-
-    return topLevelMetaAssertionPresent;
-  }
-
   clear() {
     this.types = [];
     this.rules = [];
@@ -810,7 +870,7 @@ export default class NominalFileContext extends FileContext {
 
   async verifyFile() {
     const node = this.getNode(),
-          context = this,
+          context = this, ///
           fileNode = node,  ///
           fileVerifies = await verifyFile(fileNode, context);