occam-verify-cli 1.0.800 → 1.0.809

package/src/context/{proof.js → bounded.js}

@@ -3,52 +3,23 @@
 import { arrayUtilities } from "necessary";
 
 import Context from "../context";
-import elements from "../elements";
+
+import { mergeEquivalences, findEquivalenceByTerm, equivalencesFromEquality, separateGroundedTermsAndDefinedVariables } from "../utilities/equivalences";
 
 const { last, filter } = arrayUtilities;
 
-class ProofContext extends Context {
-  constructor(context, variables, judgements, assignments, equivalences, metaLevelAssumptions, subproofOrProofAssertions) {
+class BoundedContext extends Context {
+  constructor(context, assignments, equivalences, declaredVariables, declaredJudgements, metaLevelAssumptions, subproofOrProofAssertions) {
     super(context);
 
-    this.variables = variables;
-    this.judgements = judgements;
     this.assignments = assignments;
     this.equivalences = equivalences;
+    this.declaredVariables = declaredVariables;
+    this.declaredJudgements = declaredJudgements;
     this.metaLevelAssumptions = metaLevelAssumptions;
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getVariables() {
-    let variables;
-
-    const context = this.getContext();
-
-    variables = context.getVariables();
-
-    variables = [
-      ...this.variables,
-      ...variables
-    ];
-
-    return variables;
-  }
-
-  getJudgements() {
-    let judgements;
-
-    const context = this.getContext();
-
-    judgements = context.getJudgements();
-
-    judgements = [ ///
-      ...this.judgements,
-      ...judgements
-    ]
-
-    return judgements;
-  }
-
   getAssignments() {
     return this.assignments;
   }
@@ -64,11 +35,41 @@ class ProofContext extends Context {
 
     context = this; ///
 
-    equivalences = this.equivalences.mergedWith(equivalences, context);  ///
+    equivalences = mergeEquivalences(this.equivalences, equivalences, context);  ///
 
     return equivalences;
   }
 
+  getDeclaredVariables() {
+    let declaredVariables;
+
+    const context = this.getContext();
+
+    declaredVariables = context.getDeclaredVariables();
+
+    declaredVariables = [
+      ...this.declaredVariables,
+      ...declaredVariables
+    ];
+
+    return declaredVariables;
+  }
+
+  getDeclaredJudgements() {
+    let declaredJudgements;
+
+    const context = this.getContext();
+
+    declaredJudgements = context.getDeclaredJudgements();
+
+    declaredJudgements = [ ///
+      ...this.declaredJudgements,
+      ...declaredJudgements
+    ]
+
+    return declaredJudgements;
+  }
+
   getMetaLevelAssumptions() {
     return this.metaLevelAssumptions;
   }
@@ -139,10 +140,9 @@ class ProofContext extends Context {
     const equalityRelfexive = equality.isReflexive();
 
     if (!equalityRelfexive) {
-      const { Equivalence } = elements,
-            equivalence = Equivalence.fromEquality(equality, context);
+      const equivalence = equivalencesFromEquality(equality, context);
 
-      this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
+      this.equivalences = mergeEquivalences(this.equivalences, equivalence, context);
 
       context.debug(`...added the '${equalityString}' equality to the proof context.`);
     } else {
@@ -150,38 +150,38 @@ class ProofContext extends Context {
     }
   }
 
-  addVariable(variable) {
-    const context = this, ///
-          variableString = variable.getString();
-
-    context.trace(`Adding the '${variableString}' variable to the proof context...`);
+  addAssignment(assignment) {
+    this.assignments.push(assignment);
+  }
 
-    this.variables.push(variable);
+  assignAssignments() {
+    const context = this; ///
 
-    context.debug(`...added the '${variableString}' variable to the proof context.`);
+    this.assignments.forEach((assignment) => {
+      assignment(context);
+    });
   }
 
-  addJudgement(judgement) {
+  addDEclaredVariable(declaredVariable) {
     const context = this, ///
-          judgementString = judgement.getString();
+          declaredVariableString = declaredVariable.getString();
 
-    context.trace(`Adding the '${judgementString}' judgement to the proof context...`);
+    context.trace(`Adding the '${declaredVariableString}' declared variable to the proof context...`);
 
-    this.judgements.push(judgement);
+    this.declaredVariables.push(declaredVariable);
 
-    context.debug(`...added the '${judgementString}' judgement to the proof context.`);
+    context.debug(`...added the '${declaredVariableString}' declared variable to the proof context.`);
   }
 
-  addAssignment(assignment) {
-    this.assignments.push(assignment);
-  }
+  addDeclaredJudgement(declaredJudgement) {
+    const context = this, ///
+          declaredJudgementString = declaredJudgement.getString();
 
-  assignAssignments() {
-    const context = this; ///
+    context.trace(`Adding the '${declaredJudgementString}' declared judgement to the proof context...`);
 
-    this.assignments.forEach((assignment) => {
-      assignment(context);
-    });
+    this.declaredJudgements.push(declaredJudgement);
+
+    context.debug(`...added the '${declaredJudgementString}' declared judgement to the proof context.`);
   }
 
   addMetaLevelAssumption(metaLevelAssumption) {
@@ -210,9 +210,9 @@ class ProofContext extends Context {
       context.debug(`The '${metaLevelAssumptionString}' metaLevelAssumption has already been added to the proof context.`);
     } else {
       this.metaLevelAssumptions.push(metaLevelAssumption);
-
-      context.debug(`...added the '${metaLevelAssumptionString}' meta-level assumption to the proof context.`);
     }
+
+    context.debug(`...added the '${metaLevelAssumptionString}' meta-level assumption to the proof context.`);
   }
 
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
@@ -240,11 +240,11 @@ class ProofContext extends Context {
     return comparesToTermAndPropertyRelation;
   }
 
-  findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
+  findEquivalenceByTerm(term) { return findEquivalenceByTerm(this.equivalences, term); }
 
   findJudgementByMetavariableName(metavariableName) {
-    const judgements = this.getJudgements(),
-          judgement = judgements.find((judgement) => {
+    const declaredJudgements = this.getJudgements(),
+          judgement = declaredJudgements.find((judgement) => {
             const judgementMetavariableComparesToMetavariable = judgement.compareMetavariableName(metavariableName);
 
             if (judgementMetavariableComparesToMetavariable) {
@@ -255,23 +255,23 @@ class ProofContext extends Context {
     return judgement;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
-    const variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const variableComparesToVariableIdentifier = variable.compareVariableIdentifier(variableIdentifier);
+  findDeclaredVariableByVariableIdentifier(variableIdentifier) {
+    const declaredVariables = this.getDeclaredVariables(),
+          declaredVariable = declaredVariables.find((declaredVariable) => {
+            const variableComparesToVariableIdentifier = declaredVariable.compareVariableIdentifier(variableIdentifier);
 
             if (variableComparesToVariableIdentifier) {
               return true;
             }
           }) || null;
 
-    return variable;
+    return declaredVariable;
   }
 
   findJudgementsByMetavariableNode(metavariableNode) {
-    const judgements = this.getJudgements();
+    const declaredJudgements = this.getJudgements();
 
-    filter(judgements, (judgement) => {
+    filter(declaredJudgements, (judgement) => {
       const metavariableNodeMatches = judgement.matchMetavariableNode(metavariableNode);
 
       if (metavariableNodeMatches) {
@@ -279,7 +279,7 @@ class ProofContext extends Context {
       }
     });
 
-    return judgements;
+    return declaredJudgements;
   }
 
   findMetaLevelAssumptionByMetaLevelAssumptionNode(metaLevelAssumptionNode) {
@@ -307,11 +307,11 @@ class ProofContext extends Context {
     return judgementPresent;
   }
 
-  isVariablePresentByVariableIdentifier(variableIdentifier) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
-          variablePresent = (variable !== null);
+  isDeclaredVariablePresentByVariableIdentifier(variableIdentifier) {
+    const declaredVariable = this.findDeclaredVariableByVariableIdentifier(variableIdentifier),
+          declaredVariablePresent = (declaredVariable !== null);
 
-    return variablePresent;
+    return declaredVariablePresent;
   }
 
   isTermGrounded(term) {
@@ -320,7 +320,7 @@ class ProofContext extends Context {
           groundedTerms = [],
           definedVariables = [];
 
-    equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
+    separateGroundedTermsAndDefinedVariables(equivalences, groundedTerms, definedVariables, context);
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
             const groundedTermNode = groundedTerm.getNode(),
@@ -336,16 +336,15 @@ class ProofContext extends Context {
   }
 
   static fromMetaLevelAssumptions(metaLevelAssumptions, context) {
-    const { Equivalences } = elements,
-          variables = [],
-          judgements = [],
-          assignments = [],
-          equivalences = Equivalences.fromNothing(context),
+    const assignments = [],
+          equivalences = [],
+          declaredVariables = [],
+          declaredJudgements = [],
           subproofOrProofAssertions = [],
-          proofContext = new ProofContext(context, variables, judgements, assignments, equivalences, metaLevelAssumptions, subproofOrProofAssertions);
+          boundedContext = new BoundedContext(context, assignments, equivalences, declaredVariables, declaredJudgements, metaLevelAssumptions, subproofOrProofAssertions);
 
-    return proofContext;
+    return boundedContext;
   }
 }
 
-export default ProofContext;
+export default BoundedContext;

package/src/context/branching.js

@@ -33,9 +33,9 @@ export default class BranchingContext extends Context {
       context.trace(`The '${termString}' term has already been added to the branching context.`);
     } else {
       this.terms.push(term);
-
-      context.debug(`...added the '${termString}' term to the branching context.`);
     }
+
+    context.debug(`...added the '${termString}' term to the branching context.`);
   }
 
   addTerms(terms) {