occam-verify-cli 1.0.809 → 1.0.814

package/src/context/file/nominal.js

@@ -429,11 +429,11 @@ export default class NominalFileContext extends FileContext {
 
   findRuleByReference(reference) {
     const rules = this.getRules(),
-          metavariableName = reference.getMetavariableName(),
+          metavariableNode = reference.getMetavariableNode(),
           rule = rules.find((rule) => {
-            const ruleComparesToMetavariableName = rule.compareMetavariableName(metavariableName);
+            const metavariableNodeMatches = rule.matchMetavariableNode(metavariableNode);
 
-            if (ruleComparesToMetavariableName) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -443,11 +443,11 @@ export default class NominalFileContext extends FileContext {
 
   findAxiomByReference(reference) {
     const axioms = this.getAxioms(),
-          metavariableName = reference.getMetavariableName(),
+          metavariableNode = reference.getMetavariableNode(),
           axiom = axioms.find((axiom) => {
-            const axiomComparesToMetavariableName = axiom.compareMetavariableName(metavariableName);
+            const metavariableNodeMatches = axiom.matchMetavariableNode(metavariableNode);
 
-            if (axiomComparesToMetavariableName) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -457,11 +457,11 @@ export default class NominalFileContext extends FileContext {
 
   findLemmaByReference(reference) {
     const lemmas = this.getLemmas(),
-          metavariableName = reference.getMetavariableName(),
+          metavariableNode = reference.getMetavariableNode(),
           lemma = lemmas.find((lemma) => {
-            const lemmaComparesToMetavariableName = lemma.compareMetavariableName(metavariableName);
+            const metavariableNodeMatches = lemma.matchMetavariableNode(metavariableNode);
 
-            if (lemmaComparesToMetavariableName) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -471,11 +471,11 @@ export default class NominalFileContext extends FileContext {
 
   findTheoremByReference(reference) {
     const theorems = this.getTheorems(),
-          metavariableName = reference.getMetavariableName(),
+          metavariableNode = reference.getMetavariableNode(),
           theorem = theorems.find((theorem) => {
-            const theoremComparesToMetavariableName = theorem.compareMetavariableName(metavariableName);
+            const metavariableNodeMatches = theorem.matchMetavariableNode(metavariableNode);
 
-            if (theoremComparesToMetavariableName) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -485,11 +485,11 @@ export default class NominalFileContext extends FileContext {
 
   findConjectureByReference(reference) {
     const conjectures = this.getConjectures(),
-          metavariableName = reference.getMetavariableName(),
+          metavariableNode = reference.getMetavariableNode(),
           conjecture = conjectures.find((conjecture) => {
-            const conjectureComparesToMetavariableName = conjecture.compareMetavariableName(metavariableName);
+            const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
 
-            if (conjectureComparesToMetavariableName) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;

package/src/context/liminal.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
-import { metavariableNamesFromSubstitutions } from "../utilities/substitutions";
+import { metavariableNodesFromSubstitutions } from "../utilities/substitutions";
 
 import Context from "../context";
 import elements from "../elements";
@@ -96,19 +96,20 @@ export default class LiminalContext extends Context {
     });
   }
 
-  resolveSubstitutions(generalContext, specificContext) {
-    const substitutions = this.getSubstitutions(),
-          metavariableNames = metavariableNamesFromSubstitutions(substitutions);
+  resolveSubstitutions() {
+    const context = this, ///
+          substitutions = this.getSubstitutions(),
+          metavariableNodes = metavariableNodesFromSubstitutions(substitutions);
 
-    metavariableNames.forEach((metavariableName) => {
-      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName);
+    metavariableNodes.forEach((metavariableNode) => {
+      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode);
 
       complexSubstitutions.forEach((complexSubstitution) => {
         const substitution = complexSubstitution, ///
               resolved = substitution.isResolved();
 
         if (!resolved) {
-          substitution.resolve(generalContext, specificContext);
+          substitution.resolve(context);
         }
       });
     });
@@ -116,9 +117,9 @@ export default class LiminalContext extends Context {
 
   areSubstitutionsResolved() {
     const substitutions = this.getSubstitutions(),
-          metavariableNames = metavariableNamesFromSubstitutions(substitutions),
-          resolved = metavariableNames.every((metavariableName) => {
-            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
+          metavariableNodes = metavariableNodesFromSubstitutions(substitutions),
+          resolved = metavariableNodes.every((metavariableNode) => {
+            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
                   complexSubstitutionsResolved = complexSubstitutions.every((complexSubstitution) => {
                     const complexSubstitutionResolved = complexSubstitution.isResolved();
 
@@ -195,11 +196,11 @@ export default class LiminalContext extends Context {
     return substitutions;
   }
 
-  findSubstitutionByVariableIdentifier(variableIdentifier) {
+  findSubstitutionByVariableNode(variableNode) {
     const substitution = this.findSubstitution((substitution) => {
-      const substitutionComparesToVariableIdentifier = substitution.compareVariableIdentifier(variableIdentifier);
+      const substitutionComparesToVariableNode = substitution.compareVariableNode(variableNode);
 
-      if (substitutionComparesToVariableIdentifier) {
+      if (substitutionComparesToVariableNode) {
         return true;
       }
     }) || null;
@@ -207,22 +208,22 @@ export default class LiminalContext extends Context {
     return substitution;
   }
 
-  findSubstitutionByMetavariableName(metavariableName) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
+  findSubstitutionByMetavariableNode(metavariableNode) {
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableNode(metavariableNode),
           substitution = simpleSubstitution;  ///
 
     return substitution;
   }
 
-  findSimpleSubstitutionByMetavariableName(metavariableName) {
+  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
     const simpleSubstitution = this.findSubstitution((substitution) => {
       const substitutionSimple = substitution.isSimple();
 
       if (substitutionSimple) {
         const simpleSubstitution = substitution,  ///
-              simpleSubstitutionComparesToMetavariableName = simpleSubstitution.compareMetavariableName(metavariableName);
+              metavariableNodeMatches = simpleSubstitution.matchMetavariableNode(metavariableNode);
 
-        if (simpleSubstitutionComparesToMetavariableName) {
+        if (metavariableNodeMatches) {
           return true;
         }
       }
@@ -231,15 +232,15 @@ export default class LiminalContext extends Context {
     return simpleSubstitution;
   }
 
-  findComplexSubstitutionsByMetavariableName(metavariableName) {
+  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
     const complexSubstitution = this.findSubstitutions((substitution) => {
       const substitutionComplex = substitution.isComplex();
 
       if (substitutionComplex) {
         const complexSubstitution = substitution,  ///
-              complexSubstitutionComparesToMetavariableName = complexSubstitution.compareMetavariableName(metavariableName);
+              metavariableNodeMatches = complexSubstitution.matchMetavariableNode(metavariableNode);
 
-        if (complexSubstitutionComparesToMetavariableName) {
+        if (metavariableNodeMatches) {
           return true;
         }
       }
@@ -248,13 +249,13 @@ export default class LiminalContext extends Context {
     return complexSubstitution;
   }
 
-  findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) {
+  findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
     const substitutionA = substitution; ///
 
     substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionComparesToMetavariableName = substitution.compareMetavariableName(metavariableName);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (substitutionComparesToMetavariableName) {
+      if (metavariableNodeMatches) {
         const substitutionB = substitution, ///
               substitutionBEqualToSubstitutionA = substitutionB.isEqualTo(substitutionA);
 
@@ -267,22 +268,15 @@ export default class LiminalContext extends Context {
     return substitution;
   }
 
-  isSubstitutionPresentByMetavariableName(metavariableName) {
-    const substitution = this.findSubstitutionByMetavariableName(metavariableName),
+  isSubstitutionPresentByMetavariableNode(metavariableNode) {
+    const substitution = this.findSubstitutionByMetavariableNode(metavariableNode),
           substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
   }
 
-  isSimpleSubstitutionPresentByMetavariableName(metavariableName) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
-          simpleSubstitutionPresent = (simpleSubstitution !== null);
-
-    return simpleSubstitutionPresent;
-  }
-
-  isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) {
-    substitution = this.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution);  ///
+  isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
+    substitution = this.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution);  ///
 
     const substitutionPresent = (substitution !== null);
 

package/src/context/synoptic.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import Context from "../context";
 
-const { push, last } = arrayUtilities;
+const { push, last, compress } = arrayUtilities;
 
 export default class SynopticContext extends Context {
   constructor(context, contexts) {
@@ -25,6 +25,14 @@ export default class SynopticContext extends Context {
 
       push(terms, contextTerms);
     });
+    
+    compress(terms, (termA, termB) => {
+      const termAComparesToTermB = termA.compareTerm(termB);
+      
+      if (!termAComparesToTermB) {
+        return true;
+      }
+    });
 
     return terms;
   }
@@ -38,6 +46,14 @@ export default class SynopticContext extends Context {
       push(frames, contextFrames);
     });
 
+    compress(frames, (frameA, frameB) => {
+      const frameAEqualToFrameB = frameA.isEqualTo(frameB);
+
+      if (!frameAEqualToFrameB) {
+        return true;
+      }
+    });
+
     return frames;
   }
 
@@ -50,6 +66,14 @@ export default class SynopticContext extends Context {
       push(equalities, contextEqualities);
     });
 
+    compress(equalities, (equalityA, equalityB) => {
+      const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+
+      if (!equalityAEqualToEqualityB) {
+        return true;
+      }
+    });
+
     return equalities;
   }
 
@@ -62,6 +86,14 @@ export default class SynopticContext extends Context {
       push(judgements, contextJudgements);
     });
 
+    compress(judgements, (judgementA, judgementB) => {
+      const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);
+
+      if (!judgementAEqualToJudgementB) {
+        return true;
+      }
+    });
+
     return judgements;
   }
 
@@ -74,6 +106,14 @@ export default class SynopticContext extends Context {
       push(statements, contextStatements);
     });
 
+    compress(statements, (statementA, statementB) => {
+      const statementAEqualToStatementB = statementA.isEqualTo(statementB);
+
+      if (!statementAEqualToStatementB) {
+        return true;
+      }
+    });
+
     return statements;
   }
 
@@ -86,6 +126,14 @@ export default class SynopticContext extends Context {
       push(assertions, contextAssertions);
     });
 
+    compress(assertions, (assertionA, assertionB) => {
+      const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+
+      if (!assertionAEqualToAssertionB) {
+        return true;
+      }
+    });
+
     return assertions;
   }
 
@@ -98,6 +146,14 @@ export default class SynopticContext extends Context {
       push(references, contextReferences);
     });
 
+    compress(references, (referenceA, referenceB) => {
+      const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+
+      if (!referenceAEqualToReferenceB) {
+        return true;
+      }
+    });
+
     return references;
   }
 
@@ -110,6 +166,14 @@ export default class SynopticContext extends Context {
       push(assumptions, contextAssumptions);
     });
 
+    compress(assumptions, (assumptionA, assumptionB) => {
+      const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+
+      if (!assumptionAEqualToAssumptionB) {
+        return true;
+      }
+    });
+
     return assumptions;
   }
 
@@ -122,6 +186,14 @@ export default class SynopticContext extends Context {
       push(metavariables, contextMetavariables);
     });
 
+    compress(metavariables, (metavariableA, metavariableB) => {
+      const metavariableAEqualToMetavariableB = metavariableA.isEqualTo(metavariableB);
+
+      if (!metavariableAEqualToMetavariableB) {
+        return true;
+      }
+    });
+
     return metavariables;
   }
 
@@ -134,6 +206,14 @@ export default class SynopticContext extends Context {
       push(substitutions, contextSubstitutions);
     });
 
+    compress(substitutions, (substitutionA, substitutionB) => {
+      const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+
+      if (!substitutionAEqualToSubstitutionB) {
+        return true;
+      }
+    });
+
     return substitutions;
   }
 

package/src/context.js

@@ -169,20 +169,6 @@ export default class Context extends ContextBase {
     return topLevelMetaAssertion;
   }
 
-  findTypeByTypeName(metaTypeName) {
-    const context = this.getContext(),
-          type = context.findTypeByTypeName(metaTypeName);
-
-    return type;
-  }
-
-  findMetaTypeByMetaTypeName(metaTypeName) {
-    const context = this.getContext(),
-          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
-
-    return metaType;
-  }
-
   findTermByTermNode(termNode) {
     const context = this.getContext(),
           term = context.findTermByTermNode(termNode);
@@ -197,6 +183,13 @@ export default class Context extends ContextBase {
     return frame;
   }
 
+  findVariableByVariableNode(variableNode) {
+    const context = this.getContext(),
+          variable = context.findVariableByVariableNode(variableNode);
+
+    return variable;
+  }
+
   findEqualityByEqualityNode(equalityNode) {
     const context = this.getContext(),
           equality = context.findEqualityByEqualityNode(equalityNode);
@@ -274,61 +267,61 @@ export default class Context extends ContextBase {
     return metaLevelAssumption;
   }
 
-  findTypeByNominalTypeName(nominalTypeName) {
+  findSubstitutionByVariableNode(variableNode) {
     const context = this.getContext(),
-          type = context.findTypeByNominalTypeName(nominalTypeName);
+          substitution = context.findSubstitutionByVariableNode(variableNode);
 
-    return type;
+    return substitution;
   }
 
-  findVariableByVariableNode(variableNode) {
+  findSubstitutionByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          variable = context.findVariableByVariableNode(variableNode);
+          substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
 
-    return variable;
+    return substitution;
   }
 
-  findSubstitutionByMetavariableName(metavariableName) {
+  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionByMetavariableName(metavariableName);
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableNode(metavariableNode);
 
-    return substitution;
+    return simpleSubstitution;
   }
 
-  findDeclaredMetavariableByMetavariableName(metavariableName) {
+  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
+          complexSubstitution = context.findComplexSubstitutionsByMetavariableNode(metavariableNode);
 
-    return declaredMetavariable;
+    return complexSubstitution;
   }
 
-  findSubstitutionByVariableIdentifier(variableIdentifier) {
-    const context = this.getContext(),
-          substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
+  findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
+    const context = this.getContext();
+
+    substitution = context.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution); ///
 
     return substitution;
   }
 
-  findSimpleSubstitutionByMetavariableName(metavariableName) {
+  findTypeByTypeName(metaTypeName) {
     const context = this.getContext(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+          type = context.findTypeByTypeName(metaTypeName);
 
-    return simpleSubstitution;
+    return type;
   }
 
-  findComplexSubstitutionsByMetavariableName(metavariableName) {
+  findTypeByNominalTypeName(nominalTypeName) {
     const context = this.getContext(),
-          complexSubstitution = context.findComplexSubstitutionsByMetavariableName(metavariableName);
+          type = context.findTypeByNominalTypeName(nominalTypeName);
 
-    return complexSubstitution;
+    return type;
   }
 
-  findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) {
-    const context = this.getContext();
-
-    substitution = context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution); ///
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const context = this.getContext(),
+          metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
 
-    return substitution;
+    return metaType;
   }
 
   findProcedureByProcedureName(procedureName) {
@@ -338,6 +331,20 @@ export default class Context extends ContextBase {
     return procedure;
   }
 
+  findDeclaredVariableByVariableIdentifier(variableIdentifier) {
+    const context = this.getContext(),
+          declaredVariable = context.findDeclaredVariableByVariableIdentifier(variableIdentifier);
+
+    return declaredVariable;
+  }
+
+  findDeclaredMetavariableByMetavariableName(metavariableName) {
+    const context = this.getContext(),
+          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
+
+    return declaredMetavariable;
+  }
+
   isMetavariablePresent(metavariable, context) {
     const childContext = context; ///
 
@@ -384,13 +391,6 @@ export default class Context extends ContextBase {
     return framePresent;
   }
 
-  isTypePresentByNominalTypeName(nominalTypeName) {
-    const context = this.getContext(),
-          typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-    return typePresent;
-  }
-
   isEqualityPresentByEqualityNode(equalityNode) {
     const context = this.getContext(),
           equalityPresent = context.isEqualityPresentByEqualityNode(equalityNode);
@@ -419,60 +419,67 @@ export default class Context extends ContextBase {
     return assertionPresent;
   }
 
-  isReferencePresentByMetavariableNode(metvvariableNode) {
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          referencePresent = context.isReferencePresentByMetavariableNode(metvvariableNode);
+          metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
 
-    return referencePresent;
+    return metavariablePresent;
   }
 
-  isJudgementPresentByMetavariableName(metavariableName) {
+  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
-          judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName);
+          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
 
-    return judgementPresent;
+    return substitutionPresent;
   }
 
-  isDeclaredMetavariablePresentByMetavariableName(metavariableName) {
+  isTypePresentByNominalTypeName(nominalTypeName) {
     const context = this.getContext(),
-          metavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
+          typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
-    return metavariablePresent;
+    return typePresent;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode) {
+  isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+
+    return procedurePresent;
+  }
+
+  isDeclaredMetavariablePresentByMetavariableName(metavariableName) {
+    const context = this.getContext(),
+          metavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
 
     return metavariablePresent;
   }
 
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
+  isReferencePresentByMetavariableNode(metvvariableNode) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
+      referencePresent = context.isReferencePresentByMetavariableNode(metvvariableNode);
 
-    return substitutionPresent;
+    return referencePresent;
   }
 
-  isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) {
+  isJudgementPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution);
+      judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode);
 
-    return substitutionPresent;
+    return judgementPresent;
   }
 
-  isSubstitutionPresentByMetavariableName(metavariableName) {
+  isSubstitutionPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentByMetavariableName(metavariableName);
+          substitutionPresent = context.isSubstitutionPresentByMetavariableNode(metavariableNode);
 
     return substitutionPresent;
   }
 
-  isProcedurePresentByProcedureName(procedureName) {
+  isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+      substitutionPresent = context.isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution);
 
-    return procedurePresent;
+    return substitutionPresent;
   }
 
   isMetaLevel() {
@@ -615,12 +622,24 @@ export default class Context extends ContextBase {
     context.addSubstitution(substitution);
   }
 
+  addDeclaredVariable(declaredVariable) {
+    const context = this.getContext();
+
+    context.addDeclaredVariable(declaredVariable);
+  }
+
   addMetaLevelAssumption(metaLevelAssumption) {
     const context = this.getContext();
 
     context.addMetaLevelAssumption(metaLevelAssumption);
   }
 
+  addDeclaredMetavariable(declaredMetavariable) {
+    const context = this.getContext();
+
+    context.addDeclaredMetavariable(declaredMetavariable);
+  }
+
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();