occam-verify-cli 0.0.549 → 0.0.550

package/lib/verify/typeInference.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyTypeInference;
+    }
+});
+var _term = /*#__PURE__*/ _interopRequireWildcard(require("./term"));
+var _equality = /*#__PURE__*/ _interopRequireDefault(require("../ocmbinator/equality"));
+var _query = require("../utilities/query");
+var _array = require("../utilities/array");
+var _type = require("./assertion/type");
+var _statement = require("../verify/statement");
+var _proof = require("../utilities/proof");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var leftTermNodeQuery = (0, _query.nodeQuery)("/statement/argument[0]/term!"), rightTermNodeQuery = (0, _query.nodeQuery)("/statement/argument[1]/term!"), statementNodeQuery = (0, _query.nodeQuery)("/typeInference/statement!"), typeAssertionNodeQuery = (0, _query.nodeQuery)("/typeInference/typeAssertion!");
+function verifyTypeInference(typeInferenceNode, context) {
+    var typeInferenceVerified = false;
+    var typeInferenceString = context.nodeAsString(typeInferenceNode);
+    context.debug("Verifying the '".concat(typeInferenceString, "' type inference..."), typeInferenceNode);
+    var statementNode = statementNodeQuery(typeInferenceNode);
+    var bracketedStatementChildNode = (0, _proof.bracketedStatementChildNodeFromStatementNode)(statementNode);
+    if (bracketedStatementChildNode !== null) {
+        statementNode = bracketedStatementChildNode; ///
+    }
+    var statementString = context.nodeAsString(statementNode), statementMatches = context.matchStatement(statementNode);
+    if (!statementMatches) {
+        context.error("The '".concat(statementString, "' statement is not present in the context."), typeInferenceNode);
+    } else {
+        var combinator = _equality.default, statementVerifiedAgainstCombinator = (0, _statement.verifyStatementAgainstCombinator)(statementNode, combinator, context);
+        if (!statementVerifiedAgainstCombinator) {
+            context.error("The '".concat(statementString, "' statement is not an equality."), typeInferenceNode);
+        } else {
+            var derived = false, assignments = [], typeAssertionNode = typeAssertionNodeQuery(typeInferenceNode), variableTypeAssertionVerified = (0, _type.verifyVariableTypeAssertion)(typeAssertionNode, assignments, derived, context);
+            if (variableTypeAssertionVerified) {
+                var firstAssignment = (0, _array.first)(assignments), assignment = firstAssignment, variables = [], leftTermNode = leftTermNodeQuery(statementNode), rightTermNode = rightTermNodeQuery(statementNode), leftTermVerifiedAsVariable = (0, _term.verifyTermAsVariable)(leftTermNode, variables, context), rightTermVerifiedAsVariable = (0, _term.verifyTermAsVariable)(rightTermNode, variables, context);
+                if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
+                    var firstVariable = (0, _array.first)(variables), secondVariable = (0, _array.second)(variables), leftVariable = firstVariable, rightVariable = secondVariable, leftVariableName = leftVariable.getName(), leftVariableType = leftVariable.getType(), rightVariableName = rightVariable.getName(), rightVariableType = rightVariable.getType(), leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
+                    if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
+                        var leftVariableTypeSuperTypeOfRightVariableType = leftVariableType.isSuperTypeOf(rightVariableType), rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
+                        if (leftVariableTypeSuperTypeOfRightVariableType) {
+                            var name = leftVariableName, type = rightVariableType; ///
+                            assignAssignment(name, type, assignment, context);
+                        }
+                        if (rightVariableTypeSuperTypeOfLeftVariableType) {
+                            var name1 = rightVariableName, type1 = leftVariableType; ///
+                            assignAssignment(name1, type1, assignment, context);
+                        }
+                    }
+                } else if (leftTermVerifiedAsVariable) {
+                    var types = [];
+                    (0, _term.default)(rightTermNode, types, context);
+                    var firstType = (0, _array.first)(types), firstVariable1 = (0, _array.first)(variables), leftVariable1 = firstVariable1, rightTermType = firstType, leftVariableName1 = leftVariable1.getName(), leftVariableType1 = leftVariable1.getType(), leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType1.isEqualToOrSuperTypeOf(rightTermType);
+                    if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
+                        var name2 = leftVariableName1, type2 = rightTermType; ///
+                        assignAssignment(name2, type2, assignment, context);
+                    }
+                } else if (rightTermVerifiedAsVariable) {
+                    var types1 = [];
+                    (0, _term.default)(leftTermNode, types1, context);
+                    var firstType1 = (0, _array.first)(types1), firstVariable2 = (0, _array.first)(variables), leftTermType = firstType1, rightVariable1 = firstVariable2, rightVariableName1 = rightVariable1.getName(), rightVariableType1 = rightVariable1.getType(), rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType1.isEqualToOrSuperTypeOf(leftTermType);
+                    if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
+                        var name3 = rightVariableName1, type3 = leftTermType; ///
+                        assignAssignment(name3, type3, assignment, context);
+                    }
+                }
+                typeInferenceVerified = true;
+            }
+        }
+    }
+    if (typeInferenceVerified) {
+        context.info("Verified the '".concat(typeInferenceString, "' type inference."), typeInferenceNode);
+    }
+    return typeInferenceVerified;
+}
+function assignAssignment(name, type, assignment, context) {
+    var assignmentMatchesNameAndType = assignment.matchNameAndType(name, type);
+    if (assignmentMatchesNameAndType) {
+        assignment.assign(context);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/typeInference.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"./term\";\nimport equalityCombinator from \"../ocmbinator/equality\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { first, second } from \"../utilities/array\";\nimport { verifyTermAsVariable } from \"./term\";\nimport { verifyVariableTypeAssertion } from \"./assertion/type\";\nimport { verifyStatementAgainstCombinator } from \"../verify/statement\";\nimport { bracketedStatementChildNodeFromStatementNode } from \"../utilities/proof\";\n\nconst leftTermNodeQuery = nodeQuery(\"/statement/argument[0]/term!\"),\n      rightTermNodeQuery = nodeQuery(\"/statement/argument[1]/term!\"),\n      statementNodeQuery = nodeQuery(\"/typeInference/statement!\"),\n      typeAssertionNodeQuery = nodeQuery(\"/typeInference/typeAssertion!\");\n\nexport default function verifyTypeInference(typeInferenceNode, context) {\n  let typeInferenceVerified = false;\n\n  const typeInferenceString = context.nodeAsString(typeInferenceNode);\n\n  context.debug(`Verifying the '${typeInferenceString}' type inference...`, typeInferenceNode);\n\n  let statementNode = statementNodeQuery(typeInferenceNode);\n\n  const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);\n\n  if (bracketedStatementChildNode !== null) {\n    statementNode = bracketedStatementChildNode; ///\n  }\n\n  const statementString = context.nodeAsString(statementNode),\n        statementMatches = context.matchStatement(statementNode);\n\n  if (!statementMatches) {\n    context.error(`The '${statementString}' statement is not present in the context.`, typeInferenceNode);\n  } else {\n    const combinator = equalityCombinator,  ///\n          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);\n\n    if (!statementVerifiedAgainstCombinator) {\n      context.error(`The '${statementString}' statement is not an equality.`, typeInferenceNode);\n    } else {\n      const derived = false,  ///\n            assignments = [],\n            typeAssertionNode = typeAssertionNodeQuery(typeInferenceNode),\n            variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context)\n\n      if (variableTypeAssertionVerified) {\n        const firstAssignment = first(assignments),\n              assignment = firstAssignment, ///\n              variables = [],\n              leftTermNode = leftTermNodeQuery(statementNode),\n              rightTermNode = rightTermNodeQuery(statementNode),\n              leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),\n              rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);\n\n        if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {\n          const firstVariable = first(variables),\n                secondVariable = second(variables),\n                leftVariable = firstVariable, ///\n                rightVariable = secondVariable, ///\n                leftVariableName = leftVariable.getName(),\n                leftVariableType = leftVariable.getType(),\n                rightVariableName = rightVariable.getName(),\n                rightVariableType = rightVariable.getType(),\n                leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);\n\n          if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {\n            const leftVariableTypeSuperTypeOfRightVariableType = leftVariableType.isSuperTypeOf(rightVariableType),\n                  rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);\n\n            if (leftVariableTypeSuperTypeOfRightVariableType) {\n              const name = leftVariableName, ///\n                    type = rightVariableType;  ///\n\n              assignAssignment(name, type, assignment, context);\n            }\n\n            if (rightVariableTypeSuperTypeOfLeftVariableType) {\n              const name = rightVariableName, ///\n                    type = leftVariableType;  ///\n\n              assignAssignment(name, type, assignment, context);\n            }\n          }\n        } else if (leftTermVerifiedAsVariable) {\n          const types = [];\n\n          verifyTerm(rightTermNode, types, context);\n\n          const firstType = first(types),\n                firstVariable = first(variables),\n                leftVariable = firstVariable, ///\n                rightTermType = firstType,  ///\n                leftVariableName = leftVariable.getName(),\n                leftVariableType = leftVariable.getType(),\n                leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);\n\n          if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {\n            const name = leftVariableName,  ///\n                  type = rightTermType; ///\n\n            assignAssignment(name, type, assignment, context);\n          }\n        } else if (rightTermVerifiedAsVariable) {\n          const types = [];\n\n          verifyTerm(leftTermNode, types, context);\n\n          const firstType = first(types),\n                firstVariable = first(variables),\n                leftTermType = firstType,  ///\n                rightVariable = firstVariable, ///\n                rightVariableName = rightVariable.getName(),\n                rightVariableType = rightVariable.getType(),\n                rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);\n\n          if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {\n            const name = rightVariableName,  ///\n                  type = leftTermType; ///\n\n            assignAssignment(name, type, assignment, context);\n          }\n        }\n\n        typeInferenceVerified = true;\n      }\n    }\n  }\n\n  if (typeInferenceVerified) {\n    context.info(`Verified the '${typeInferenceString}' type inference.`, typeInferenceNode);\n  }\n\n  return typeInferenceVerified;\n}\n\nfunction assignAssignment(name, type, assignment, context) {\n  const assignmentMatchesNameAndType = assignment.matchNameAndType(name, type);\n\n  if (assignmentMatchesNameAndType) {\n    assignment.assign(context);\n  }\n}\n"],"names":["verifyTypeInference","leftTermNodeQuery","nodeQuery","rightTermNodeQuery","statementNodeQuery","typeAssertionNodeQuery","typeInferenceNode","context","typeInferenceVerified","typeInferenceString","nodeAsString","debug","statementNode","bracketedStatementChildNode","bracketedStatementChildNodeFromStatementNode","statementString","statementMatches","matchStatement","error","combinator","equalityCombinator","statementVerifiedAgainstCombinator","verifyStatementAgainstCombinator","derived","assignments","typeAssertionNode","variableTypeAssertionVerified","verifyVariableTypeAssertion","firstAssignment","first","assignment","variables","leftTermNode","rightTermNode","leftTermVerifiedAsVariable","verifyTermAsVariable","rightTermVerifiedAsVariable","firstVariable","secondVariable","second","leftVariable","rightVariable","leftVariableName","getName","leftVariableType","getType","rightVariableName","rightVariableType","leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType","isEqualToOrSubTypeOfOfSuperTypeOf","leftVariableTypeSuperTypeOfRightVariableType","isSuperTypeOf","rightVariableTypeSuperTypeOfLeftVariableType","name","type","assignAssignment","types","verifyTerm","firstType","rightTermType","leftVariableTypeEqualToOrSuperTypeOfRightTermType","isEqualToOrSuperTypeOf","leftTermType","rightVariableTypeEqualToOrSuperTypeOfRightTermType","info","assignmentMatchesNameAndType","matchNameAndType","assign"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.549",
+  "version": "0.0.550",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/assignment.js

@@ -13,6 +13,21 @@ export default class Assignment {
     proofContext.addVariable(this.variable);
   }
 
+  match(assignment) {
+    const variable = assignment.getVariable(),
+          variableMatches = variable.match(this.variable),
+          matches = variableMatches;  ///
+
+    return matches;
+  }
+
+  matchNameAndType(name, type) {
+    const variableMatchesNameAndType = this.variable.matchNameAndType(name, type),
+          nameAndTypeMatch = variableMatchesNameAndType; ///
+
+    return nameAndTypeMatch;
+  }
+
   static fromVariable(variable) {
     const assignment = new Assignment(variable);
 

package/src/axiomLemmaTheoremConjecture.js

@@ -33,7 +33,7 @@ export default class AxiomLemmaTheoremConjecture {
   }
 
   matchLabelName(labelName) {
-    const matchesLabelName = this.labels.some((label) => {
+    const labelNameMatches = this.labels.some((label) => {
       const name = labelName, ///
             labelMatchesName = label.matchName(name);
 
@@ -42,7 +42,7 @@ export default class AxiomLemmaTheoremConjecture {
       }
     });
 
-    return matchesLabelName;
+    return labelNameMatches;
   }
 
   matchStatement(statementNode, statementProofContext) {

package/src/metaType.js

@@ -25,15 +25,15 @@ export default class MetaType {
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
 
-    return matchesName;
+    return nameMatches;
   }
 
   matchMetaTypeName(metaTypeName) {
-    const matchesMetaTypeName = (this.name === metaTypeName);
+    const metaTypeNameMatches = (this.name === metaTypeName);
 
-    return matchesMetaTypeName;
+    return metaTypeNameMatches;
   }
 
   asString(tokens) {

package/src/metavariable.js

@@ -17,9 +17,9 @@ export default class Metavariable {
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
 
-    return matchesName;
+    return nameMatches;
   }
 
   toJSON(tokens) {

package/src/rule.js

@@ -32,7 +32,7 @@ export default class Rule {
   }
 
   matchLabelName(labelName) {
-    const matchesLabelName = this.labels.some((label) => {
+    const labelNameMatches = this.labels.some((label) => {
       const name = labelName, ///
             labelMatchesName = label.matchName(name);
 
@@ -41,7 +41,7 @@ export default class Rule {
       }
     });
 
-    return matchesLabelName;
+    return labelNameMatches;
   }
 
   matchStatement(statementNode, statementProofContext) {

package/src/step/metaproof.js

@@ -29,37 +29,37 @@ export default class MetaproofStep {
       const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
 
       if (ruleSubproofAssertionNode !== null) {
-        const matchesRuleSubproofAssertion = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
+        const ruleSubproofAssertionMatches = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
 
-        matches = matchesRuleSubproofAssertion;  ///
+        matches = ruleSubproofAssertionMatches;  ///
       }
     }
 
     if (!matches) {
-      const matchesMetastatement = this.matchMetastatement(metastatementNode);
+      const metastatementMatches = this.matchMetastatement(metastatementNode);
 
-      matches = matchesMetastatement; ///
+      matches = metastatementMatches; ///
     }
 
     return matches;
   }
 
   matchMetastatement(metastatementNode) {
-    let matchesMetastatement = false;
+    let metastatementMatches = false;
 
     if (this.metastatementNode !== null) {
       const metastatementNodeA = metastatementNode, ///
             metastatementNodeB = this.metastatementNode,  ///
             metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-      matchesMetastatement = metastatementMatchesModuloBrackets;  ///
+      metastatementMatches = metastatementMatchesModuloBrackets;  ///
     }
 
-    return matchesMetastatement;
+    return metastatementMatches;
   }
 
   matchRuleSubproofAssertion(ruleSubproofAssertionNode) {
-    let matchesRuleSubproofAssertion = false;
+    let ruleSubproofAssertionMatches = false;
 
     if (this.ruleSubproofNode !== null) {
       const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
@@ -79,11 +79,11 @@ export default class MetaproofStep {
               metastatementNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
               metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-        matchesRuleSubproofAssertion = metastatementMatchesModuloBrackets; ///
+        ruleSubproofAssertionMatches = metastatementMatchesModuloBrackets; ///
       }
     }
 
-    return matchesRuleSubproofAssertion;
+    return ruleSubproofAssertionMatches;
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {

package/src/step/proof.js

@@ -20,15 +20,15 @@ export default class ProofStep {
   match(statementNode) {
     let matches;
 
-    const matchesStatement = this.matchStatement(statementNode);
+    const statementMatches = this.matchStatement(statementNode);
 
-    matches = matchesStatement; //
+    matches = statementMatches; //
 
     return matches;
   }
 
   matchStatement(statementNode) {
-    let matchesStatement = false;
+    let statementMatches = false;
 
     if (this.statementNode !== null) {
       const ruleName = META_ARGUMENT_RULE_NAME,
@@ -36,10 +36,10 @@ export default class ProofStep {
             statementNodeB = this.statementNode,  ///
             statementMatchesModuloBrackets = matchStatementModuloBrackets(statementNodeA, statementNodeB, ruleName);
 
-      matchesStatement = statementMatchesModuloBrackets;  ///
+      statementMatches = statementMatchesModuloBrackets;  ///
     }
 
-    return matchesStatement;
+    return statementMatches;
   }
 
   static fromSubproofNode(subproofNode) {

package/src/substitution/metastatementForMetavariable.js

@@ -19,15 +19,15 @@ export default class MetastatementForMetavariableSubstitution {
   }
 
   matchMetastatementNode(metastatementNode) {
-    let matchesMetastatementNode;
+    let metastatementNodeMatches;
 
     const nodeA = this.metastatementNode,  ///
           nodeB = metastatementNode,
           nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-    matchesMetastatementNode = nodeMatches;  ///
+    metastatementNodeMatches = nodeMatches;  ///
 
-    if (!matchesMetastatementNode) {
+    if (!metastatementNodeMatches) {
       const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
       if (bracketedMetastatementChildNode !== null) {
@@ -36,11 +36,11 @@ export default class MetastatementForMetavariableSubstitution {
               nodeB = metastatementNode,
               nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-        matchesMetastatementNode = nodeMatches;  ///
+        metastatementNodeMatches = nodeMatches;  ///
       }
     }
 
-    return matchesMetastatementNode;
+    return metastatementNodeMatches;
   }
 
   static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {

package/src/substitution/statementForMetavariable.js

@@ -19,15 +19,15 @@ export default class StatementForMetavariableSubstitution {
   }
 
   matchStatementNode(statementNode) {
-    let matchesStatementNode;
+    let statementNodeMatches;
 
     const nodeA = this.statementNode,  ///
           nodeB = statementNode,
           nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-    matchesStatementNode = nodeMatches;  ///
+    statementNodeMatches = nodeMatches;  ///
 
-    if (!matchesStatementNode) {
+    if (!statementNodeMatches) {
       const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
       if (bracketedStatementChildNode !== null) {
@@ -36,11 +36,11 @@ export default class StatementForMetavariableSubstitution {
               nodeB = statementNode,
               nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-        matchesStatementNode = nodeMatches;  ///
+        statementNodeMatches = nodeMatches;  ///
       }
     }
 
-    return matchesStatementNode;
+    return statementNodeMatches;
   }
 
   static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {

package/src/substitution/termForVariable.js

@@ -17,15 +17,15 @@ export default class TermForVariableSubstitution {
   }
 
   matchTermNode(termNode) {
-    let matchesTermNode;
+    let termNodeMatches;
 
     const nodeA = this.termNode,  ///
           nodeB = termNode,
           nodeMatches = matcher.matchNode(nodeA, nodeB);
 
-    matchesTermNode = nodeMatches;  ///
+    termNodeMatches = nodeMatches;  ///
 
-    return matchesTermNode;
+    return termNodeMatches;
   }
 
   static fromVariableNameAndTermNode(variableName, termNode) {

package/src/type.js

@@ -84,24 +84,21 @@ export default class Type {
   }
 
   match(type) {
-    const equalToType = this.isEqualTo(type),
-          subTypeOfType = this.isSubTypeOf(type),
-          superTypeOfType = this.isSuperTypeOf(type),
-          matches = (equalToType || subTypeOfType || superTypeOfType);
+    const matches = (type === this);  ///
 
     return matches;
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
 
-    return matchesName;
+    return nameMatches;
   }
 
   matchTypeName(typeName) {
-    const matchesTypeName = (this.name === typeName);
+    const typeNameMatches = (this.name === typeName);
 
-    return matchesTypeName;
+    return typeNameMatches;
   }
 
   asString(tokens, noSuperType) {

package/src/variable.js

@@ -16,10 +16,34 @@ export default class Variable {
     return this.type;
   }
 
+  match(variable) {
+    const name = variable.getName(),
+          type = variable.getType(),
+          nameMatches = this.matchName(name),
+          typeMatches = this.matchType(type),
+          matches = (nameMatches && typeMatches);
+
+    return matches;
+  }
+
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
+
+    return nameMatches;
+  }
+
+  matchType(type) {
+    const typeMatches = this.type.match(type);
+
+    return typeMatches;
+  }
+
+  matchNameAndType(name, type) {
+    const nameMatches = this.matchName(name),
+          typeMatches = this.matchType(type),
+          nameAndTypeMatch = (nameMatches && typeMatches);
 
-    return matchesName;
+    return nameAndTypeMatch;
   }
 
   asString(tokens) {

package/src/verify/assertion/type.js

@@ -7,8 +7,8 @@ import { first } from "../../utilities/array";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
-const termNodeQuery = nodeQuery("/typeAssertion/term"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type");
+const termNodeQuery = nodeQuery("/typeAssertion/term!"),
+      typeNodeQuery = nodeQuery("/typeAssertion/type!");
 
 export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let typeAssertionVerified = false;
@@ -44,7 +44,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {
+export function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let variableTypeAssertionVerified = false;
 
   const variables = [],

package/src/verify/proof.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import matcher from "../matcher";
+import ProofContext from "../context/proof";
 import verifyDerivation from "../verify/derivation";
 
 import { nodeQuery } from "../utilities/query";
@@ -10,6 +11,8 @@ const derivationNodeQuery = nodeQuery("/proof/derivation!");
 export default function verifyProof(proofNode, conclusion, proofContext) {
   let proofVerified = false;
 
+  proofContext = ProofContext.fromProofContext(proofContext); ///
+
   const derivationNode = derivationNodeQuery(proofNode),
         derivationVerified = verifyDerivation(derivationNode, proofContext);
 

package/src/verify/ruleProof.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import matcher from "../matcher";
+import MetaproofContext from "../context/metaproof";
 import verifyRuleDerivation from "../verify/ruleDerivation";
 
 import { nodeQuery } from "../utilities/query";
@@ -10,6 +11,8 @@ const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 export default function verifyRuleProof(ruleProofNode, conclusion, assignments, metaproofContext) {
   let ruleProofVerified = false;
 
+  metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
+
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
         ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, metaproofContext);