occam-verify-cli 1.0.612 → 1.0.631

package/src/context/liminal.js

@@ -2,11 +2,10 @@
 
 import { arrayUtilities } from "necessary";
 import { metavariableNamesFromSubstitutions } from "../utilities/substitutions";
-import { substitutionsStringFromSubstitutions } from "../utilities/string";
 
 import Context from "../context";
 
-const { find, first, prune, compress } = arrayUtilities;
+const { find, first } = arrayUtilities;
 
 export default class LiminalContext extends Context {
   constructor(context, substitutions) {
@@ -62,60 +61,34 @@ 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) {
@@ -123,23 +96,20 @@ export default class LiminalContext extends Context {
           metavariableNames = metavariableNamesFromSubstitutions(substitutions);
 
     metavariableNames.forEach((metavariableName) => {
-      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
-            complexSubstitutionsResolved = complexSubstitutions.every((complexSubstitution) => {
-              const substitution = complexSubstitution, ///
-                    resolved = substitution.isResolved();
+      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName);
 
-              if (!resolved) {
-                substitution.resolve(generalContext, specificContext);
-              }
-            });
+      complexSubstitutions.forEach((complexSubstitution) => {
+        const substitution = complexSubstitution, ///
+              resolved = substitution.isResolved();
 
-      if (complexSubstitutionsResolved) {
-        return true;
-      }
+        if (!resolved) {
+          substitution.resolve(generalContext, specificContext);
+        }
+      });
     });
   }
 
-  areSubstitutionsResolved(generalContext, specificContext) {
+  areSubstitutionsResolved() {
     const substitutions = this.getSubstitutions(),
           metavariableNames = metavariableNamesFromSubstitutions(substitutions),
           resolved = metavariableNames.every((metavariableName) => {
@@ -165,12 +135,14 @@ export default class LiminalContext extends Context {
       context = this.getContext();
     }
 
+    context.debug(`Commiting the limiinal context`);
+
     context.addSubstitutions(this.substitutions);
   }
 
-  findSubstitution(callback, generalContext, specificContext) {
+  findSubstitution(callback) {
     const substitutions = this.getSubstitutions(),
-          substitution = substitutions.find(callback, generalContext, specificContext);
+          substitution = substitutions.find(callback);
 
     return substitution;
   }
@@ -185,16 +157,12 @@ export default class LiminalContext extends Context {
     return substitutions;
   }
 
-  findSubstitutionByVariableIdentifier(variable) {
+  findSubstitutionByVariableIdentifier(variableIdentifier) {
     const substitution = this.findSubstitution((substitution) => {
-      const substitutionVariable = substitution.getVariable();
-
-      if (substitutionVariable !== null) {
-        const substitutionVariableMatchesVariableIdentifier = substitutionVariable.matchVariableIdentifier(variableIdentifier);
+      const substitutionComparesToVariableIdentifier = substitution.compareVariableIdentifier(variableIdentifier);
 
-        if (substitutionVariableMatchesVariableIdentifier) {
-          return true;
-        }
+      if (substitutionComparesToVariableIdentifier) {
+        return true;
       }
     }) || null;
 
@@ -202,13 +170,8 @@ export default class LiminalContext extends Context {
   }
 
   findSubstitutionByMetavariableName(metavariableName) {
-    const substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionMatchesMetavariableName = substitution.matchMetavariableName(metavariableName);
-
-      if (substitutionMatchesMetavariableName) {
-        return true;
-      }
-    }) || null;
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
+          substitution = simpleSubstitution;  ///
 
     return substitution;
   }
@@ -219,9 +182,9 @@ export default class LiminalContext extends Context {
 
       if (substitutionSimple) {
         const simpleSubstitution = substitution,  ///
-              simpleSubstitutionMatchesMetavariableName = simpleSubstitution.matchMetavariableName(metavariableName);
+              simpleSubstitutionComparesToMetavariableName = simpleSubstitution.compareMetavariableName(metavariableName);
 
-        if (simpleSubstitutionMatchesMetavariableName) {
+        if (simpleSubstitutionComparesToMetavariableName) {
           return true;
         }
       }
@@ -236,9 +199,9 @@ export default class LiminalContext extends Context {
 
       if (substitutionComplex) {
         const complexSubstitution = substitution,  ///
-              complexSubstitutionMatchesMetavariableName = complexSubstitution.matchMetavariableName(metavariableName);
+              complexSubstitutionComparesToMetavariableName = complexSubstitution.compareMetavariableName(metavariableName);
 
-        if (complexSubstitutionMatchesMetavariableName) {
+        if (complexSubstitutionComparesToMetavariableName) {
           return true;
         }
       }
@@ -251,9 +214,9 @@ export default class LiminalContext extends Context {
     const substitutionA = substitution; ///
 
     substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionMatchesMetavariableName = substitution.matchMetavariableName(metavariableName);
+      const substitutionComparesToMetavariableName = substitution.compareMetavariableName(metavariableName);
 
-      if (substitutionMatchesMetavariableName) {
+      if (substitutionComparesToMetavariableName) {
         const substitutionB = substitution, ///
               substitutionBSubstitutionComparesToSubstitutionA = substitutionB.compare(substitutionA);
 

package/src/context/scoped.js

@@ -17,21 +17,17 @@ class ScopedContext extends Context {
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getVariables(nested = true) {
+  getVariables() {
     let variables;
 
-    if (nested) {
-      const context = this.getContext();
+    const context = this.getContext();
 
-      variables = context.getVariables();
+    variables = context.getVariables();
 
-      variables = [
-        ...this.variables,
-        ...variables
-      ];
-    } else {
-      variables = this.variables;
-    }
+    variables = [
+      ...this.variables,
+      ...variables
+    ];
 
     return variables;
   }
@@ -67,6 +63,21 @@ class ScopedContext extends Context {
     return equivalences;
   }
 
+  getSubproofOrProofAssertions() {
+    let subproofOrProofAssertions;
+
+    const context = this.getContext();
+
+    subproofOrProofAssertions = context.getSubproofOrProofAssertions();
+
+    subproofOrProofAssertions = [  ///
+      ...subproofOrProofAssertions,
+      ...this.subproofOrProofAssertions
+    ];
+
+    return subproofOrProofAssertions;
+  }
+
   getProofAssertions() {
     const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),
           proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {
@@ -93,93 +104,57 @@ class ScopedContext extends Context {
     return lastProofAssertion;
   }
 
-  getSubproofOrProofAssertions() {
-    let subproofOrProofAssertions;
-
-    const context = this.getContext();
-
-    subproofOrProofAssertions = context.getSubproofOrProofAssertions();
-
-    subproofOrProofAssertions = [  ///
-      ...subproofOrProofAssertions,
-      ...this.subproofOrProofAssertions
-    ];
-
-    return subproofOrProofAssertions;
-  }
-
   addEquality(equality) {
-    let equalityAdded;
+    const context = this, ///
+          equalityString = equality.getString();
+
+    context.trace(`Adding the '${equalityString}' equality to the scoped context...`);
 
-    const equalityReflexive = equality.isReflexive();
+    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; ///
+            equivalence = Equivalence.fromEquality(equality, context);
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
-    }
-
-    equalityAdded = true;
-
-    if (equalityAdded) {
-      const context = this, ///
-            equalityString = equality.getString();
 
-      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;
-
-    const variableIdentifier = variable.getIdentifier(),
-          variablePresent = this.isVariablePresentByVariableIdentifier(variableIdentifier, nested);
-
-    if (!variablePresent) {
-      this.variables.push(variable);
-
-      variableAdded = true;
-    }
+  addVariable(variable) {
+    const context = this, ///
+          variableString = variable.getString();
 
-    if (variableAdded) {
-      const context = this,
-            variableString = variable.getString();
+    context.trace(`Adding the '${variableString}' variable to the scoped context...`);
 
-      context.trace(`Added the '${variableString}' variable.`)
-    }
+    this.variables.push(variable);
 
-    return variableAdded;
+    context.debug(`...added the '${variableString}' variable to the scoped context.`);
   }
 
   addJudgement(judgement) {
-    let judgementAdded = false;
-
-    const metavariable = judgement.getMetavariable(),
-          metavariableName = metavariable.getMetavariableName(),
-          judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName);
-
-    if (!judgementPresent) {
-      this.judgements.push(judgement);
-
-      judgementAdded = true;
-    }
+    const context = this, ///
+          judgementString = judgement.getString();
 
-    if (judgementAdded) {
-      const context = this, ///
-            judgementString = judgement.getString();
+    context.trace(`Adding the '${judgementString}' judgement to the scoped context...`);
 
-      context.trace(`Added the '${judgementString}' judgement.`)
-    }
+    this.judgements.push(judgement);
 
-    return judgementAdded;
+    context.debug(`...added the '${judgementString}' judgement to the scoped context.`);
   }
 
   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); }
@@ -187,7 +162,7 @@ class ScopedContext extends Context {
   findJudgementByMetavariableName(metavariableName) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMetavariableComparesToMetavariable = judgement.matchMetavariableName(metavariableName);
+            const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
 
             if (judgementMetavariableComparesToMetavariable) {
               return true;
@@ -197,8 +172,8 @@ class ScopedContext extends Context {
     return judgement;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier, nested = true) {
-    const variables = this.getVariables(nested),
+  findVariableByVariableIdentifier(variableIdentifier) {
+    const variables = this.getVariables(),
           variable = variables.find((variable) => {
             const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
 
@@ -220,7 +195,7 @@ class ScopedContext extends Context {
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
         const groundedTermNode = groundedTerm.getNode(),
-              groundedTermNodeMatches = term.matchNode(groundedTermNode);
+              groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
             if (groundedTermNodeMatches) {
               return true;
@@ -238,8 +213,8 @@ class ScopedContext extends Context {
     return judgementPresent;
   }
 
-  isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
+  isVariablePresentByVariableIdentifier(variableIdentifier) {
+    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
           variablePresent = (variable !== null);
 
     return variablePresent;

package/src/context.js

@@ -33,11 +33,18 @@ export default class Context extends ContextBase {
 
   getFrames() {
     const context = this.getContext(),
-          frames = context.getFrames();
+      frames = context.getFrames();
 
     return frames;
   }
 
+  getEqualities() {
+    const context = this.getContext(),
+          equalities = context.getEqualities();
+
+    return equalities;
+  }
+
   getStatements() {
     const context = this.getContext(),
           statements = context.getStatements();
@@ -52,6 +59,13 @@ export default class Context extends ContextBase {
     return references;
   }
 
+  getEquivalences() {
+    const context = this.getContext(),
+          equivalences = context.getEquivalences();
+
+    return equivalences;
+  }
+
   getSubstitutions() {
     const context = this.getContext(),
           substitutions = context.getSubstitutions();
@@ -102,20 +116,55 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
-  findProcedureByName(name) {
+  findRuleByReference(reference) {
     const context = this.getContext(),
-          procedure = context.findProcedureByName(name);
+      rule = context.findRuleByReference(reference);
 
-    return procedure;
+    return rule;
+  }
+
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+    return topLevelAssertion;
+  }
+
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const context = this.getContext(),
+          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+
+    return metaType;
+  }
+
+  findTermByTermNode(termNode) {
+    const context = this.getContext(),
+          term = context.findTermByTermNode(termNode);
+
+    return term;
   }
 
   findFrameByFrameNode(frameNode) {
     const context = this.getContext(),
-          frame = context.findFrameByFrameNode(frameNode);
+      frame = context.findFrameByFrameNode(frameNode);
 
     return frame;
   }
 
+  findEqualityByEqualityNode(equalityNode) {
+    const context = this.getContext(),
+      equality = context.findEqualityByEqualityNode(equalityNode);
+
+    return equality;
+  }
+
+  findJudgementByJudgementNode(judgementNode) {
+    const context = this.getContext(),
+          judgement = context.findJudgementByJudgementNode(judgementNode);
+
+    return judgement;
+  }
+
   findStatementByStatementNode(statementNode) {
     const context = this.getContext(),
           statement = context.findStatementByStatementNode(statementNode);
@@ -180,32 +229,40 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
-  findRuleByReference(reference) {
+  findProcedureByProcedureName(procedureName) {
     const context = this.getContext(),
-          rule = context.findRuleByReference(reference);
+      procedure = context.findProcedureByProcedureName(procedureName);
 
-    return rule;
+    return procedure;
   }
 
-  findTopLevelAssertionByReference(reference) {
+  isMetavariablePresent(metavariable) {
+    metavariable = this.findMetavariable(metavariable); ///
+
+    const metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
+  isLabelPresentByReference(reference) {
     const context = this.getContext(),
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+          labelPresent = context.isLabelPresentByReference(reference);
 
-    return topLevelAssertion;
+    return labelPresent;
   }
 
-  isTermPresentByTermNode(termNode) {
+  isMetavariablePresentByReference(reference) {
     const context = this.getContext(),
-          termPresent = context.isTermPresentByTermNode(termNode);
+          metavariablePresent = context.isMetavariablePresentByReference(reference);
 
-    return termPresent;
+    return metavariablePresent;
   }
 
-  isProcedurePresentByName(name) {
+  isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByName(name);
+          termPresent = context.isTermPresentByTermNode(termNode);
 
-    return procedurePresent;
+    return termPresent;
   }
 
   isFramePresentByFrameNode(frameNode) {
@@ -215,6 +272,20 @@ export default class Context extends ContextBase {
     return framePresent;
   }
 
+  isJudgementPresentByJudgementNode(judgementNode) {
+    const context = this.getContext(),
+          judgementPresent = context.isJudgementPresentByJudgementNode(judgementNode);
+
+    return judgementPresent;
+  }
+
+  isEqualityPresentByEqualityNode(equalityNode) {
+    const context = this.getContext(),
+          equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode);
+
+    return equalityPresent;
+  }
+
   isStatementPresentByStatementNode(statementNode) {
     const context = this.getContext(),
       statementPresent = context.isStatementPresentByStatementNode(statementNode);
@@ -229,9 +300,9 @@ export default class Context extends ContextBase {
     return assertionPresent;
   }
 
-  isReferencePresentByReferenceNode(referenceNode) {
+  isReferencePresentByMetavariableNode(metvvariableNode) {
     const context = this.getContext(),
-          referencePresent = context.isReferencePresentByReferenceNode(referenceNode);
+          referencePresent = context.isReferencePresentByMetavariableNode(metvvariableNode);
 
     return referencePresent;
   }
@@ -250,30 +321,17 @@ export default class Context extends ContextBase {
     return substitutionPresent;
   }
 
-  isLabelPresentByReference(reference) {
+  isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
-          labelPresent = context.isLabelPresentByReference(reference);
-
-    return labelPresent;
-  }
-
-  isMetavariablePresentByReference(reference) {
-    const context = this.getContext(),
-          metavariablePresent = context.isMetavariablePresentByReference(reference);
-
-    return metavariablePresent;
-  }
-
-  addRule(rule) {
-    const context = this.getContext();
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
 
-    context.addRule(rule);
+    return procedurePresent;
   }
 
-  adTerm(term) {
+  addTerm(term) {
     const context = this.getContext();
 
-    context.adTerm(term);
+    context.addTerm(term);
   }
 
   addFrame(frame) {
@@ -295,10 +353,9 @@ export default class Context extends ContextBase {
   }
 
   addJudgement(judgement) {
-    const context = this.getContext(),
-          judgementAdded = context.addJudgement(judgement);
+    const context = this.getContext();
 
-    return judgementAdded;
+    context.addJudgement(judgement);
   }
 
   addSubstitution(substitution) {
@@ -307,12 +364,6 @@ export default class Context extends ContextBase {
     context.addSubstitution(substitution);
   }
 
-  removeSubstitution(substitution) {
-    const context = this.getContext();
-
-    context.removeSubstitution(substitution);
-  }
-
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -72,6 +72,10 @@ export default define(class ContainedAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
       }
     }

package/src/element/assertion/defined.js

@@ -66,6 +66,10 @@ export default define(class DefinedAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validates the '${definedAssertionString}' defined assertion.`);
       }
     }