occam-verify-cli 0.0.1073 → 0.0.1075

package/src/context/local.js

@@ -10,14 +10,13 @@ import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariab
 const { last } = arrayUtilities;
 
 class LocalContext {
-  constructor(context, tokens, variables, proofSteps, judgements, equivalences, metavariables) {
+  constructor(context, tokens, variables, proofSteps, judgements, equivalences) {
     this.context = context;
     this.tokens = tokens;
     this.variables = variables;
     this.proofSteps = proofSteps;
     this.judgements = judgements;
     this.equivalences = equivalences;
-    this.metavariables = metavariables;
   }
 
   getContext() {
@@ -28,13 +27,19 @@ class LocalContext {
     return this.tokens;
   }
 
-  getVariables() {
-    let variables = this.context.getVariables();
+  getVariables(nested = true) {
+    let variables;
 
-    variables = [ ///
-      ...this.variables,
-      ...variables
-    ];
+    if (nested) {
+      variables = this.context.getVariables();
+
+      variables = [
+        ...this.variables,
+        ...variables
+      ];
+    } else {
+      variables = this.variables;
+    }
 
     return variables;
   }
@@ -65,25 +70,13 @@ class LocalContext {
     let equivalences = this.context.getEquivalences();
 
     const equivalencesA = this.equivalences, ///
-          equivalencesB = equivalences,
-          LocalContext = this;  ///
+          equivalencesB = equivalences;
 
-    equivalences = mergeEquivalences(equivalencesA, equivalencesB, LocalContext); ///
+    equivalences = mergeEquivalences(equivalencesA, equivalencesB); ///
 
     return equivalences;
   }
 
-  getMetavariables() {
-    let metavariables = this.context.getMetavariables();
-
-    metavariables = [ ///
-      ...this.metavariables,
-      ...metavariables
-    ]
-
-    return metavariables;
-  }
-
   getLastProofStep() {
     let lastProofStep = null;
 
@@ -112,7 +105,7 @@ class LocalContext {
 
   getConstructors() { return this.context.getConstructors(); }
 
-  addEquality(equality) {
+  addEquality(equality, localContext) {
     let equalityAdded;
 
     const equalityReflexive = equality.isReflexive();
@@ -130,15 +123,15 @@ class LocalContext {
       } else if ((leftEquivalence === null) && (rightEquivalence === null)) {
         const equivalence = Equivalence.fromLeftTermAndRightTerm(leftTerm, rightTerm);
 
-        this.addEquivalence(equivalence);
+        this.addEquivalence(equivalence, localContext);
 
         equalityAdded = true;
       } else if ((leftEquivalence !== null) && (rightEquivalence === null)) {
-        leftEquivalence.addTerm(rightTerm);
+        leftEquivalence.addTerm(rightTerm, localContext);
 
         equalityAdded = true;
       } else if ((leftEquivalence === null) && (rightEquivalence !== null)) {
-        rightEquivalence.addTerm(leftTerm);
+        rightEquivalence.addTerm(leftTerm, localContext);
 
         equalityAdded = true;
       } else if ((leftEquivalence !== null) && (rightEquivalence !== null)) {
@@ -156,9 +149,9 @@ class LocalContext {
           this.addEquivalence(equivalence);
         }
 
-        equivalence.addTerm(leftTerm);
+        equivalence.addTerm(leftTerm, localContext);
 
-        equivalence.addTerm(rightTerm);
+        equivalence.addTerm(rightTerm, localContext);
 
         equalityAdded = true;
       }
@@ -167,17 +160,11 @@ class LocalContext {
     return equalityAdded;
   }
 
-  addVariable(variable) {
+  addVariable(variable, nested = true) {
     let variableAdded = false;
 
-    const variableNode = variable.getNode(),
-          variablePresent = this.variables.some((variable) => {
-            const variableMatchesNode = variable.matchVariableNode(variableNode);
-
-            if (variableMatchesNode) {
-              return true;
-            }
-          });
+    const variableName = variable.getNode(),
+          variablePresent = this.isVariablePresentByVariableName(variableName, nested);
 
     if (!variablePresent) {
       this.variables.push(variable);
@@ -192,7 +179,11 @@ class LocalContext {
     this.proofSteps.push(proofStep);
   }
 
-  addEquivalence(equivalence) {
+  addEquivalence(equivalence, localContext) {
+    const equivalenceString = equivalence.asString();
+
+    localContext.trace(`Added the '${equivalenceString}' equivalence.`);
+
     this.equivalences.push(equivalence);
   }
 
@@ -208,9 +199,8 @@ class LocalContext {
     let judgementAdded = false;
 
     const metavariableNode = judgement.getMetavariableNode(),
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          metavariableDefinedByMetavariableName = this.isMetavariableDefinedByMetavariableName(metavariableName),
-          judgementPresent = metavariableDefinedByMetavariableName; ///
+          metavariableDefined = this.isMetavariableDefinedByMetavariableNode(metavariableNode),
+          judgementPresent = metavariableDefined; ///
 
     if (!judgementPresent) {
       this.judgements.push(judgement);
@@ -221,21 +211,6 @@ class LocalContext {
     return judgementAdded;
   }
 
-  addMetavariable(metavariable) {
-    let metavariableAdded = false;
-
-    const metavariableName = metavariable.getName(),
-          metavariablePresent = this.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (!metavariablePresent) {
-      this.metavariables.push(metavariable);
-
-      metavariableAdded = true;
-    }
-
-    return metavariableAdded;
-  }
-
   getTermType(term) {
     let termType;
 
@@ -299,35 +274,37 @@ class LocalContext {
 
   isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-  isMetavariablePresentByMetavariableName(metavariableName) { return this.context.isMetavariablePresentByMetavariableName(metavariableName); }
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode, localContext); }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
+  isVariablePresentByVariableName(variableName, nested = true) {
+    const variable = this.findVariableByVariableName(variableName, nested),
           variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
-  isJudgementPresentByMetavariableName(metavariableName) {
-    const judgement = this.findJudgementByMetavariableName(metavariableName),
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
           judgementPresent = (judgement !== null);
 
     return judgementPresent;
   }
 
-  isMetavariableDefinedByMetavariableName(metavariableName) {
-    const judgementPresent = this.isJudgementPresentByMetavariableName(metavariableName),
-          metavariableDefinedByMetavariableName = judgementPresent; ///
+  isMetavariableDefinedByMetavariableNode(metavariableNode) {
+    const judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode),
+          metavariableDefined = judgementPresent; ///
 
-    return metavariableDefinedByMetavariableName
+    return metavariableDefined
   }
 
   findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findVariableByVariableName(variableName) {
-    const variables = this.getVariables(),
+  findMetavariableByMetavariableNode(metavariableNode, localContext) { return this.context.findMetavariableByMetavariableNode(metavariableNode, localContext); }
+
+  findVariableByVariableName(variableName, nested = true) {
+    const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
             const nameMatches = variable.matchVariableName(variableName);
 
@@ -339,12 +316,12 @@ class LocalContext {
     return variable;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
+  findJudgementByMetavariableNode(metavariableNode) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMatchesMetavariableName = judgement.matchMetavariableName(metavariableName);
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (judgementMatchesMetavariableName) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;
@@ -352,19 +329,6 @@ class LocalContext {
     return judgement;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchMetavariableName(metavariableName);
-
-            if (nameMatches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
   findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
   findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
@@ -440,8 +404,7 @@ class LocalContext {
           proofSteps = [],
           judgements = [],
           equivalences = [],
-          metavariables = [],
-          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;
   }
@@ -452,10 +415,9 @@ class LocalContext {
           variables = [],
           proofSteps = [],
           judgements = [],
-          equivalences = [],
-          metavariables = [];
+          equivalences = [];
 
-    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);  ///
 
     return localContext;
   }
@@ -465,8 +427,7 @@ class LocalContext {
           proofSteps = [],
           judgements = [],
           equivalences = [],
-          metavariables = [],
-          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;
   }

package/src/declaration/combinator.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Combinator from "../combinator";
+import shim from "../shim";
 
 export default class CombinatorDeclaration {
   constructor(fileContext, combinator) {
@@ -25,9 +25,9 @@ export default class CombinatorDeclaration {
 
     this.fileContext.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerifiedAtTopLevel = this.combinator.verifyAtTopLevel(this.fileContext);
+    const combinatorVerifiedWhenDeclared = this.combinator.verifyWhenDeclared(this.fileContext);
 
-    if (combinatorVerifiedAtTopLevel) {
+    if (combinatorVerifiedWhenDeclared) {
       this.fileContext.addCombinator(this.combinator);
 
       verified = true;
@@ -41,7 +41,8 @@ export default class CombinatorDeclaration {
   }
 
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
-    const combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+    const { Combinator } = shim,
+          combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
           combinatorDeclaration = new CombinatorDeclaration(fileContext, combinator);
 
     return combinatorDeclaration;

package/src/declaration/constructor.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Constructor from "../constructor";
+import shim from "../shim";
 
 export default class ConstructorDeclaration {
   constructor(fileContext, constructor) {
@@ -25,9 +25,9 @@ export default class ConstructorDeclaration {
 
     this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const constructorVerifiedAtTopLevel = this.constructor.verifyAtTopLevel(this.fileContext);
+    const constructorVerifiedWhenDeclared = this.constructor.verifyWhenDeclared(this.fileContext);
 
-    if (constructorVerifiedAtTopLevel) {
+    if (constructorVerifiedWhenDeclared) {
       this.fileContext.addConstructor(this.constructor);
 
       verified = true;
@@ -41,7 +41,8 @@ export default class ConstructorDeclaration {
   }
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+    const { Constructor } = shim,
+          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
           constructorDeclaration = new ConstructorDeclaration(fileContext, constructor);
 
     return constructorDeclaration;

package/src/declaration/metavariable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import shim from "../shim";
-import Metavariable from "../metavariable";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -33,9 +32,9 @@ export default class MetavariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerifiedAtTopLevel = this.metavariable.verifyAtTopLevel(this.fileContext);
+    const metavariableVerifiedWhenDeclared = this.metavariable.verifyWhenDeclared(this.fileContext);
 
-    if (metavariableVerifiedAtTopLevel) {
+    if (metavariableVerifiedWhenDeclared) {
       this.fileContext.addMetavariable(this.metavariable);
 
       verified = true;
@@ -49,7 +48,7 @@ export default class MetavariableDeclaration {
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const { MetaType } = shim,
+    const { MetaType, Metavariable } = shim,
           metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext),
           metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),

package/src/declaration/type.js

@@ -25,9 +25,9 @@ export default class TypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
 
-    const typeVerifiedAtTopLevel = this.type.verifyAtTopLevel(this.fileContext);
+    const typeVerifiedWhenDeclared = this.type.verifyWhenDeclared(this.fileContext);
 
-    if (typeVerifiedAtTopLevel) {
+    if (typeVerifiedWhenDeclared) {
       this.fileContext.addType(this.type);
 
       verified = true;

package/src/declaration/variable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Variable from "../variable";
+import shim from "../shim";
 
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
@@ -33,9 +33,9 @@ export default class VariableDeclaration {
 
     this.fileContext.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const variableVerifiedAtTopLevel = this.variable.verifyAtTopLevel(this.fileContext);
+    const variableVerifiedWhenDeclared = this.variable.verifyWhenDeclared(this.fileContext);
 
-    if (variableVerifiedAtTopLevel) {
+    if (variableVerifiedWhenDeclared) {
       this.fileContext.addVariable(this.variable);
 
       verified = true;
@@ -49,7 +49,8 @@ export default class VariableDeclaration {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const typeNode = typeNodeQuery(variableDeclarationNode),
+    const { Variable } = shim,
+          typeNode = typeNodeQuery(variableDeclarationNode),
           variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
           string = stringFromVariableAndTypeNode(variable, typeNode),
           variableDeclaration = new VariableDeclaration(fileContext, string, variable);

package/src/declaration.js

@@ -9,7 +9,7 @@ import { stripBracketsFromStatementNode } from "./utilities/brackets";
 const referenceNodeQuery = nodeQuery("/declaration/reference"),
       statementNodeQuery = nodeQuery("/declaration/statement");
 
-export default class Declaration {
+class Declaration {
   constructor(string, reference, statement) {
     this.string = string;
     this.reference = reference;
@@ -141,3 +141,9 @@ export default class Declaration {
     return declaration;
   }
 }
+
+Object.assign(shim, {
+  Declaration
+});
+
+export default Declaration;

package/src/derivation.js

@@ -10,7 +10,7 @@ const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default class Derivation {
+class Derivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -52,3 +52,9 @@ export default class Derivation {
     return derivation;
   }
 }
+
+Object.assign(shim, {
+  Derivation
+});
+
+export default Derivation;

package/src/equality.js

@@ -3,13 +3,15 @@
 import shim from "./shim";
 import equalityUnifier from "./unifier/equality";
 import EqualityAssignment from "./assignment/equality";
+import VariableAssignment from "./assignment/variable";
 
 import { nodeQuery } from "./utilities/query";
 
-const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
       rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
-export default class Equality {
+class Equality {
   constructor(string,leftTerm, rightTerm) {
     this.string = string;
     this.leftTerm = leftTerm;
@@ -28,6 +30,25 @@ export default class Equality {
     return this.rightTerm;
   }
 
+  getType() {
+    let type;
+
+    const leftTermType = this.leftTerm.getType(),
+          rightTermType = this.rightTerm.getType(),
+          leftTermTypeEqualToOrSubTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOf(rightTermType),
+          rightTermTypeEqualToOrSubTypeOfLeftTermType = rightTermType.isEqualToOrSubTypeOf(leftTermType);
+
+    if (leftTermTypeEqualToOrSubTypeOfRightTermType) {
+      type = leftTermType;  ///
+    }
+
+    if (rightTermTypeEqualToOrSubTypeOfLeftTermType) {
+      type = rightTermType; ///
+    }
+
+    return type;
+  }
+
   isReflexive() {
     const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
           reflexive = leftTermMatchesRightTerm; ///
@@ -51,25 +72,57 @@ export default class Equality {
 
     localContext.trace(`Verifying the '${equalityString}' equality...`);
 
-    let verifiedWhenStated = false,
-        verifiedWhenDerived = false;
-
-    if (stated) {
-      verifiedWhenStated = this.verifyWhenStated(localContext);
-    } else {
-      verifiedWhenDerived = this.verifyWhenDerived(localContext);
-    }
+    const termsVerified = this.verifyTerms(localContext);
 
-    if (verifiedWhenStated || verifiedWhenDerived) {
-      if (assignments !== null) {
-        const equality = this,  //
-              equalityAssignment = EqualityAssignment.fromEquality(equality),
-              assignment = equalityAssignment; ///
+    if (termsVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
 
-        assignments.push(assignment);
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(localContext);
       }
 
-      verified = true;
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        if (assignments !== null) {
+          const { Variable } = shim,
+                type = this.getType(),
+                leftTermNode = this.leftTerm.getNode(),
+                rightTermNode = this.rightTerm.getNode(),
+                leftVariableNode = variableNodeQuery(leftTermNode),
+                rightVariableNode = variableNodeQuery(rightTermNode),
+                leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, localContext),
+                rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, localContext);
+
+          let assignment;
+
+          if (leftVariable !== null) {
+            const leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
+
+            assignment = leftVariableAssignment;  ///
+
+            assignments.push(assignment);
+          }
+
+          if (rightVariable !== null) {
+            const rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
+
+            assignment = rightVariableAssignment;  ///
+
+            assignments.push(assignment);
+          }
+
+          const equality = this,  //
+                equalityAssignment = EqualityAssignment.fromEquality(equality);
+
+          assignment = equalityAssignment; ///
+
+          assignments.push(assignment);
+        }
+
+        verified = true;
+      }
     }
 
     if (verified) {
@@ -122,9 +175,7 @@ export default class Equality {
 
     localContext.trace(`Verifying the '${equalityString}' stated equality...`);
 
-    const termsVerified = this.verifyTerms(localContext);
-
-    verifiedWhenStated = termsVerified; ///
+    verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
       localContext.debug(`...verified the '${equalityString}' stated equality.`);
@@ -134,19 +185,15 @@ export default class Equality {
   }
 
   verifyWhenDerived(localContext) {
-    let verifiedWhenDerived = false;
+    let verifiedWhenDerived;
 
     const equalityString = this.string; ///
 
     localContext.trace(`Verifying the '${equalityString}' derived equality...`);
 
-    const termsVerified = this.verifyTerms(localContext);
-
-    if (termsVerified) {
-      const equal = this.isEqual(localContext);
+    const equal = this.isEqual(localContext);
 
-      verifiedWhenDerived = equal;  ///
-    }
+    verifiedWhenDerived = equal;  ///
 
     if (verifiedWhenDerived) {
       localContext.debug(`...verified the '${equalityString}' derived equality.`);
@@ -173,3 +220,9 @@ export default class Equality {
     return equality;
   }
 }
+
+Object.assign(shim, {
+  Equality
+});
+
+export default Equality;