occam-verify-cli 0.0.538 → 0.0.540

package/src/verifier/termForVariable.js

@@ -3,14 +3,16 @@
 import Verifier from "../verifier";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 import { TERM_RULE_NAME } from "../ruleNames";
 import { variableNameFromVariableNode } from "../utilities/query";
+import { verifyTermAgainstConstructors } from "../verify/term";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -23,28 +25,28 @@ export default class TermForVariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);
 
         if (termNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions) {
+  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
     let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);
 
       termNodeVerified = variableVerified; ///
     }
@@ -52,7 +54,7 @@ export default class TermForVariableVerifier extends Verifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeB, termNodeB, substitutions) {
+  verifyVariableNode(variableNodeB, termNodeB, substitutions, proofContextA, proofContextB) {
     let variableVerified;
 
     const variableNameA = variableNameFromVariableNode(variableNodeB),
@@ -74,14 +76,32 @@ export default class TermForVariableVerifier extends Verifier {
 
       if (createSubstitutions) {
         const variableName = variableNameA, ///
-              termNode = termNodeB, ///
-              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
-              substitution = termForVariableSubstitution;  ///
+              proofContext = proofContextA, ///
+              variable = proofContext.findVariableByVariableName(variableName);
 
-        substitutions.push(substitution);
-      }
+        if (variable !== null) {
+          const types = [],
+                context = proofContextB, ///
+                termNode = termNodeB, ///
+                termVerified = verifyTermAgainstConstructors(termNodeB, types, context);
+
+          if (termVerified) {
+            const firstType = first(types),
+                  termType = firstType,
+                  variableType = variable.getType(),
+                  variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+
+            if (variableTypeEqualToOrSuperTypeOfTermType) {
+              const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                    substitution = termForVariableSubstitution;  ///
+
+              substitutions.push(substitution);
 
-      variableVerified = true;
+              variableVerified = true;
+            }
+          }
+        }
+      }
     }
 
     return variableVerified;

package/src/verifier.js

@@ -40,7 +40,7 @@ export default class Verifier {
         if (nodeVerified) {
           return true;
         }
-      })
+      });
     }
 
     return nodesVerify;

package/src/verify/assertion/type.js

@@ -85,9 +85,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
 
           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),
+          const name = variableName,  ///
+                type = assertedType,  ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);

package/src/verify/axiom.js

@@ -44,7 +44,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
       if (consequenceVerified) {
         const firstConsequence = first(consequences),
               consequence = firstConsequence, ///
-              axiom = Axiom.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+              axiom = Axiom.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/conjecture.js

@@ -9,6 +9,7 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import proof from "../context/proof";
 
 const proofNodeQuery = nodeQuery("/conjecture/proof!"),
       labelNodesQuery = nodesQuery("/conjecture/label"),
@@ -50,7 +51,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
 
         verifyProof(proofNode, consequence, proofContext);
 
-        const conjecture = Conjecture.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+        const conjecture = Conjecture.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
         fileContext.addConjecture(conjecture);
 

package/src/verify/declaration/metavariable.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import verifyMetavariable from "../../verify/metavariable";
+
+import { nodeQuery } from "../../utilities/query";
+
+const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
+      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable");
+
+export default function verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext) {
+  let metavariableDeclarationVerified;
+
+  const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
+        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
+        metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
+
+  metavariableDeclarationVerified = metavariableVVerified;  ///
+
+  return metavariableDeclarationVerified;
+}

package/src/verify/declaration/topLevel.js

@@ -9,6 +9,7 @@ import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
 import verifyConstructorDeclaration from "../../verify/declaration/constructor";
+import verifyMetavariableDeclaration from "../../verify/declaration/metavariable";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -20,7 +21,8 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
-      constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
+      constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!"),
+      metavariableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/metavariableDeclaration!");
 
 export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
@@ -34,7 +36,8 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
-        constructorDeclarationNode = constructorDeclarationNodeQuery(node);
+        constructorDeclarationNode = constructorDeclarationNodeQuery(node),
+        metavariableDeclarationNode = metavariableDeclarationNodeQuery(node);
 
   if (false) {
     ///
@@ -74,6 +77,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
+  } else if (metavariableDeclarationNode !== null) {
+    const metavariableDeclarationVerified = verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext);
+
+    topLevelDeclarationVerified = metavariableDeclarationVerified;  ///
   }
 
   return topLevelDeclarationVerified;

package/src/verify/lemma.js

@@ -53,7 +53,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
               proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+          const lemma = Lemma.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metastatement/qualified.js

@@ -11,7 +11,8 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode),
+          metastatementMetaproofContext = metaproofContext; ///
 
     metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
@@ -20,7 +21,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
           rule = metaproofContext.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementMetaproofContext);
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }

package/src/verify/metastatement.js

@@ -1,9 +1,72 @@
 "use strict";
 
+import Verifier from "../verifier";
+
+import { METAVARIABLE_RULE_NAME } from "../ruleNames";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+
+class MetastatementVerifier extends Verifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, metaproofContext) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNode = nonTerminalNodeA, ///
+          ruleName = nonTerminalNode.getRuleName(); ///
+
+    switch (ruleName) {
+      case METAVARIABLE_RULE_NAME: {
+        const metavariableNode = nonTerminalNode, ///
+              metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, metaproofContext);
+
+        nonTerminalNodeVerified = metavariableNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              nodesA = childNodes, ///
+              nodesB = childNodes, ///
+              nodesVerified = this.verifyNodes(nodesA, nodesB, metaproofContext);
+
+        nonTerminalNodeVerified = nodesVerified; ///
+
+        break;
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyMetavariableNode(metavariableNode, metaproofContext) {
+    let metavariableNodeVerified = false;
+
+    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+    if (!metavariablePresent) {
+      const metavariableString = metaproofContext.nodeAsString(metavariableNode);
+
+      metaproofContext.error(`The '${metavariableString}' metavariable is not present.`, metavariableNode);
+    } else {
+      metavariableNodeVerified = true;
+    }
+
+    return metavariableNodeVerified;
+  }
+}
+
+const metastatementVerifier = new MetastatementVerifier();
+
 export default function verifyMetastatement(metastatementNode, assignments, derived, metaproofContext) {
-  let metastatementVerified = true; ///
+  let metastatementVerified = false;
+
+  if (!metastatementVerified) {
+    const nonTerminalNodeA = metastatementNode, ///
+          nonTerminalNodeB = metastatementNode, ///
+          nonTerminalNodeVerified = metastatementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, metaproofContext);
 
-  ///
+    metastatementVerified = nonTerminalNodeVerified;  ///
+  }
 
   return metastatementVerified;
 }

package/src/verify/metavariable.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import Metavariable from "../metavariable";
+
+import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } from "../utilities/query";
+
+export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
+  let metavariableVerified = false;
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariableString = fileContext.nodeAsString(metavariableNode),
+        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+  if (metavariablePresent) {
+    fileContext.error(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+  } else {
+    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+          metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
+          name = metavariableName,  ///
+          metavariable = Metavariable.fromNameAndMetaType(name, metaType);
+
+    fileContext.addMetavariable(metavariable);
+
+    metavariableVerified = true;
+  }
+
+  if (metavariableVerified) {
+    fileContext.info(`Verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verify/rule.js

@@ -55,7 +55,7 @@ export default function verifyRule(ruleNode, fileContext) {
         }
 
         if (ruleProofVerified) {
-          const rule = Rule.fromLabelsPremisesAndConclusion(labels, premises, conclusion);
+          const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
 
           fileContext.addRule(rule);
 

package/src/verify/statement/qualified.js

@@ -11,7 +11,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = proofContext.nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode),
+          statementProofContext = proofContext; ///
 
     proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
@@ -22,7 +23,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const rule = proofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+        const ruleMatchesStatement = rule.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = ruleMatchesStatement;  ///
       }
@@ -32,7 +33,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const axiom = proofContext.findAxiomByReferenceName(referenceName);
 
       if (axiom !== null) {
-        const axiomMatchesStatement = axiom.matchStatement(statementNode, proofContext);
+        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = axiomMatchesStatement; ///
       }
@@ -42,7 +43,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const lemma = proofContext.findLemmaByReferenceName(referenceName);
 
       if (lemma !== null) {
-        const lemmaMatchesStatement = lemma.matchStatement(statementNode, proofContext);
+        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = lemmaMatchesStatement; ///
       }
@@ -52,7 +53,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const theorem = proofContext.findTheoremByReferenceName(referenceName);
 
       if (theorem !== null) {
-        const theoremMatchesStatement = theorem.matchStatement(statementNode, proofContext);
+        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = theoremMatchesStatement; ///
       }
@@ -62,7 +63,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const conjecture = proofContext.findConjectureByReferenceName(referenceName);
 
       if (conjecture !== null) {
-        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, proofContext);
+        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = conjectureMatchesStatement; ///
       }

package/src/verify/statement.js

@@ -192,8 +192,8 @@ function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode,  ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        nodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context),
-        statementVerifiedAgainstCombinator = nodeVerified;  ///
+        nonTerminalNodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context),
+        statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
 
   return statementVerifiedAgainstCombinator;
 }
@@ -254,18 +254,18 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
                 rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
 
           if (leftVariableTypeSuperTypeOfRightVariableType) {
-            const type = rightVariableType,  ///
-                  name = leftVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = leftVariableName, ///
+                  type = rightVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
           }
 
           if (rightVariableTypeSuperTypeOfLeftVariableType) {
-            const type = leftVariableType,  ///
-                  name = rightVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = rightVariableName, ///
+                  type = leftVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
@@ -293,9 +293,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
         } else {
-          const type = rightTermType, ///
-                name = leftVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = leftVariableName,  ///
+                type = rightTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);
@@ -322,9 +322,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
         } else {
-          const type = leftTermType, ///
-                name = rightVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = rightVariableName,  ///
+                type = leftTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);

package/src/verify/theorem.js

@@ -9,6 +9,7 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import proof from "../context/proof";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
       labelNodesQuery = nodesQuery("/theorem/label"),
@@ -50,7 +51,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
               proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+          const theorem = Theorem.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
           fileContext.addTheorem(theorem);
 

package/src/verify/variable.js

@@ -20,10 +20,10 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
     const typeName = typeNameFromTypeNode(typeNode);
     
     if (typeName === null) {
-      const type = objectType,
-            name = variableName;  ///
+      const name = variableName,  ///
+            type = objectType;
 
-      variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
     } else {
       const type = fileContext.findTypeByTypeName(typeName);
 
@@ -32,7 +32,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
       } else {
         const name = variableName;  ///
 
-        variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
       }
     }