occam-verify-cli 1.0.800 → 1.0.806

package/src/context/proof.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) {
+  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,13 +336,12 @@ 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);
+          proofContext = new ProofContext(context, assignments, equivalences, declaredVariables, declaredJudgements, metaLevelAssumptions, subproofOrProofAssertions);
 
     return proofContext;
   }

package/src/context/synthetic.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import Context from "../context";
 
-const { last } = arrayUtilities;
+const { push, last } = arrayUtilities;
 
 export default class SyntheticContext extends Context {
   constructor(context, contexts) {
@@ -17,157 +17,267 @@ export default class SyntheticContext extends Context {
     return this.contexts;
   }
 
-  addSubstitutions(substitutions) {
-    const context = this.getContext();
+  getTerms() {
+    const terms = [];
 
-    context.addSubstitutions(substitutions);
+    this.contexts.forEach((context) => {
+      const contextTerms = context.getTerms();
+
+      push(terms, contextTerms);
+    });
+
+    return terms;
   }
 
-  findTermByTermNode(termNode) {
-    let term = null;
+  getFrames() {
+    const frames = [];
 
-    this.contexts.some((context) => {
-      term = context.findTermByTermNode(termNode);
+    this.contexts.forEach((context) => {
+      const contextFrames = context.getFrames();
 
-      if (term !== null) {
-        return true;
-      }
+      push(frames, contextFrames);
     });
 
-    return term;
+    return frames;
   }
 
-  findFrameByFrameNode(frameNode) {
-    let frame = null;
+  getEqualities() {
+    const equalities = [];
 
-    this.contexts.some((context) => {
-      frame = context.findFrameByFrameNode(frameNode);
+    this.contexts.forEach((context) => {
+      const contextEqualities = context.getEqualities();
 
-      if (frame !== null) {
-        return true;
-      }
+      push(equalities, contextEqualities);
     });
 
-    return frame;
+    return equalities;
   }
 
-  findStatementByStatementNode(statementNode) {
-    let statement = null;
+  getJudgements() {
+    const judgements = [];
 
-    this.contexts.some((context) => {
-      statement = context.findStatementByStatementNode(statementNode);
+    this.contexts.forEach((context) => {
+      const contextJudgements = context.getJudgements();
 
-      if (statement !== null) {
-        return true;
-      }
+      push(judgements, contextJudgements);
     });
 
-    return statement;
+    return judgements;
   }
 
-  findSubstitutionBySubstitutionNode(substitutionNode) {
-    let substitution = null;
+  getStatements() {
+    const statements = [];
 
-    this.contexts.some((context) => {
-      substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
+    this.contexts.forEach((context) => {
+      const contextStatements = context.getStatements();
 
-      if (substitution !== null) {
-        return true;
-      }
+      push(statements, contextStatements);
     });
 
-    return substitution;
+    return statements;
   }
 
-  findReferenceByMetavariableNode(metavariableNode) {
-    let reference = null;
+  getAssertions() {
+    const assertions = [];
 
-    this.contexts.some((context) => {
-      reference = context.findReferenceByMetavariableNode(metavariableNode);
+    this.contexts.forEach((context) => {
+      const contextAssertions = context.getAssertions();
 
-      if (reference !== null) {
-        return true;
-      }
+      push(assertions, contextAssertions);
     });
 
-    return reference;
+    return assertions;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
-    let variable = null;
+  getReferences() {
+    const references = [];
 
-    this.contexts.some((context) => {
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    this.contexts.forEach((context) => {
+      const contextReferences = context.getReferences();
 
-      if (variable !== null) {
-        return true;
-      }
+      push(references, contextReferences);
     });
 
-    return variable;
+    return references;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    let metavariable = null;
+  getAssumptions() {
+    const assumptions = [];
 
-    this.contexts.some((context) => {
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    this.contexts.forEach((context) => {
+      const contextAssumptions = context.getAssumptions();
 
-      if (metavariable !== null) {
-        return true;
-      }
+      push(assumptions, contextAssumptions);
     });
 
-    return metavariable;
+    return assumptions;
   }
 
-  isTermPresentByTermNode(termNode) {
-    const term = this.findTermByTermNode(termNode),
-          termPresent = (term !== null);
+  getMetavariables() {
+    const metavariables = [];
 
-    return termPresent;
+    this.contexts.forEach((context) => {
+      const contextMetavariables = context.getMetavariables();
+
+      push(metavariables, contextMetavariables);
+    });
+
+    return metavariables;
   }
 
-  isFramePresentByFrameNode(frameNode) {
-    const frame = this.findFrameByFrameNode(frameNode),
-          framePresent = (frame !== null);
+  getSubstitutions() {
+    const substitutions = [];
+
+    this.contexts.forEach((context) => {
+      const contextSubstitutions = context.getSubstitutions();
+
+      push(substitutions, contextSubstitutions);
+    });
 
-    return framePresent;
+    return substitutions;
   }
 
-  isStatementPresentByStatementNode(statementNode) {
-    const statement = this.findStatementByStatementNode(statementNode),
-          statementPresent = (statement !== null);
+  findTermByTermNode(termNode) {
+    const terms = this.getTerms(),
+          term = terms.find((term) => {
+            const termNodeMatches = term.matchTermNode(termNode);
+
+            if (termNodeMatches) {
+              return true;
+            }
+          }) || null;
 
-    return statementPresent;
+    return term;
   }
 
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
-    const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode),
-      substitutionPresent = (substitution !== null);
+  findFrameByFrameNode(frameNode) {
+    const frames = this.getFrames(),
+          frame = frames.find((frame) => {
+            const frameNodeMatches = frame.matchFrameNode(frameNode);
 
-    return substitutionPresent;
+            if (frameNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return frame;
   }
 
-  isReferencePresentByMetavariableNode(metavariableNode) {
-    const reference = this.findReferenceByMetavariableNode(metavariableNode),
-          referencePresent = (reference !== null);
+  findEqualityByEqualityNode(equalityNode) {
+    const equalities = this.getEqualities(),
+          equality = equalities.find((equality) => {
+            const equalityNodeMatches = equality.matchEqualityNode(equalityNode);
 
-    return referencePresent;
+            if (equalityNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return equality;
   }
 
-  isVariablePresentByVariableIdentifier(variableIdentifier) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
-          variablePresent = (variable !== null);
+  findJudgementByJudgementNode(judgementNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);
+
+            if (judgementNodeMatches) {
+              return true;
+            }
+          }) || null;
 
-    return variablePresent;
+    return judgement;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
-          metavariablePresent = (metavariable !== null);
+  findStatementByStatementNode(statementNode) {
+    const statements = this.getStatements(),
+          statement = statements.find((statement) => {
+            const statementNodeMatches = statement.matchStatementNode(statementNode);
+
+            if (statementNodeMatches) {
+              return true;
+            }
+          }) || null;
 
-    return metavariablePresent;
+    return statement;
+  }
+
+  findReferenceByReferenceNode(referenceNode) {
+    const references = this.getReferences(),
+          reference = references.find((reference) => {
+            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
+
+            if (referenceMatcheReferenceNode) {
+              return true;
+            }
+          }) || null;
+
+    return reference;
+  }
+
+  findAssertionByAssertionNode(assertionNode) {
+    const assertions = this.getAssertions(),
+          assertion = assertions.find((assertion) => {
+            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+
+            if (assertionNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return assertion;
+  }
+
+  findAssumptionByAssumptionNode(assumptionNode) {
+    const assumptions = this.getAssumptions(),
+          assumption = assumptions.find((assumption) => {
+            const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
+
+            if (assumptionNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return assumption;
+  }
+
+  findReferenceByMetavariableNode(metavariableNode) {
+    const references = this.getReferences(),
+          reference = references.find((reference) => {
+            const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
+
+            if (referenceMatcheMetavariableNode) {
+              return true;
+            }
+          }) || null;
+
+    return reference;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
+
+            if (metavariableNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  findSubstitutionBySubstitutionNode(substitutionNode) {
+    const substitutions = this.getSubstitutions(),
+          substitution = substitutions.find((substitution) => {
+            const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
+
+            if (substitutionNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return substitution;
   }
 
   static fromContexts(...contexts) {