occam-verify-cli 0.0.1068 → 0.0.1069

package/src/frame.js

@@ -41,14 +41,18 @@ class Frame {
   }
 
   getMetavariable() {
-    let metavariable;
+    let metavariable = null;
 
-    const metavariablesLength = this.metavariables.length;
+    const declarationsLength = this.declarations.length;
+
+    if (declarationsLength === 0) {
+      const metavariablesLength = this.metavariables.length;
 
-    if (metavariablesLength === 1) {
-      const firstMetavariable = first(this.metavariables);
+      if (metavariablesLength === 1) {
+        const firstMetavariable = first(this.metavariables);
 
-      metavariable = firstMetavariable; ///
+        metavariable = firstMetavariable; ///
+      }
     }
 
     return metavariable;
@@ -57,65 +61,91 @@ class Frame {
   getMetavariableNode() {
     let metavariableNode = null;
 
-    const declarationsLength = this.declarations.length;
+    const metavariable = this.getMetavariable();
 
-    if (declarationsLength === 0) {
-      const metavariablesLength = this.metavariables.length;
+    if (metavariable !== null) {
+      metavariableNode = metavariable.getNode();
+    }
 
-      if (metavariablesLength === 1) {
-        const firstMetavariable = first(this.metavariables),
-              metavariable = firstMetavariable; ///
+    return metavariableNode;
+  }
 
-        metavariableNode = metavariable.getNode();
-      }
+  matchFrameNode(frameNode) {
+    const frameNodeMatches = this.node.match(frameNode);
+
+    return frameNodeMatches;
+  }
+
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches = false;
+
+    const metavariable = this.getMetavariable();
+
+    if (metavariable !== null) {
+      metavariableNameMatches = metavariable.matchMetavariableName(metavariableName);
     }
 
-    return metavariableNode;
+    return metavariableNameMatches;
   }
 
-  // matchMetavariableName(metavariableName) {
-  //   let metavariableNameMatches = false;
-  //
-  //   const metavariableNode = this.getMetavariableNode();
-  //
-  //   if (metavariableNode !== null) {
-  //     const name = metavariableName;  ///
-  //
-  //     metavariableName = metavariableNameFromMetavariableNode(metavariableNode);  ///
-  //
-  //     const nameMatchesMetavariableName = (name === metavariableName);
-  //
-  //     metavariableNameMatches = nameMatchesMetavariableName;  ///
-  //   }
-  //
-  //   return metavariableNameMatches;
-  // }
-  //
-  // unifySubstitution(substitution) {
-  //   const substitutionUnified = this.declarations.some((declaration) => {
-  //     const substitutionUnifiedWithDeclaration = declaration.unifySubstitution(substitution);
-  //
-  //     if (substitutionUnifiedWithDeclaration) {
-  //       return true;
-  //     }
-  //   });
-  //
-  //   return substitutionUnified;
-  // }
-  //
-  // unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) {
-  //   const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-  //         substitutionsUnified = substitutions.everySubstitution((substitution) => {
-  //           const substitutionUnified = this.unifySubstitution(substitution);
-  //
-  //           if (substitutionUnified) {
-  //             return true;
-  //           }
-  //         }),
-  //         metaLemmaOrMetaTheoremUnified = substitutionsUnified; ///
-  //
-  //   return metaLemmaOrMetaTheoremUnified;
-  // }
+  unifySubstitution(substitution, localContext) {
+    let substitutionUnified = false;
+
+    const substitutionString = substitution.getString();
+
+    localContext.trace(`Unifying the '${substitutionString}' substitution...`)
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.declarations.some((declaration) => {
+        const substitutionUnified = declaration.unifySubstitution(substitution, localContext);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (!substitutionUnified) {
+      substitutionUnified = this.metavariables.some((metavariable) => {
+        const substitutionUnified = metavariable.unifySubstitution(substitution, localContext);
+
+        if (substitutionUnified) {
+          return true;
+        }
+      });
+    }
+
+    if (substitutionUnified) {
+      localContext.debug(`...unified the '${substitutionString}' substitution...`)
+    }
+
+    return substitutionUnified;
+  }
+
+  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext) {
+    let metaLemmaOrMetaTheoremUnified;
+
+    const metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+
+    localContext.trace(`Unifying the '${metaLemmaMetatheoremString}' metatheorem or meta-lemma...`);
+
+    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution, localContext);
+
+            if (substitutionUnified) {
+              return true;
+            }
+          });
+
+    metaLemmaOrMetaTheoremUnified = substitutionsUnified; ///
+
+    if (metaLemmaOrMetaTheoremUnified) {
+      localContext.debug(`...unified the '${metaLemmaMetatheoremString}' metatheorem or meta-lemma.`);
+    }
+
+    return metaLemmaOrMetaTheoremUnified;
+  }
 
   verify(assignments, stated, localContext) {
     let verified;
@@ -124,17 +154,30 @@ class Frame {
 
     localContext.trace(`Verifying the '${frameString}' frame...`);
 
-    let verifiedWhenStated = false,
-        verifiedWhenDerived = false;
+    const declarationsVerified = this.declarations.every((declaration) => {
+            const declarationVerified = declaration.verify(assignments, stated, localContext);
 
-    if (stated) {
-      verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
-    } else {
-      verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
-    }
+            return declarationVerified;
+          }),
+          metavariablesVerified = this.metavariables.every((metavariable) => {
+            const metavariableVerified = metavariable.verify(localContext);
+
+            return metavariableVerified;
+          });
+
+    if (declarationsVerified && 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;
+      }
     }
 
     if (verified) {
@@ -157,11 +200,7 @@ class Frame {
       const metavariablesLength = this.metavariables.length;
 
       if (metavariablesLength === 1) {
-        const firstMetavariable = first(this.metavariables),
-              metavariable = firstMetavariable, ///
-              metavariableVerified = metavariable.verify(localContext);
-
-        verifiedWhenStated = metavariableVerified;  ///
+        verifiedWhenStated = true;
       } else {
         localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
       }
@@ -184,21 +223,7 @@ class Frame {
 
     localContext.trace(`Verifying the '${frameString}' frame when derived...`);
 
-    const declarationsVerified = this.declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(assignments, stated, localContext);
-
-      return declarationVerified;
-    });
-
-    if (declarationsVerified) {
-      const metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(localContext);
-
-        return metavariableVerified;
-      });
-
-      verifiedWhenDerived = metavariablesVerified; ///
-    }
+    verifiedWhenDerived = true;
 
     if (verifiedWhenDerived) {
       localContext.debug(`...verified the '${frameString}' frame when derived.`);

package/src/index.js

@@ -2,12 +2,28 @@
 
 import Type from "./type";
 import Term from "./term";
+import Rule from "./rule";
+import Label from "./label";
+import Axiom from "./axiom";
+import Lemma from "./lemma";
+import Premise from "./premise";
+import Theorem from "./theorem";
 import MetaType from "./metaType";
+import Variable from "./variable";
 import Statement from "./statement";
 import ProofStep from "./proofStep";
+import Consequent from "./consequent";
+import Conjecture from "./conjecture";
+import Combinator from "./combinator";
+import Conclusion from "./conclusion";
+import Constructor from "./constructor";
+import Supposition from "./supposition";
+import Metatheorem from "./metatheorem";
+import Metavariable from "./metavariable";
+import UnqualifiedStatement from "./statement/unqualified";
 
 export { default as Log } from "./log";
-export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
+export { default as releaseUtilities } from "./utilities/release";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
 export { default as releaseContextUtilities } from "./utilities/releaseContext";

package/src/judgement.js

@@ -96,12 +96,12 @@ export default class Judgement {
     localContext.trace(`Verifying the '${judgementString}' judgement when derived...`);
 
     const reference = this.declaration.getReference(),
-          metatheorem = localContext.findMetatheoremByReference(reference),
           metaLemma = localContext.findMetaLemmaByReference(reference),
+          metatheorem = localContext.findMetatheoremByReference(reference),
           metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
     if (metaLemmaMetatheorem !== null) {
-      const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
+      const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext);
 
       verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
     }

package/src/label.js

@@ -1,12 +1,15 @@
 "use strict";
 
+import shim from "./shim";
+import LocalContext from "./context/local";
 import Metavariable from "./metavariable";
 
 import { nodeQuery } from "./utilities/query";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
 
 const metavariableNodeQuery = nodeQuery("//label/metavariable");
 
-export default class Label {
+class Label {
   constructor(metavariable) {
     this.metavariable = metavariable;
   }
@@ -43,7 +46,7 @@ export default class Label {
   }
 
   toJSON() {
-    const metavariableJSON = this.metavariable.toJSON(),
+    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///
           json = {
             metavariable
@@ -53,22 +56,24 @@ export default class Label {
   }
 
   static fromJSON(json, fileContext) {
-    let { metavariable } = json;
-
-    json = metavariable;  ///
-
-    metavariable = Metavariable.fromJSON(json, fileContext);
-
-    const label = new Label(metavariable);
+    const metavariable = metavariableFromJSON(json, fileContext),
+          label = new Label(metavariable);
 
     return label;
   }
 
   static fromLabelNode(labelNode, fileContext) {
     const metavariableNode = metavariableNodeQuery(labelNode),
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, fileContext),
+          localContext = LocalContext.fromFileContext(fileContext),
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           label = new Label(metavariable);
 
     return label;
   }
 }
+
+Object.assign(shim, {
+  Label
+});
+
+export default Label;

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/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;