occam-verify-cli 0.0.1245 → 0.0.1247

package/src/dom/declaration.js

@@ -150,19 +150,29 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' declaration...`);
 
-    const statementVerified = this.verifyStatement(this.statement, assignments, stated, context);
+    const referenceVerified = this.verifyReference(assignments, stated, context);
 
-    if (statementVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (referenceVerified) {
+      const statementVerified = this.verifyStatement(assignments, stated, context);
 
-      if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(context);
-      } else {
-        verifiedWhenDerived = this.verifyWhenDerived(frame, context);
-      }
+      if (statementVerified) {
+        let verifiedWhenStated = false,
+            verifiedWhenDerived = false;
 
-      verified = (verifiedWhenStated || verifiedWhenDerived);
+        if (stated) {
+          verifiedWhenStated = this.verifyWhenStated(frame, assignments, context);
+
+          verified = verifiedWhenStated;  ///
+        } else {
+          verifiedWhenDerived = this.verifyWhenDerived(context);
+
+          verified = verifiedWhenDerived; ///
+        }
+
+        if (verifiedWhenStated || verifiedWhenDerived) {
+          verified = true;
+        }
+      }
     }
 
     if (verified) {
@@ -172,26 +182,54 @@ export default domAssigned(class Declaration {
     return verified;
   }
 
-  verifyStatement(statement, assignments, stated, context) {
+  verifyReference(assignments, stated, context) {
+    let referenceVerified;
+
+    const referenceString = this.reference.getString(),
+          declarationString = this.string;  ///
+
+    context.trace(`Verifying the '${declarationString}' declaration's '${referenceString}' reference...`);
+
+    referenceVerified = this.reference.verify(context);
+
+    if (referenceVerified) {
+      context.debug(`...verified the '${declarationString}' declaration's '${referenceString}' reference.`);
+    }
+
+    return referenceVerified;
+  }
+
+  verifyStatement(assignments, stated, context) {
+    let statementVerified;
+
+    const statementString = this.statement.getString(),
+          declarationString = this.string;  ///
+
+    context.trace(`Verifying the '${declarationString}' declaration's '${statementString}' statement...`);
+
     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),
@@ -199,36 +237,38 @@ export default domAssigned(class Declaration {
             metaLemmaMetatheorems = [
               ...metaLemmas,
               ...metatheorems
-            ],
-            metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
-
-              if (metaLemmaMetatheoremUnified) {
-                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;
-          }
-        }
-      }
+            ];
     }
 
+
+    //       metaLemmaMetatheoremUnified = metaLemmaMetatheorems.some((metaLemmaMetatheorem) => {
+    //         const metaLemmaMetatheoremUnified = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+    //
+    //         if (metaLemmaMetatheoremUnified) {
+    //           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;
+    //     }
+    //   }
+    // }
+
     if (verifiedWhenStated) {
-      context.debug(`...verified the '${declarationString}' stated declaration.`);
+      context.trace(`...verified the '${declarationString}' stated declaration.`);
     }
 
     return verifiedWhenStated;
@@ -241,54 +281,50 @@ export default domAssigned(class Declaration {
 
     context.trace(`Verifying the '${declarationString}' derived declaration...`);
 
-    const referenceVerified = this.reference.verify(context);
-
-    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 (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;
-          }
-        }
-      }
-    }
+    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 (verifiedWhenDerived) {
-      context.debug(`...verified the '${declarationString}' derived declaration.`);
+      context.trace(`...verified the '${declarationString}' derived declaration.`);
     }
 
     return verifiedWhenDerived;
@@ -297,23 +333,19 @@ export default domAssigned(class Declaration {
   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; ///

package/src/dom/frame.js

@@ -70,93 +70,6 @@ export default domAssigned(class Frame {
     return equalTo;
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnified = false;
-
-    const frameString = this.string,  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
-
-    if (!substitutionUnified) {
-      substitutionUnified = this.declarations.some((declaration) => {
-        const substitutionUnified = declaration.unifySubstitution(substitution, context);
-
-        if (substitutionUnified) {
-          return true;
-        }
-      });
-    }
-
-    if (!substitutionUnified) {
-      substitutionUnified = this.metavariables.some((metavariable) => {
-        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
-
-        if (substitutionUnified) {
-          return true;
-        }
-      });
-    }
-
-    if (substitutionUnified) {
-      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
-    }
-
-    return substitutionUnified;
-  }
-
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnified;
-
-    const frameString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
-
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
-
-    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
-
-            if (substitutionUnified) {
-              return true;
-            }
-          });
-
-    metaLemmaMetatheoremUnified = substitutionsUnified; ///
-
-    if (metaLemmaMetatheoremUnified) {
-      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
-    }
-
-    return metaLemmaMetatheoremUnified;
-  }
-
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
-    let axiomLemmaTheoremOrConjectureUnified;
-
-    const frameString = this.string,  ///
-          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
-
-    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
-
-    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution, context);
-
-            if (substitutionUnified) {
-              return true;
-            }
-          });
-
-    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
-
-    if (axiomLemmaTheoremOrConjectureUnified) {
-      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
-    }
-
-    return axiomLemmaTheoremOrConjectureUnified;
-  }
-
   verify(assignments, stated, context) {
     let verified = false;
 
@@ -164,14 +77,10 @@ export default domAssigned(class Frame {
 
     context.trace(`Verifying the '${frameString}' frame...`);
 
-    const declarationsVerified = this.verifyDeclarations(this.declarations, assignments, stated, context);
+    const declarationsVerified = this.verifyDeclarations(assignments, stated, context);
 
     if (declarationsVerified) {
-      const  metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(context);
-
-        return metavariableVerified;
-      });
+      const  metavariablesVerified = this.verifyMetavariables(assignments, stated, context);
 
       if (metavariablesVerified) {
         let verifiedWhenStated = false,
@@ -196,21 +105,53 @@ export default domAssigned(class Frame {
     return verified;
   }
 
-  verifyDeclarations(declarations, assignments, stated, context) {
+  verifyDeclarations(assignments, stated, context) {
+    let declarationsVerified;
+
+    const frameString = this.string,  ///
+          declarationsString = declarationsStringFromDeclarations(this.declarations);
+
+    context.trace(`Verifying the '${frameString}' frame's '${declarationsString}' declarations...`);
+
     stated = true;  ///
 
     assignments = null; ///
 
-    const declarationsVerified = declarations.every((declaration) => {
+    declarationsVerified = this.declarations.every((declaration) => {
       const frame = null, ///
             declarationVerified = declaration.verify(frame, assignments, stated, context);
 
       return declarationVerified;
     });
 
+    if (declarationsVerified) {
+      context.debug(`...verified the '${frameString}' frame's '${declarationsString}' declarations.`);
+    }
+
     return declarationsVerified;
   }
 
+  verifyMetavariables(assignments, stated, context) {
+    let metavariablesVerified;
+
+    const frameString = this.string,  ///
+          metavariablesString = metavariablesStringFromDeclarations(this.metavariables);
+
+    context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariables...`);
+
+    metavariablesVerified = this.metavariables.every((metavariable) => {
+      const metavariableVerified = metavariable.verify(context);
+
+      return metavariableVerified;
+    });
+
+    if (metavariablesVerified) {
+      context.debug(`...verified the '${frameString}' frame's '${metavariablesString}' metavariables.`);
+    }
+
+    return metavariablesVerified;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 
@@ -278,6 +219,93 @@ export default domAssigned(class Frame {
     return verifiedGivenMetaType;
   }
 
+  unifySubstitution(substitution, context) {
+    let substitutionUnified = false;
+
+    const frameString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${frameString}' frame...`)
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.declarations.some((declaration) => {
+        const substitutionUnified = declaration.unifySubstitution(substitution, context);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.metavariables.some((metavariable) => {
+        const substitutionUnified = metavariable.unifySubstitution(substitution, context);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (substitutionUnified) {
+      context.debug(`...unified the '${substitutionString}' substitution with the '${frameString}' frame...`)
+    }
+
+    return substitutionUnified;
+  }
+
+  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
+    let metaLemmaMetatheoremUnified;
+
+    const frameString = this.string,  ///
+          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+
+    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame...`);
+
+    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, context);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    metaLemmaMetatheoremUnified = substitutionsUnified; ///
+
+    if (metaLemmaMetatheoremUnified) {
+      context.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${frameString}' frame.`);
+    }
+
+    return metaLemmaMetatheoremUnified;
+  }
+
+  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context) {
+    let axiomLemmaTheoremOrConjectureUnified;
+
+    const frameString = this.string,  ///
+          axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+
+    context.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame...`);
+
+    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, context);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
+
+    if (axiomLemmaTheoremOrConjectureUnified) {
+      context.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture with the '${frameString}' frame.`);
+    }
+
+    return axiomLemmaTheoremOrConjectureUnified;
+  }
+
   static name = "Frame";
 
   static fromFrameNode(frameNode, context) {
@@ -369,3 +397,31 @@ function metavariablesFromFrameNode(frameNode, context) {
 
   return metavariables;
 }
+
+function declarationsStringFromDeclarations(declarations) {
+  const declarationsString = declarations.reduce((declarationsString, declaration) => {
+    const declarationString = declaration.getString();
+
+    declarationsString = (declarationsString === null) ?
+                           declarationString :
+                            `${declarationsString}, ${declarationString}`;
+
+    return declarationsString;
+  }, null);
+
+  return declarationsString;
+}
+
+function metavariablesStringFromDeclarations(metavariable) {
+  const metavariablesString = metavariable.reduce((metavariablesString, metavariable) => {
+    const metavariableString = metavariable.getString();
+
+    metavariablesString = (metavariablesString === null) ?
+                            metavariableString :
+                             `${metavariablesString}, ${metavariableString}`;
+
+    return metavariablesString;
+  }, null);
+
+  return metavariablesString;
+}

package/src/dom/judgement.js

@@ -38,10 +38,10 @@ export default domAssigned(class Judgement {
 
     context.trace(`Verifying the '${judgementString}' judgement...`);
 
-    const frameVerified = this.frame.verify(assignments, stated, context);
+    const frameVerified = this.verifyFrame(assignments, stated, context);
 
     if (frameVerified) {
-      const declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
+      const declarationVerified = this.verifyDeclaration(assignments, stated, context);
 
       if (declarationVerified) {
         let verifiedWhenStated = false,
@@ -64,6 +64,40 @@ export default domAssigned(class Judgement {
     return verified;
   }
 
+  verifyFrame(assignments, stated, context) {
+    let frameVerified;
+
+    const frameString = this.frame.getString(),
+          judgementString = this.string;  ///
+
+    context.trace(`Verifying the '${judgementString}' judgement's '${frameString}' frame...`);
+
+    frameVerified = this.frame.verify(assignments, stated, context);
+
+    if (frameVerified) {
+      context.debug(`...verified the '${judgementString}' judgement's '${frameString}' frame.`);
+    }
+
+    return frameVerified;
+  }
+
+  verifyDeclaration(assignments, stated, context) {
+    let declarationVerified;
+
+    const judgementString = this.string,  ///
+          declarationString = this.declaration.getString();
+
+    context.trace(`Verifying the '${judgementString}' judgement's '${declarationString}' declaration...`);
+
+    declarationVerified = this.declaration.verify(this.frame, assignments, stated, context);
+
+    if (declarationVerified) {
+      context.debug(`...verified the '${judgementString}' judgement's '${declarationString}' declaration.`);
+    }
+
+    return declarationVerified;
+  }
+
   verifyWhenStated(assignments, context) {
     let verifiedWhenStated;