occam-verify-cli 0.0.1067 → 0.0.1069

package/src/lemma.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "./shim";
 import Label from "./label";
 import Proof from "./proof";
 import Consequent from "./consequent";
@@ -8,23 +9,24 @@ import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { EMPTY_STRING } from "./constants";
+import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { labelsStringFromLabels } from "./topLevelAssertion";
 
 const proofNodeQuery = nodeQuery("/lemma/proof"),
       labelNodesQuery = nodesQuery("/lemma/label"),
       consequentNodeQuery = nodeQuery("/lemma/consequent"),
       suppositionNodesQuery = nodesQuery("/lemma/supposition");
 
-export default class Lemma extends TopLevelAssertion {
+class Lemma extends TopLevelAssertion {
   verify() {
     let verified = false;
 
-    const labelsString = labelsStringFromLabels(this.labels);
+    const lemmaString = this.string;  ///
 
-    (labelsString === null) ?
+    (lemmaString === EMPTY_STRING) ?
       this.fileContext.trace(`Verifying a lemma...`) :
-        this.fileContext.trace(`Verifying the '${labelsString}' lemma...`);
+        this.fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
 
     const labelsVerifiedAtTopLevel = this.labels.every((label) => {
       const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
@@ -63,16 +65,14 @@ export default class Lemma extends TopLevelAssertion {
     }
 
     if (verified) {
-      (labelsString === null) ?
+      (lemmaString === EMPTY_STRING) ?
         this.fileContext.debug(`...verified a lemma.`) :
-          this.fileContext.debug(`...verified the '${labelsString}' lemma.`);
+          this.fileContext.debug(`...verified the '${lemmaString}' lemma.`);
     }
 
     return verified;
   }
 
-  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Lemma, json, fileContext); }
-
   static fromLemmaNode(lemmaNode, fileContext) {
     const proofNode = proofNodeQuery(lemmaNode),
           labelNodes = labelNodesQuery(lemmaNode),
@@ -89,9 +89,16 @@ export default class Lemma extends TopLevelAssertion {
             return supposition;
           }),
           consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          string = stringFromLabels(labels),
           proof = Proof.fromProofNode(proofNode, fileContext),
-          lemma = new Lemma(fileContext, labels, suppositions, consequent, proof);
+          lemma = new Lemma(fileContext, string, labels, suppositions, consequent, proof);
 
     return lemma;
   }
 }
+
+Object.assign(shim, {
+  Lemma
+});
+
+export default Lemma;

package/src/metaLemma.js

@@ -1,7 +1,108 @@
 "use strict";
 
+import Label from "./label";
+import Proof from "./proof";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import Substitutions from "./substitutions";
 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");
+
 export default class MetaLemma extends TopLevelAssertion {
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return MetaLemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, substitutions, fileContext); }
+  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 metaLemmaString = this.string;  ///
+
+    (metaLemmaString === EMPTY_STRING) ?
+      this.fileContext.trace(`Verifying a meta-lemma...`) :
+        this.fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
+
+    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
+      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+
+      if (labelVVerifiedAtTopLevel) {
+        return true;
+      }
+    });
+
+    if (labelsVerifiedAtTopLevel) {
+      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 proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
+
+          if (proofVerified) {
+            const metaLemma = this;  ///
+
+            this.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.`);
+    }
+
+    return verified;
+  }
+
+  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
+    const 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;
+  }
 }
+

package/src/metaType.js

@@ -57,15 +57,15 @@ class MetaType {
 
   static fromJSON(json, fileContext) {
     const { name } = json,
-          metaType = new MetaType(name);
+          metaTypeName = name,  ///
+          metaType = metaTypeFromMetaTypeName(metaTypeName);
 
     return metaType;
   }
 
   static fromMetaTypeNode(metaTypeNode, localContext) {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          name = metaTypeName,  ///
-          metaType = new MetaType(name);
+          metaType = metaTypeFromMetaTypeName(metaTypeName);
 
     return metaType;
   }
@@ -107,3 +107,29 @@ class StatementMetaType extends MetaType {
 export const frameMetaType = FrameMetaType.fromNothing();
 export const referenceMetaType = ReferenceMetaType.fromNothing();
 export const statementMetaType = StatementMetaType.fromNothing();
+
+function metaTypeFromMetaTypeName(metaTypeName) {
+  let metaType;
+
+  switch (metaTypeName) {
+    case FRAME_META_TYPE_NAME: {
+      metaType = frameMetaType; ///
+
+      break;
+    }
+
+    case REFERENCE_META_TYPE_NAME: {
+      metaType = referenceMetaType; ///
+
+      break;
+    }
+
+    case STATEMENT_META_TYPE_NAME: {
+      metaType = statementMetaType; ///
+
+      break;
+    }
+  }
+
+  return metaType;
+}

package/src/metatheorem.js

@@ -1,7 +1,148 @@
 "use strict";
 
+import shim from "./shim";
+import Label from "./label";
+import Proof from "./proof";
+import Consequent from "./consequent";
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Metatheorem extends TopLevelAssertion {
-  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Metatheorem, labels, suppositions, consequent, substitutions, fileContext); }
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { stringFromLabels } from "./topLevelAssertion";
+import { labelsFromJSON,
+         labelsToLabelsJSON,
+         consequentFromJSON,
+         suppositionsFromJSON,
+         substitutionsFromJSON,
+         consequentToConsequentJSON,
+         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 labelsVerifiedAtTopLevel = this.labels.every((label) => {
+      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+
+      if (labelVVerifiedAtTopLevel) {
+        return true;
+      }
+    });
+
+    if (labelsVerifiedAtTopLevel) {
+      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 proofVerified = this.proof.verify(this.substitutions, this.consequent, localContext);
+
+          if (proofVerified) {
+            const metatheorem = this;  ///
+
+            this.fileContext.addMetatheorem(metatheorem);
+
+            verified = true;
+          }
+        }
+      }
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${metatheoremString}' metatheorem.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const labelsJSON = labelsToLabelsJSON(this.labels),
+          consequentJSON = consequentToConsequentJSON(this.consequent),
+          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
+          substitutionsJSON = substitutionsToSubstitutionsJSON(this.substitutions),
+          labels = labelsJSON,  ///
+          consequent = consequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
+          substitutions = substitutionsJSON,  ///
+          json = {
+            labels,
+            consequent,
+            suppositions,
+            substitutions
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const labels = labelsFromJSON(json, fileContext),
+          consequent = consequentFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
+          substitutions = substitutionsFromJSON(json, fileContext),
+          string = stringFromLabels(labels),
+          proof = null,
+          topLevelAssertion = new Metatheorem(fileContext, string, labels, suppositions, consequent, proof, substitutions);
+
+    return topLevelAssertion;
+  }
+
+  static fromMetatheoremNode(metatheoremNode, fileContext) {
+    const 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;
+  }
 }
+
+Object.assign(shim, {
+  Metatheorem
+});
+
+export default Metatheorem;