occam-verify-cli 0.0.1246 → 0.0.1248

package/src/dom/declaration.js

@@ -5,6 +5,7 @@ import dom from "../dom";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
+import metaLemma from "./metaLemma";
 
 const statementNodeQuery = nodeQuery("/declaration/statement");
 
@@ -27,171 +28,93 @@ export default domAssigned(class Declaration {
     return this.statement;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnified;
-
-    const statementString = statement.getString(),
-          declarationStatementString = this.statement.getString(); ///
-
-    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
-
-    let statementNode = statement.getNode();
-
-    statementNode = stripBracketsFromStatementNode(statementNode); ///
-
-    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
-
-    statementUnified = statementNodeMatches;  ///
-
-    if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
-    }
-
-    return statementUnified;
-  }
-
-  unifyMetavariable(metavariable, context) {
-    let metavariableUnified;
-
-    const referenceString = this.reference.getString(),
-          metavariableString = metavariable.getString();
-
-    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
-
-    const metavariableNode = metavariable.getNode(),
-          metavariableNodeMatches = this.reference.matchMetavariableNode(metavariableNode);
-
-    metavariableUnified = metavariableNodeMatches;  ///
-
-    if (metavariableUnified) {
-      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
-    }
-
-    return metavariableUnified;
-  }
-
-  unifySubstitution(substitution, context) {
-    let substitutionUnified;
-
-    const declarationString = this.string,  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
-
-    const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(),
-          statementUnified = this.unifyStatement(statement, context),
-          metavariableUnified = this.unifyMetavariable(metavariable, context);
+  verify(frame, assignments, stated, context) {
+    let verified = false;
 
-    substitutionUnified = (metavariableUnified && statementUnified);
+    const declarationString = this.string;  ///
 
-    if (substitutionUnified) {
-      context.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
-    }
+    context.trace(`Verifying the '${declarationString}' declaration...`);
 
-    return substitutionUnified;
-  }
+    const referenceVerified = this.verifyReference(assignments, stated, context);
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified = false;
+    if (referenceVerified) {
+      const statementVerified = this.verifyStatement(assignments, stated, context);
 
-    const declarationString = this.string,  ///
-          metalemmaMetatheoremString = metaLemmaMetatheorem.getString();
+      if (statementVerified) {
+        let verifiedWhenStated = false,
+            verifiedWhenDerived = false;
 
-    context.trace(`Unifying the '${metalemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration...`);
+        if (stated) {
+          verifiedWhenStated = this.verifyWhenStated(frame, assignments, context);
 
-    const substitutions = Substitutions.fromNothing(),
-          referenceUnified = metaLemmaMetatheorem.unifyReference(this.reference, substitutions, context);
+          verified = verifiedWhenStated;  ///
+        } else {
+          verifiedWhenDerived = this.verifyWhenDerived(context);
 
-    if (referenceUnified) {
-      const statementUnified = metaLemmaMetatheorem.unifyStatement(this.statement, substitutions, context);
+          verified = verifiedWhenDerived; ///
+        }
 
-      if (statementUnified) {
-        metaLemmaMetatheoremUnified = true;
+        if (verifiedWhenStated || verifiedWhenDerived) {
+          verified = true;
+        }
       }
     }
 
-    if (metaLemmaMetatheoremUnified) {
-      context.debug(`...unified the '${metalemmaMetatheoremString}' meta-lemma or metatheorem with the '${declarationString}' declaration.`);
+    if (verified) {
+      context.debug(`...verified the '${declarationString}' declaration.`);
     }
 
-    return metaLemmaMetatheoremUnified;
+    return verified;
   }
 
-  unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, context) {
-    let axiomLemmaTheoremConjectureUnified = false;
-
-    const declarationString = this.string,  ///
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
-
-    context.trace(`Unifying the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${declarationString}' declaration...`);
+  verifyReference(assignments, stated, context) {
+    let referenceVerified;
 
-    const referenceUnified = axiomLemmaTheoremConjecture.unifyReference(this.reference, context);
+    const referenceString = this.reference.getString(),
+          declarationString = this.string;  ///
 
-    if (referenceUnified) {
-      const statementUnified = axiomLemmaTheoremConjecture.unifyStatement(this.statement, context);
+    context.trace(`Verifying the '${declarationString}' declaration's '${referenceString}' reference...`);
 
-      if (statementUnified) {
-        axiomLemmaTheoremConjectureUnified = true;
-      }
-    }
+    referenceVerified = this.reference.verify(context);
 
-    if (axiomLemmaTheoremConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture with the '${declarationString}' declaration.`);
+    if (referenceVerified) {
+      context.debug(`...verified the '${declarationString}' declaration's '${referenceString}' reference.`);
     }
 
-    return axiomLemmaTheoremConjectureUnified;
+    return referenceVerified;
   }
 
-  verify(frame, assignments, stated, context) {
-    let verified = false;
+  verifyStatement(assignments, stated, context) {
+    let statementVerified;
 
-    const declarationString = this.string;  ///
-
-    context.trace(`Verifying the '${declarationString}' declaration...`);
+    const statementString = this.statement.getString(),
+          declarationString = this.string;  ///
 
-    const statementVerified = this.verifyStatement(this.statement, assignments, stated, context);
+    context.trace(`Verifying the '${declarationString}' declaration's '${statementString}' statement...`);
 
-    if (statementVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
-
-      if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(context);
-      } else {
-        verifiedWhenDerived = this.verifyWhenDerived(frame, context);
-      }
-
-      verified = (verifiedWhenStated || verifiedWhenDerived);
-    }
-
-    if (verified) {
-      context.debug(`...verified the '${declarationString}' declaration.`);
-    }
-
-    return verified;
-  }
-
-  verifyStatement(statement, assignments, stated, context) {
     stated = true;  ///
 
     assignments = null; ///
 
-    const statementVerified = statement.verify(assignments, stated, context);
+    statementVerified = this.statement.verify(assignments, stated, context);
+
+    if (statementVerified) {
+      context.debug(`...verified the '${declarationString}' declaration's '${statementString}' statement.`);
+    }
 
     return statementVerified;
   }
 
-  verifyWhenStated(context) {
+  verifyWhenStated(frame, assignments, context) {
     let verifiedWhenStated;
 
     const declarationString = this.string;  ///
 
     context.trace(`Verifying the '${declarationString}' stated declaration...`);
 
-    const referenceVerified = this.reference.verify(context);
+    const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
 
-    if (referenceVerified) {
+    if (metavariablePresent) {
       verifiedWhenStated = true;
     } else {
       const metaLemmas = context.findMetaLemmasByReference(this.reference),
@@ -200,35 +123,19 @@ export default domAssigned(class Declaration {
               ...metaLemmas,
               ...metatheorems
             ],
-            metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+            metaLemmaMetatheoremsVerifiedWhenStated = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
+              const metaLemmaMetatheoremVerifiedWhenStated = metaLemmaMetatheorem.verifyWhenStated(this.statement, this.reference, context);
 
-              if (metaLemmaMetatheoremUnified) {
+              if (metaLemmaMetatheoremVerifiedWhenStated) {
                 return true;
               }
             });
 
-      if (metaLemmaMetatheoremUnified) {
-        verifiedWhenStated = true;
-      } else {
-        const axiom = context.findAxiomByReference(this.reference),
-              lemma = context.findLemmaByReference(this.reference),
-              theorem = context.findTheoremByReference(this.reference),
-              conjecture = context.findConjectureByReference(this.reference),
-              axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
-
-        if (axiomLemmaTheoremConjecture !== null) {
-          const axiomLemmaTheoremConjectureUnified = this.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, context);
-
-          if (axiomLemmaTheoremConjectureUnified) {
-            verifiedWhenStated = true;
-          }
-        }
-      }
+      verifiedWhenStated = metaLemmaMetatheoremsVerifiedWhenStated; ///
     }
 
     if (verifiedWhenStated) {
-      context.debug(`...verified the '${declarationString}' stated declaration.`);
+      context.trace(`...verified the '${declarationString}' stated declaration.`);
     }
 
     return verifiedWhenStated;
@@ -241,79 +148,136 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' derived declaration...`);
 
-    const referenceVerified = this.reference.verify(context);
+    debugger
+
+    // const metaLemmas = context.findMetaLemmasByReference(this.reference),
+    //       metatheorems = context.findMetatheoremsByReference(this.reference),
+    //       metaLemmaMetatheorems = [
+    //         ...metaLemmas,
+    //         ...metatheorems
+    //       ],
+    //       metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
+    //         let metaLemmaMetatheoremUnified = true;
+    //
+    //         if (metaLemmaMetatheoremUnified) {
+    //           metaLemmaMetatheoremUnified = frame.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+    //         }
+    //
+    //         if (metaLemmaMetatheoremUnified) {
+    //           metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+    //         }
+    //
+    //         if (metaLemmaMetatheoremUnified) {
+    //           return true;
+    //         }
+    //       });
+    //
+    // if (metaLemmaMetatheoremUnified) {
+    //   verifiedWhenDerived = true;
+    // } else {
+    //   const axiom = context.findAxiomByReference(this.reference),
+    //         lemma = context.findLemmaByReference(this.reference),
+    //         theorem = context.findTheoremByReference(this.reference),
+    //         conjecture = context.findConjectureByReference(this.reference),
+    //         axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
+    //
+    //   if (axiomLemmaTheoremConjecture !== null) {
+    //     const axiomLemmaTheoremConjectureUnified = this.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, context);
+    //
+    //     if (axiomLemmaTheoremConjectureUnified) {
+    //       verifiedWhenDerived = true;
+    //     }
+    //   }
+    // }
 
-    if (referenceVerified) {
-      verifiedWhenDerived = true;
-    } else {
-      const metaLemmas = context.findMetaLemmasByReference(this.reference),
-            metatheorems = context.findMetatheoremsByReference(this.reference),
-            metaLemmaMetatheorems = [
-              ...metaLemmas,
-              ...metatheorems
-            ],
-            metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
-              let metaLemmaMetatheoremUnified = true;
+    if (verifiedWhenDerived) {
+      context.trace(`...verified the '${declarationString}' derived declaration.`);
+    }
 
-              if (metaLemmaMetatheoremUnified) {
-                metaLemmaMetatheoremUnified = frame.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
-              }
+    return verifiedWhenDerived;
+  }
 
-              if (metaLemmaMetatheoremUnified) {
-                metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
-              }
+  unifyStatement(statement, context) {
+    let statementUnified;
 
-              if (metaLemmaMetatheoremUnified) {
-                return true;
-              }
-            });
+    const statementString = statement.getString(),
+          declarationStatementString = this.statement.getString(); ///
 
-      if (metaLemmaMetatheoremUnified) {
-        verifiedWhenDerived = true;
-      } else {
-        const axiom = context.findAxiomByReference(this.reference),
-              lemma = context.findLemmaByReference(this.reference),
-              theorem = context.findTheoremByReference(this.reference),
-              conjecture = context.findConjectureByReference(this.reference),
-              axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
-
-        if (axiomLemmaTheoremConjecture !== null) {
-          const axiomLemmaTheoremConjectureUnified = this.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, context);
-
-          if (axiomLemmaTheoremConjectureUnified) {
-            verifiedWhenDerived = true;
-          }
-        }
-      }
+    context.trace(`Unifying the '${statementString}' statement with the '${declarationStatementString}' statement...`);
+
+    let statementNode = statement.getNode();
+
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
+
+    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
+
+    statementUnified = statementNodeMatches;  ///
+
+    if (statementUnified) {
+      context.debug(`...unified the '${statementString}' statement with the '${declarationStatementString}' statement.`);
     }
 
-    if (verifiedWhenDerived) {
-      context.debug(`...verified the '${declarationString}' derived declaration.`);
+    return statementUnified;
+  }
+
+  unifyMetavariable(metavariable, context) {
+    let metavariableUnified;
+
+    const referenceString = this.reference.getString(),
+          metavariableString = metavariable.getString();
+
+    context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
+
+    const metavariableNode = metavariable.getNode(),
+          metavariableNodeMatches = this.reference.matchMetavariableNode(metavariableNode);
+
+    metavariableUnified = metavariableNodeMatches;  ///
+
+    if (metavariableUnified) {
+      context.debug(`...unified the '${metavariableString}' metavariable with the '${referenceString}' reference.`);
     }
 
-    return verifiedWhenDerived;
+    return metavariableUnified;
+  }
+
+  unifySubstitution(substitution, context) {
+    let substitutionUnified;
+
+    const declarationString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${declarationString}' declaration...`);
+
+    const statement = substitution.getStatement(),
+          metavariable = substitution.getMetavariable(),
+          statementUnified = this.unifyStatement(statement, context),
+          metavariableUnified = this.unifyMetavariable(metavariable, context);
+
+    substitutionUnified = (metavariableUnified && statementUnified);
+
+    if (substitutionUnified) {
+      context.debug(`...unified the '${declarationString}' substitution with the '${substitutionString}' declaration.`);
+    }
+
+    return substitutionUnified;
   }
 
   static name = "Declaration";
 
   static fromDeclarationNode(declarationNode, context) {
-    let declaration = null;
+    const { Reference, Statement } = dom,
+          node = declarationNode,  ///
+          string = context.nodeAsString(node);
 
-    if (declarationNode !== null) {
-      const { Statement } = dom;
+    let statementNode;
 
-      let statementNode = statementNodeQuery(declarationNode);
+    statementNode = statementNodeQuery(declarationNode);
 
-      statementNode = stripBracketsFromStatementNode(statementNode);  ///
+    statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
-      const { Reference } = dom,
-            reference = Reference.fromDeclarationNode(declarationNode, context),
-            statement = Statement.fromStatementNode(statementNode, context),
-            node = declarationNode,  ///
-            string = context.nodeAsString(node);
-
-      declaration = new Declaration(string, reference, statement);
-    }
+    const reference = Reference.fromDeclarationNode(declarationNode, context),
+          statement = Statement.fromStatementNode(statementNode, context),
+          declaration = new Declaration(string, reference, statement);
 
     return declaration;
   }

package/src/dom/equality.js

@@ -81,7 +81,7 @@ export default domAssigned(class Equality {
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(context);
+        verifiedWhenStated = this.verifyWhenStated(assignments, context);
       } else {
         verifiedWhenDerived = this.verifyWhenDerived(context);
       }
@@ -170,7 +170,7 @@ export default domAssigned(class Equality {
     return termsVerified;
   }
 
-  verifyWhenStated(context) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated;
 
     const equalityString = this.string; ///