occam-verify-cli 0.0.531 → 0.0.533

package/src/equality.js

@@ -1,15 +1,12 @@
 "use strict";
 
-import matcher from "./matcher";
+import Variable from "./variable";
 import verifyTerm from "./verify/term";
-import equalityCombinator from "./ocmbinator/equality";
-import equalityStatementNode from "./node/statement/equality";
 
 import { nodeQuery } from "./utilities/query";
 import { first, second } from "./utilities/array";
-import { EQUALITY_DEPTH } from "./constants";
 import { TERM_RULE_NAME } from "./ruleNames";
-import { verifyStatementAgainstCombinator } from "./verify/statement";
+import { verifyTermAsVariable } from "./verify/term";
 
 const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
@@ -88,40 +85,10 @@ export default class Equality {
     return equates;
   }
 
-  static fromProofStep(proofStep) {
-    let equality = null;
-
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const nodeA = statementNode,  ///
-            nodeB = equalityStatementNode,  ///
-            depth = EQUALITY_DEPTH,
-            nodeMatches = matcher.matchNode(nodeA, nodeB, depth);
-
-      if (nodeMatches) {
-        const leftTermNode = leftTermNodeQuery(statementNode),
-              rightTermNode = rightTermNodeQuery(statementNode);
-
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
-    }
-
-    return equality;
-  }
-
   static fromStatementNode(statementNode, context) {
-    let equality = null;
-
-    const combinator = equalityCombinator,  ///
-          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
-
-    if (statementVerifiedAgainstCombinator) {
-      const leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode);
-
-      equality = new Equality(leftTermNode, rightTermNode);
-    }
+    const leftTermNode = leftTermNodeQuery(statementNode),
+          rightTermNode = rightTermNodeQuery(statementNode),
+          equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
 
     return equality;
   }
@@ -264,12 +231,41 @@ function equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, c
     if (leftTermTypeEqualToRightTermType) {
       equality = new Equality(leftTermNode, rightTermNode);
     } else {
+      const leftTermTypeSubTypeOfRightTermType = leftTermType.isSubTypeOf(rightTermType);
+
+      if (false) {
+          ///
+      } else if (leftTermTypeSubTypeOfRightTermType) {
+        const variables = [],
+              rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+        if (rightTermVerifiedAsVariable) {
+          let rightVariable;
+
+          const firstVariable = first(variables);
+
+          rightVariable = firstVariable;  ///
+
+          const rightVariableName = rightVariable.getName(),
+                rightName = rightVariableName,  ///
+                rightType = leftTermType; ///
+
+          rightVariable = Variable.fromTypeAndName(rightType, rightName);
+
+          context.addVariable(rightVariable);
+
+          equality = new Equality(leftTermNode, rightTermNode);
+        }
+      }
+    }
+
+    if (equality === null) {
       const leftTermString = context.nodeAsString(leftTermNode),
             rightTermString = context.nodeAsString(rightTermNode),
             leftTermTypeName = leftTermType.getName(),
             rightTermTypeName = rightTermType.getName();
 
-      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type.'`, leftTermNode);
+      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type and neither can be inferred.'`, leftTermNode);
     }
   }
 

package/src/label.js

@@ -34,8 +34,10 @@ export default class Label {
     return json;
   }
 
-  static fromJSON(json, lexer, parser) {
+  static fromJSON(json, context) {
     const labelString = json, ///
+          lexer  = context.getLexer(),
+          parser = context.getParser(),
           labelNode = labelNodeFromLabelString(labelString, lexer, parser),
           node = labelNode, ///
           label = new Label(node);

package/src/lemma.js

@@ -7,7 +7,7 @@ import { LEMMA_KIND } from "./kinds";
 export default class Lemma extends AxiomLemmaTheoremConjecture {
   static kind = LEMMA_KIND;
 
-  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, lexer, parser); }
+  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, context); }
 
   static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
 }

package/src/premise.js

@@ -116,9 +116,11 @@ export default class Premise {
     return json;
   }
 
-  static fromJSON(json, lexer, parser) {
+  static fromJSON(json, context) {
     const { metastatement } = json,
           metastatementString = metastatement,  ///
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           premise = new Premise(metastatementNode);
 

package/src/rule.js

@@ -134,7 +134,7 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, lexer, parser) {
+  static fromJSON(json, context) {
     let rule;
 
     let { labels } = json;
@@ -143,7 +143,7 @@ export default class Rule {
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, lexer, parser);
+            label = Label.fromJSON(json, context);
 
       return label;
     });
@@ -154,7 +154,7 @@ export default class Rule {
 
     premises = premisesJSON.map((premiseJSON) => {
       const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, lexer, parser);
+            premise = Premise.fromJSON(json, context);
 
       return premise;
     });
@@ -165,7 +165,7 @@ export default class Rule {
 
     json = conclusionJSON;  ///
 
-    conclusion = Conclusion.fromJSON(json, lexer, parser);
+    conclusion = Conclusion.fromJSON(json, context);
 
     rule = new Rule(labels, premises, conclusion);
 

package/src/supposition.js

@@ -71,9 +71,11 @@ export default class Supposition {
     return json;
   }
 
-  static fromJSON(json, lexer, parser) {
+  static fromJSON(json, context) {
     const { statement } = json,
           statementString = statement,  ///
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           supposition = new Supposition(statementNode);
 

package/src/theorem.js

@@ -7,7 +7,7 @@ import { THEOREM_KIND } from "./kinds";
 export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, lexer, parser); }
+  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
 
   static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }

package/src/type.js

@@ -124,14 +124,14 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json, lexer, parser) {
+  static fromJSON(json, context) {
     let type;
 
     let { superType } = json;
 
     const superTypeJSON = superType;  ///
 
-    superType = superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser);
+    superType = superTypeFromSuperTypeJSON(superTypeJSON, context);
 
     const { name } = json;
 
@@ -181,7 +181,7 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser) {
+function superTypeFromSuperTypeJSON(superTypeJSON, context) {
   let superType;
 
   const json = superTypeJSON, ///
@@ -191,11 +191,11 @@ function superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser) {
     superType = objectType; ///
   } else {
     const typeName = name,  ///
-          type = releaseContext.findTypeByTypeName(typeName);
+          type = context.findTypeByTypeName(typeName);
 
     superType = (type !== null) ?
                   type :  ///
-                    Type.fromJSON(json, lexer, parser);  ///
+                    Type.fromJSON(json, context);  ///
   }
 
   return superType;

package/src/utilities/node.js

@@ -65,9 +65,10 @@ function nodeFromContentAndRuleName(content, ruleName, lexer = florenceLexer, pa
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],
         tokens = lexer.tokenise(content),
-        node = parser.parse(tokens, rule);
+        node = parser.parse(tokens, rule),
+        nonTerminalNode = node; ///
 
-  rewriteNodes(node);
+  rewriteNodes(nonTerminalNode);
 
   return node;
 }

package/src/variable.js

@@ -1,9 +1,10 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name) {
+  constructor(type, name, termNode) {
     this.type = type;
     this.name = name;
+    this.termNode = termNode;
   }
 
   getType() {
@@ -14,6 +15,14 @@ export default class Variable {
     return this.name;
   }
 
+  getTermNode() {
+    return this.termNode;
+  }
+
+  isUndefined() {
+    return (this.termNode === null);
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 
@@ -28,7 +37,14 @@ export default class Variable {
   }
 
   static fromTypeAndName(type, name) {
-    const variable = new Variable(type, name);
+    const termNode = null,
+          variable = new Variable(type, name, termNode);
+
+    return variable;
+  }
+
+  static fromTypeNameAndTermNode(type, name, termNode) {
+    const variable = new Variable(type, name, termNode);
 
     return variable;
   }

package/src/verify/assertion/type.js

@@ -1,54 +1,53 @@
 "use strict";
 
 import Variable from "../../variable";
-import TypeAssertion from "../../assertion/type";
+import Assertion from "../../assertion";
 
 import { first } from "../../utilities/array";
-import { verifyTermAsVariable } from "../../verify/term";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, context) {
   let typeAssertionVerified = false;
 
-  const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
+  context.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
-        typePresent = proofContext.isTypePresentByTypeName(typeName);
+        typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
-    // if (!typeAssertionVerified) {
-    //   const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
-    //
-    //   typeAssertionVerified = termTypeAssertionVerified;  ///
-    // }
+    if (!typeAssertionVerified) {
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, context);
+
+      typeAssertionVerified = termTypeAssertionVerified;  ///
+    }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+    context.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context) {
   let variableTypeAssertionVerified = false;
 
-  const context = proofContext, ///
-        variables = [],
+  const variables = [],
         termNode = termNodeQuery(typeAssertionNode),
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
@@ -56,41 +55,45 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
     const typeNode = typeNodeQuery(typeAssertionNode),
           typeName = typeNameFromTypeNode(typeNode),
           assertedTypeName = typeName,  ///
-          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-          firstVariable = first(variables),
-          variable = firstVariable, ///
-          variableName = variable.getName(),
-          variableType = variable.getType();
-
-    if (derived) {
-      const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+          assertedType = context.findTypeByTypeName(assertedTypeName);
 
-      if (!variableTypeEqualToOrSubTypeOfAssertedType) {
-        const assertedTypeName = assertedType.getName(),
-              variableTypeName = variableType.getName();
-
-        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
-      } else {
-        variableTypeAssertionVerified = true;
-      }
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
-      const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+      const firstVariable = first(variables),
+            variable = firstVariable, ///
+            variableName = variable.getName(),
+            variableType = variable.getType();
+
+      if (derived) {
+        const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+
+        if (!variableTypeEqualToOrSubTypeOfAssertedType) {
+          const assertedTypeName = assertedType.getName(),
+                variableTypeName = variableType.getName();
+
+          context.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
+        } else {
+          variableTypeAssertionVerified = true;
+        }
+      } else {
+        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
-      if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-        const assertedTypeName = assertedType.getName(),
-              variableTypeName = variableType.getName();
+        if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+          const assertedTypeName = assertedType.getName(),
+                variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-      } else {
-        const type = assertedType,  ///
-              name = variableName,  ///
-              variable = Variable.fromTypeAndName(type, name),
-              typeAssertion = TypeAssertion.fromVariable(variable),
-              assertion = typeAssertion;  ///
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+        } else {
+          const type = assertedType,  ///
+                name = variableName,  ///
+                variable = Variable.fromTypeAndName(type, name),
+                assertion = Assertion.fromVariable(variable);
 
-        assertions.push(assertion);
+          assertions.push(assertion);
 
-        variableTypeAssertionVerified = true;
+          variableTypeAssertionVerified = true;
+        }
       }
     }
   }
@@ -98,40 +101,38 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
   return variableTypeAssertionVerified;
 }
 
-// function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
-//   let termTypeAssertionVerified = false;
-//
-//   const types = [],
-//         context = proofContext, ///
-//         termNode = termNodeQuery(typeAssertionNode),
-//         termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-//
-//   if (termVerifiedAgainstConstructors) {
-//     const typeNode = typeNodeQuery(typeAssertionNode),
-//           typeName = typeNameFromTypeNode(typeNode),
-//           assertedTypeName = typeName,  ///
-//           assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-//           firstType = first(types),
-//           termType = firstType,
-//           termString = proofContext.nodeAsString(termNode),
-//           termTypeEqualToOrSubTypeOfAssertedType = termType.isEqualToOrSubTypeOf(assertedType);
-//
-//     if (!termTypeEqualToOrSubTypeOfAssertedType) {
-//       const termTypeName = termType.getName(),
-//             assertedTypeName = assertedType.getName();
-//
-//       proofContext.error(`The '${termString}' term's '${termTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
-//     } else {
-//       const type = assertedType,  ///
-//             typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
-//             assertion = typeAssertion;  ///
-//
-//       assertions.push(assertion);
-//
-//       termTypeAssertionVerified = true;
-//     }
-//   }
-//
-//   return termTypeAssertionVerified;
-// }
+function verifyTermTypeAssertion(typeAssertionNode, context) {
+  let termTypeAssertionVerified = false;
+
+  const types = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+
+  if (termVerifiedAgainstConstructors) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = context.findTypeByTypeName(assertedTypeName);
+
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
+    } else {
+      const firstType = first(types),
+            termType = firstType, ///
+            termTypeIsEqualToAssertedType = termType.isEqualTo(assertedType);
+
+      if (!termTypeIsEqualToAssertedType) {
+        const termString = context.nodeAsString(termNode),
+              termTypeName = termType.getName(),
+              assertedTypeName = assertedType.getName();
+
+        context.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+      } else {
+        termTypeAssertionVerified = true;
+      }
+    }
+  }
+
+  return termTypeAssertionVerified;
+}