occam-verify-cli 0.0.1087 → 0.0.1089

package/src/declaration.js

@@ -100,71 +100,23 @@ class Declaration {
 
     localContext.trace(`Verifying the '${declarationString}' declaration...`);
 
-    if (!verified) {
-      const verifiedAtMetaLevel = this.verifyAtMetaLevel(assignments, stated, localContext);
-
-      verified = verifiedAtMetaLevel; ///
-    }
-
-    if (!verified) {
-      const verifiedAtIntrinsicLevel = this.verifyAtIntrinsicLevel(assignments, stated, localContext);
-
-      verified = verifiedAtIntrinsicLevel;  ///
-    }
-
-    if (verified) {
-      localContext.debug(`...verified the '${declarationString}' declaration.`);
-    }
-
-    return verified;
-  }
-
-  verifyAtMetaLevel(assignments, stated, localContext) {
-    let verifiedAtMetaLevel;
-
-    const declarationString = this.string;  ///
-
-    localContext.trace(`Verifying the '${declarationString}' declaration at meta level...`);
-
     stated = true;  ///
 
     assignments = null; ///
 
-    const referenceVerified = this.reference.verify(localContext),
-          statementVerified = this.statement.verify(assignments, stated, localContext);
+    const referenceVerified = this.reference.verify(localContext);
 
-    verifiedAtMetaLevel = (referenceVerified && statementVerified);
+    if (referenceVerified) {
+      const statementVerified = this.statement.verify(assignments, stated, localContext);
 
-    if (verifiedAtMetaLevel) {
-      localContext.debug(`...verified the '${declarationString}' declaration at meta level.`);
+      verified = statementVerified; ///
     }
 
-    return verifiedAtMetaLevel;
-  }
-
-  verifyAtIntrinsicLevel(assignments, stated, localContext) {
-    let verifiedAtIntrinsicLevel = false;
-
-    const declarationString = this.string;  ///
-
-    localContext.trace(`Verifying the '${declarationString}' declaration at intrinsic level...`);
-
-    const lemma = localContext.findLemmaByReference(this.reference),
-          theorem = localContext.findTheoremByReference(this.reference),
-          lemmaOrTheorem = (lemma || theorem);
-
-    if (lemmaOrTheorem !== null) {
-      const lemmaOrTheoremStatement = lemmaOrTheorem.getStatement(),
-            lemmaOrTheoremStatementEqualToStatement = lemmaOrTheoremStatement.isEqualTo(this.statement);
-
-      verifiedAtIntrinsicLevel = lemmaOrTheoremStatementEqualToStatement; ///
-    }
-
-    if (verifiedAtIntrinsicLevel) {
-      localContext.debug(`...verified the '${declarationString}' declaration at intrinsic level.`);
+    if (verified) {
+      localContext.debug(`...verified the '${declarationString}' declaration.`);
     }
 
-    return verifiedAtIntrinsicLevel;
+    return verified;
   }
 
   static fromDeclarationNode(declarationNode, localContext) {

package/src/frame.js

@@ -121,11 +121,11 @@ class Frame {
   }
 
   unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext) {
-    let metaLemmaOrMetaTheoremUnified;
+    let metaLemmaMetatheoremUnified;
 
     const metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
 
-    localContext.trace(`Unifying the '${metaLemmaMetatheoremString}' metatheorem or meta-lemma...`);
+    localContext.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem...`);
 
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
           substitutionsUnified = substitutions.everySubstitution((substitution) => {
@@ -136,45 +136,73 @@ class Frame {
             }
           });
 
-    metaLemmaOrMetaTheoremUnified = substitutionsUnified; ///
+    metaLemmaMetatheoremUnified = substitutionsUnified; ///
 
-    if (metaLemmaOrMetaTheoremUnified) {
-      localContext.debug(`...unified the '${metaLemmaMetatheoremString}' metatheorem or meta-lemma.`);
+    if (metaLemmaMetatheoremUnified) {
+      localContext.debug(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem.`);
     }
 
-    return metaLemmaOrMetaTheoremUnified;
+    return metaLemmaMetatheoremUnified;
+  }
+
+  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, localContext) {
+    let axiomLemmaTheoremOrConjectureUnified;
+
+    const axiomLemmaTheoremStringOrConjecture = axiomLemmaTheoremOrConjecture.getString();
+
+    localContext.trace(`Unifying the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture...`);
+
+    const substitutions = axiomLemmaTheoremOrConjecture.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, localContext);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    axiomLemmaTheoremOrConjectureUnified = substitutionsUnified; ///
+
+    if (axiomLemmaTheoremOrConjectureUnified) {
+      localContext.debug(`...unified the '${axiomLemmaTheoremStringOrConjecture}' axiom, lemma, theorem or conjecture.`);
+    }
+
+    return axiomLemmaTheoremOrConjectureUnified;
   }
 
   verify(assignments, stated, localContext) {
-    let verified;
+    let verified = false;
 
     const frameString = this.string;  ///
 
     localContext.trace(`Verifying the '${frameString}' frame...`);
 
     const declarationsVerified = this.declarations.every((declaration) => {
-            const declarationVerified = declaration.verify(assignments, stated, localContext);
+      const declarationVerified = declaration.verify(assignments, stated, localContext);
 
-            return declarationVerified;
-          }),
-          metavariablesVerified = this.metavariables.every((metavariable) => {
-            const metavariableVerified = metavariable.verify(localContext);
+      return declarationVerified;
+    });
 
-            return metavariableVerified;
-          });
+    if (declarationsVerified) {
+      const  metavariablesVerified = this.metavariables.every((metavariable) => {
+        const metavariableVerified = metavariable.verify(localContext);
 
-    if (declarationsVerified && metavariablesVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+        return metavariableVerified;
+      });
 
-      if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
-      } else {
-        verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
-      }
+      if (metavariablesVerified) {
+        let verifiedWhenStated = false,
+            verifiedWhenDerived = false;
+
+        if (stated) {
+          verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+        } else {
+          verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
+        }
 
-      if (verifiedWhenStated || verifiedWhenDerived) {
-        verified = true;
+        if (verifiedWhenStated || verifiedWhenDerived) {
+          verified = true;
+        }
       }
     }
 
@@ -194,19 +222,18 @@ class Frame {
 
     const declarationsLength = this.declarations.length;
 
-    if (declarationsLength === 0) {
+    if (declarationsLength > 0) {
+      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
+    } else {
       const metavariablesLength = this.metavariables.length;
 
-      if (metavariablesLength === 1) {
-        verifiedWhenStated = true;
-      } else {
+      if (metavariablesLength > 1) {
         localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
+      } else {
+        verifiedWhenStated = true;
       }
-    } else {
-      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
     }
 
-
     if (verifiedWhenStated) {
       localContext.debug(`...verified the '${frameString}' frame when stated.`);
     }

package/src/judgement.js

@@ -38,21 +38,24 @@ class Judgement {
 
     localContext.trace(`Verifying the '${judgementString}' judgement...`);
 
-    const frameVerified = this.frame.verify(assignments, stated, localContext),
-          declarationVerified = this.declaration.verify(assignments, stated, localContext);
+    const frameVerified = this.frame.verify(assignments, stated, localContext);
 
-    if (frameVerified && declarationVerified) {
-      let verifiedWhenStated = false,
-          verifiedWhenDerived = false;
+    if (frameVerified) {
+      const declarationVerified = this.declaration.verify(assignments, stated, localContext);
 
-      if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
-      } else {
-        verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
-      }
+      if (declarationVerified) {
+        let verifiedWhenStated = false,
+            verifiedWhenDerived = false;
+
+        if (stated) {
+          verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+        } else {
+          verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
+        }
 
-      if (verifiedWhenStated || verifiedWhenDerived) {
-        verified = true;
+        if (verifiedWhenStated || verifiedWhenDerived) {
+          verified = true;
+        }
       }
     }
 
@@ -88,21 +91,38 @@ class Judgement {
   }
 
   verifyWhenDerived(assignments, localContext) {
-    let verifiedWhenDerived;
+    let verifiedWhenDerived = false;
 
     const judgementString = this.string;  ///
 
     localContext.trace(`Verifying the '${judgementString}' judgement when derived...`);
 
-    const reference = this.declaration.getReference(),
-          metaLemma = localContext.findMetaLemmaByReference(reference),
-          metatheorem = localContext.findMetatheoremByReference(reference),
-          metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+    if (!verifiedWhenDerived) {
+      const reference = this.declaration.getReference(),
+            metaLemma = localContext.findMetaLemmaByReference(reference),
+            metatheorem = localContext.findMetatheoremByReference(reference),
+            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+      if (metaLemmaMetatheorem !== null) {
+        const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext);
+
+        verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
+      }
+    }
 
-    if (metaLemmaMetatheorem !== null) {
-      const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext);
+    if (!verifiedWhenDerived) {
+      const reference = this.declaration.getReference(),
+            axiom = localContext.findAxiomByReference(reference),
+            lemma = localContext.findLemmaByReference(reference),
+            theorem = localContext.findTheoremByReference(reference),
+            conjecture = localContext.findConjectureByReference(reference),
+            axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture);
 
-      verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
+      if (axiomLemmaTheoremOrConjecture !== null) {
+        const axiomLemmaTheoremOrConjectureUnified = this.frame.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, localContext);
+
+        verifiedWhenDerived = axiomLemmaTheoremOrConjectureUnified; ///
+      }
     }
 
     if (verifiedWhenDerived) {

package/src/lemma.js

@@ -1,97 +1,37 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { EMPTY_STRING } from "./constants";
-import { stringFromLabels } from "./topLevelAssertion";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-
-const proofNodeQuery = nodeQuery("/lemma/proof"),
-      labelNodesQuery = nodesQuery("/lemma/label"),
-      consequentNodeQuery = nodeQuery("/lemma/consequent"),
-      suppositionNodesQuery = nodesQuery("/lemma/supposition");
 
 class Lemma extends TopLevelAssertion {
   verify() {
-    let verified = false;
+    let verified;
 
-    const lemmaString = this.string;  ///
+    const fileContext = this.getFileContext(),
+          lemmaString = this.string;  ///
 
     (lemmaString === EMPTY_STRING) ?
-      this.fileContext.trace(`Verifying a lemma...`) :
-        this.fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
-
-    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
-      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    if (labelsVerifiedWhenDeclared) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(localContext);
-
-              if (suppositionVerified) {
-                return true;
-              }
-            });
-
-      if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(localContext);
-
-        if (consequentVerified) {
-          const { Substitutions } = shim,
-                substitutions = Substitutions.fromNothing(),
-                proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
+      fileContext.trace(`Verifying a lemma...`) :
+        fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
 
-          if (proofVerified) {
-            const lemma = this;  ///
+    verified = super.verify();
 
-            this.fileContext.addLemma(lemma);
+    if (verified) {
+      const lemma = this; ///
 
-            verified = true;
-          }
-        }
-      }
-    }
+      fileContext.addLemma(lemma);
 
-    if (verified) {
       (lemmaString === EMPTY_STRING) ?
-        this.fileContext.debug(`...verified a lemma.`) :
-          this.fileContext.debug(`...verified the '${lemmaString}' lemma.`);
+        fileContext.debug(`...verified a lemma.`) :
+          fileContext.debug(`...verified the '${lemmaString}' lemma.`);
     }
 
     return verified;
   }
 
-  static fromLemmaNode(lemmaNode, fileContext) {
-    const { Label, Proof, Supposition, Consequent } = shim,
-          proofNode = proofNodeQuery(lemmaNode),
-          labelNodes = labelNodesQuery(lemmaNode),
-          consequentNode = consequentNodeQuery(lemmaNode),
-          suppositionNodes = suppositionNodesQuery(lemmaNode),
-          labels = labelNodes.map((labelNode) => {
-            const label = Label.fromLabelNode(labelNode, fileContext);
-
-            return label;
-          }),
-          suppositions = suppositionNodes.map((suppositionNode) => {
-            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
-
-            return supposition;
-          }),
-          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
-          string = stringFromLabels(labels),
-          proof = Proof.fromProofNode(proofNode, fileContext),
-          lemma = new Lemma(fileContext, string, labels, suppositions, consequent, proof);
-
-    return lemma;
-  }
+  static fromLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Lemma, metaLemmaNode, fileContext); }
 }
 
 Object.assign(shim, {

package/src/metaLemma.js

@@ -1,106 +1,37 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { EMPTY_STRING } from "./constants";
-import { stringFromLabels } from "./topLevelAssertion";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-
-const proofNodeQuery = nodeQuery("/metaLemma/proof"),
-      labelNodesQuery = nodesQuery("/metaLemma/label"),
-      consequentNodeQuery = nodeQuery("/metaLemma/consequent"),
-      suppositionNodesQuery = nodesQuery("/metaLemma/supposition");
 
 class MetaLemma extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, consequent, proof, substitutions) {
-    super(fileContext, string, labels, suppositions, consequent, proof);
-
-    this.substitutions = substitutions;
-  }
-
-  getSubstitutions() {
-    return this.substitutions;
-  }
-
   verify() {
-    let verified = false;
+    let verified;
 
-    const metaLemmaString = this.string;  ///
+    const fileContext = this.getFileContext(),
+          metaLemmaString = this.string;  ///
 
     (metaLemmaString === EMPTY_STRING) ?
-      this.fileContext.trace(`Verifying a meta-lemma...`) :
-        this.fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
-
-    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
-      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
-
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
-
-    if (labelsVerifiedWhenDeclared) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(localContext);
-
-              if (suppositionVerified) {
-                return true;
-              }
-            });
+      fileContext.trace(`Verifying a meta-lemma...`) :
+        fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
-      if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(localContext);
+    verified = super.verify();
 
-        if (consequentVerified) {
-          const proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
-
-          if (proofVerified) {
-            const metaLemma = this;  ///
+    if (verified) {
+      const metaLemma = this; ///
 
-            this.fileContext.addMetaLemma(metaLemma);
+      fileContext.addMetaLemma(metaLemma);
 
-            verified = true;
-          }
-        }
-      }
-    }
-
-    if (verified) {
       (metaLemmaString === EMPTY_STRING) ?
-        this.fileContext.debug(`...verified a meta-lemma.`) :
-          this.fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
+        fileContext.debug(`...verified a meta-lemma.`) :
+          fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
     return verified;
   }
 
-  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
-    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
-          proofNode = proofNodeQuery(metaLemmaNode),
-          labelNodes = labelNodesQuery(metaLemmaNode),
-          consequentNode = consequentNodeQuery(metaLemmaNode),
-          suppositionNodes = suppositionNodesQuery(metaLemmaNode),
-          labels = labelNodes.map((labelNode) => {
-            const label = Label.fromLabelNode(labelNode, fileContext);
-
-            return label;
-          }),
-          suppositions = suppositionNodes.map((suppositionNode) => {
-            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
-
-            return supposition;
-          }),
-          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
-          proof = Proof.fromProofNode(proofNode, fileContext),
-          string = stringFromLabels(labels),
-          substitutions = Substitutions.fromNothing(),
-          metaLemma = new MetaLemma(fileContext, string, labels, suppositions, consequent, proof, substitutions);
-
-    return metaLemma;
-  }
+  static fromMetaLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(MetaLemma, metaLemmaNode, fileContext); }
 }
 
 Object.assign(shim, {

package/src/metatheorem.js

@@ -1,10 +1,8 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
-import { nodeQuery, nodesQuery } from "./utilities/query";
 import { stringFromLabels } from "./topLevelAssertion";
 import { labelsFromJSON,
          labelsToLabelsJSON,
@@ -15,66 +13,23 @@ import { labelsFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "./utilities/json";
 
-const proofNodeQuery = nodeQuery("/metatheorem/proof"),
-      labelNodesQuery = nodesQuery("/metatheorem/label"),
-      consequentNodeQuery = nodeQuery("/metatheorem/consequent"),
-      suppositionNodesQuery = nodesQuery("/metatheorem/supposition");
-
 class Metatheorem extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, consequent, proof, substitutions) {
-    super(fileContext, string, labels, suppositions, consequent, proof);
-
-    this.substitutions = substitutions;
-  }
-
-  getSubstitutions() {
-    return this.substitutions;
-  }
-
   verify() {
-    let verified = false;
-
-    const metatheoremString = this.string;  ///
-
-    this.fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
-
-    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
-      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
+    let verified;
 
-      if (labelVVerifiedWhenDeclared) {
-        return true;
-      }
-    });
+    const fileContext = this.getFileContext(),
+          metatheoremString = this.string;  ///
 
-    if (labelsVerifiedWhenDeclared) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(localContext);
+    fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
 
-              if (suppositionVerified) {
-                return true;
-              }
-            });
+    verified = super.verify();
 
-      if (suppositionsVerified) {
-        const consequentVerified = this.consequent.verify(localContext);
-
-        if (consequentVerified) {
-          const proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
-
-          if (proofVerified) {
-            const metatheorem = this;  ///
+    if (verified) {
+      const metaTheorem = this; ///
 
-            this.fileContext.addMetatheorem(metatheorem);
+      fileContext.addMetatheorem(metaTheorem);
 
-            verified = true;
-          }
-        }
-      }
-    }
-
-    if (verified) {
-      this.fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
+      fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
     }
 
     return verified;
@@ -111,30 +66,7 @@ class Metatheorem extends TopLevelAssertion {
     return topLevelAssertion;
   }
 
-  static fromMetatheoremNode(metatheoremNode, fileContext) {
-    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
-          proofNode = proofNodeQuery(metatheoremNode),
-          labelNodes = labelNodesQuery(metatheoremNode),
-          consequentNode = consequentNodeQuery(metatheoremNode),
-          suppositionNodes = suppositionNodesQuery(metatheoremNode),
-          labels = labelNodes.map((labelNode) => {
-            const label = Label.fromLabelNode(labelNode, fileContext);
-
-            return label;
-          }),
-          suppositions = suppositionNodes.map((suppositionNode) => {
-            const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
-
-            return supposition;
-          }),
-          consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
-          proof = Proof.fromProofNode(proofNode, fileContext),
-          string = stringFromLabels(labels),
-          substitutions = Substitutions.fromNothing(),
-          metatheorem = new Metatheorem(fileContext, string, labels, suppositions, consequent, proof, substitutions);
-
-    return metatheorem;
-  }
+  static fromMetatheoremNode(metatheoremNode, fileContext) { return TopLevelAssertion.fromNode(Metatheorem, metatheoremNode, fileContext); }
 }
 
 Object.assign(shim, {