occam-verify-cli 1.0.611 → 1.0.617

package/src/context/file/nominal.js

@@ -259,54 +259,119 @@ 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) {
@@ -404,10 +469,10 @@ export default class NominalFileContext extends FileContext {
     return theorem;
   }
 
-  findProcedureByName(name) {
+  findProcedureByProcedureName(procedureName) {
     const procedures = this.getProcedures(),
           procedure = procedures.find((procedure) => {
-            const nameMatches = procedure.matchName(name);
+            const nameMatches = procedure.matchName(procedureName);
 
             if (nameMatches) {
               return true;
@@ -650,14 +715,6 @@ export default class NominalFileContext extends FileContext {
     return metavariable;
   }
 
-  isMetavariablePresent(metavariable) {
-    metavariable = this.findMetavariable(metavariable);
-
-    const metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
   isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) {
     const type = this.findTypeByTypeName(typeName, includeRelease, includeDependencies),
           typePresent = (type !== null);
@@ -714,6 +771,21 @@ export default class NominalFileContext extends FileContext {
     return metavariablePresent;
   }
 
+  isMetavariablePresent(metavariable) {
+    metavariable = this.findMetavariable(metavariable);
+
+    const metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
+  isProcedurePresentByProcedureName(procedureName) {
+    const procedure = this.findProcedureByProcedureName(procedureName),
+          procedurePresent = (procedure !== null);
+
+    return procedurePresent;
+  }
+
   isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
@@ -728,13 +800,6 @@ export default class NominalFileContext extends FileContext {
     return labelPresent;
   }
 
-  isProcedurePresentByName(name) {
-    const procedure = this.findProcedureByName(name),
-          procedurePresent = (procedure !== null);
-
-    return procedurePresent;
-  }
-
   isMetavariablePresentByReference(reference) {
     const metavariables = this.getMetavariables(),
           metavariablePresent = metavariables.some((metavariable) => {

package/src/context/liminal.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
-import { metavariablesFromSubstitutions } from "../utilities/substitutions";
-import { substitutionsStringFromSubstitutions } from "../utilities/string";
+import { metavariableNamesFromSubstitutions } from "../utilities/substitutions";
 
 import Context from "../context";
 
-const { find, first, prune, compress } = arrayUtilities;
+const { find, first } = arrayUtilities;
 
 export default class LiminalContext extends Context {
   constructor(context, substitutions) {
@@ -62,68 +61,42 @@ export default class LiminalContext extends Context {
   }
 
   addSubstitution(substitution) {
-    const context = this,
+    const context = this, ///
+          substitutionA = substitution, ///
           substitutionString = substitution.getString();
 
-    this.substitutions = [ ///
-      ...this.substitutions,
-      substitution
-    ];
+    context.trace(`Adding the '${substitutionString}' substitution to the liminal context...`);
 
-    compress(this.substitutions, (substitutionA, substitutionB) => {
-      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+    const substitutionB = this.substitutions.find((substitution) => {
+      const substitutionB = substitution, ///
+            substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
 
-      if (!substitutionAEqualToSubstitutionB) {
+      if (substitutionAEqualToSubstitutionB) {
         return true;
       }
-    });
-
-    context.trace(`Added the '${substitutionString}' substitution to the context.`);
-  }
-
-  addSubstitutions(substitutions) {
-    const context = this,
-          substitutionsString = substitutionsStringFromSubstitutions(substitutions);
-
-    this.substitutions = [ ///
-      ...this.substitutions,
-      ...substitutions
-    ];
-
-    compress(this.substitutions, (substitutionA, substitutionB) => {
-      const substitutionAEqualToAssertionB = substitutionA.isEqualTo(substitutionB);
+    }) || null;
 
-      if (!substitutionAEqualToAssertionB) {
-        return true;
-      }
-    });
+    if (substitutionB !== null) {
+      context.trace(`The '${substitutionString}' substitution has already been added to the liminal context.`);
+    } else {
+      this.substitutions.push(substitution);
 
-    context.trace(`Added the '${substitutionsString}' substitutions to the context.`);
+      context.debug(`...added the '${substitutionString}' substitution to the liminal context.`);
+    }
   }
 
-  removeSubstitution(substitution) {
-    const context = this,
-          substitutionA = substitution, ///
-          substitutionString = substitution.getString();
-
-    prune(this.substitutions, (substitution) => {
-      const substitutionB = substitution,
-            substitutionAEqualTosubstitutionB = substitutionA.isEqualTo(substitutionB);
-
-      if (!substitutionAEqualTosubstitutionB) {
-        return true;
-      }
+  addSubstitutions(substitutions) {
+    substitutions.forEach((substitution) => {
+      this.addSubstitution(substitution);
     });
-
-    context.trace(`Removed the '${substitutionString}' substitution to the context.`);
   }
 
   resolveSubstitutions(generalContext, specificContext) {
     const substitutions = this.getSubstitutions(),
-          metavariables = metavariablesFromSubstitutions(substitutions, generalContext, specificContext);
+          metavariableNames = metavariableNamesFromSubstitutions(substitutions);
 
-    metavariables.forEach((metavariable) => {
-      const complexSubstitutions = this.findComplexSubstitutionsByMetavariable(metavariable),
+    metavariableNames.forEach((metavariableName) => {
+      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
             complexSubstitutionsResolved = complexSubstitutions.every((complexSubstitution) => {
               const substitution = complexSubstitution, ///
                     resolved = substitution.isResolved();
@@ -139,11 +112,11 @@ export default class LiminalContext extends Context {
     });
   }
 
-  areSubstitutionsResolved(generalContext, specificContext) {
+  areSubstitutionsResolved() {
     const substitutions = this.getSubstitutions(),
-          metavariables = metavariablesFromSubstitutions(substitutions, generalContext, specificContext),
-          resolved = metavariables.every((metavariable) => {
-            const complexSubstitutions = this.findComplexSubstitutionsByMetavariable(metavariable),
+          metavariableNames = metavariableNamesFromSubstitutions(substitutions),
+          resolved = metavariableNames.every((metavariableName) => {
+            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
                   complexSubstitutionsResolved = complexSubstitutions.every((complexSubstitution) => {
                     const complexSubstitutionResolved = complexSubstitution.isResolved();
 
@@ -165,6 +138,8 @@ export default class LiminalContext extends Context {
       context = this.getContext();
     }
 
+    context.debug(`Commiting the limiinal context`);
+
     context.addSubstitutions(this.substitutions);
   }
 
@@ -213,15 +188,15 @@ export default class LiminalContext extends Context {
     return substitution;
   }
 
-  findSimpleSubstitutionByMetavariable(metavariable) {
+  findSimpleSubstitutionByMetavariableName(metavariableName) {
     const simpleSubstitution = this.findSubstitution((substitution) => {
       const substitutionSimple = substitution.isSimple();
 
       if (substitutionSimple) {
         const simpleSubstitution = substitution,  ///
-              simpleSubstitutionMetavariableComparesToMetavariable = simpleSubstitution.compareMetavariable(metavariable);
+              simpleSubstitutionMatchesMetavariableName = simpleSubstitution.matchMetavariableName(metavariableName);
 
-        if (simpleSubstitutionMetavariableComparesToMetavariable) {
+        if (simpleSubstitutionMatchesMetavariableName) {
           return true;
         }
       }
@@ -230,21 +205,21 @@ export default class LiminalContext extends Context {
     return simpleSubstitution;
   }
 
-  findComplexSubstitutionsByMetavariable(metavariable) {
-    const complexSubstitutions = this.findSubstitutions((substitution) => {
+  findComplexSubstitutionsByMetavariableName(metavariableName) {
+    const complexSubstitution = this.findSubstitutions((substitution) => {
       const substitutionComplex = substitution.isComplex();
 
       if (substitutionComplex) {
-        const complexSubstitution = substitution, ///
-              complexSubstitutionMetavariableComparesToMetavariable = complexSubstitution.compareMetavariable(metavariable);
+        const complexSubstitution = substitution,  ///
+              complexSubstitutionMatchesMetavariableName = complexSubstitution.matchMetavariableName(metavariableName);
 
-        if (complexSubstitutionMetavariableComparesToMetavariable) {
+        if (complexSubstitutionMatchesMetavariableName) {
           return true;
         }
       }
-    });
+    }) || null;
 
-    return complexSubstitutions;
+    return complexSubstitution;
   }
 
   findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) {
@@ -266,8 +241,8 @@ export default class LiminalContext extends Context {
     return substitution;
   }
 
-  isSimpleSubstitutionPresentByMetavariable(metavariable) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariable(metavariable),
+  isSimpleSubstitutionPresentByMetavariableName(metavariableName) {
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
           simpleSubstitutionPresent = (simpleSubstitution !== null);
 
     return simpleSubstitutionPresent;

package/src/context/scoped.js

@@ -109,77 +109,93 @@ class ScopedContext extends Context {
   }
 
   addEquality(equality) {
-    let equalityAdded;
+    let equalityAdded = false;
 
-    const equalityReflexive = equality.isReflexive();
+    const context = this, ///
+          equalityString = equality.getString();
+
+    context.trace(`Adding the '${equalityString}' equality to the scoped context...`);
+
+    const equalityRelfexive = equality.isReflexive();
 
-    if (!equalityReflexive) {
+    if (equalityRelfexive) {
+      context.trace(`The '${equalityString}' equality is reflexive and will not added to the scoped context.`);
+    } else {
       const { Equivalence } = elements,
             equivalence = Equivalence.fromEquality(equality),
             context = this; ///
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
-    }
-
-    equalityAdded = true;
 
-    if (equalityAdded) {
-      const context = this, ///
-            equalityString = equality.getString();
+      equalityAdded = true;
 
-      context.trace(`Added the '${equalityString}' equality.`)
+      context.debug(`...added the '${equalityString}' equality to the scoped context.`);
     }
 
     return equalityAdded;
   }
 
-  addVariable(variable, nested = true) {
-    let variableAdded = false;
+  addVariable(variable) {
+    const context = this, ///
+          variableA = variable, ///
+          variableString = variable.getString();
 
-    const variableIdentifier = variable.getIdentifier(),
-          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
+    context.trace(`Adding the '${variableString}' variable to the scoped context...`);
 
-    if (!variablePresent) {
-      this.variables.push(variable);
+    const variableB = this.variables.find((variable) => {
+      const variableB = variable, ///
+            variableAComparesToVariableB = variableA.compare(variableB);
 
-      variableAdded = true;
-    }
+      if (variableAComparesToVariableB) {
+        return true;
+      }
+    }) || null;
 
-    if (variableAdded) {
-      const context = this,
-            variableString = variable.getString();
+    if (variableB !== null) {
+      context.trace(`The '${variableString}' variable has already been added to the scoped context.`);
+    } else {
+      this.variables.push(variable);
 
-      context.trace(`Added the '${variableString}' variable.`)
+      context.debug(`...added the '${variableString}' variable to the scoped context.`);
     }
-
-    return variableAdded;
   }
 
   addJudgement(judgement) {
     let judgementAdded = false;
 
+    const context = this, ///
+          judgementString = judgement.getString();
+
+    context.trace(`Adding the '${judgementString}' judgement to the scoped context...`);
+
     const metavariable = judgement.getMetavariable(),
           metavariableName = metavariable.getMetavariableName(),
           judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName);
 
-    if (!judgementPresent) {
+    if (judgementPresent) {
+      const metavariableString = metavariable.getString();
+
+      context.trace(`A '${judgementString}' judgement for the '${metavariableString}' metavariable is already present.`);
+    } else {
       this.judgements.push(judgement);
 
       judgementAdded = true;
-    }
 
-    if (judgementAdded) {
-      const context = this, ///
-            judgementString = judgement.getString();
-
-      context.trace(`Added the '${judgementString}' judgement.`)
+      context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
     }
 
     return judgementAdded;
   }
 
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    const context = this, ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
+
+    context.trace(`Adding the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context...`);
+
     this.subproofOrProofAssertions.push(subproofOrProofAssertion);
+
+    context.debug(`...added the '${subproofOrProofAssertionString}' subproof or proof assertion to the scoped context.`);
   }
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }