occam-verify-cli 0.0.1067 → 0.0.1069

package/src/frame.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "./shim";
 import Declaration from "./declaration";
 import Metavariable from "./metavariable";
@@ -7,13 +9,17 @@ import Metavariable from "./metavariable";
 import { FRAME_META_TYPE_NAME } from "./metaTypeNames";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 
-const declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodesQuery = nodesQuery("/frame/metavariable"),
-      frameMetavariableNodeQuery = nodeQuery("/*/frame/metavariable!");
+const frameNodeQuery = nodeQuery("/*/frame"),
+      declarationNodesQuery = nodesQuery("/frame/declaration"),
+      metavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      metavariableNodesQuery = nodesQuery("/frame/metavariable");
+
+const { first } = arrayUtilities;
 
 class Frame {
-  constructor(string, declarations, metavariables) {
+  constructor(string, node, declarations, metavariables) {
     this.string = string;
+    this.node = node;
     this.declarations = declarations;
     this.metavariables = metavariables;
   }
@@ -22,6 +28,10 @@ class Frame {
     return this.string;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getDeclarations() {
     return this.declarations;
   }
@@ -31,82 +41,113 @@ class Frame {
   }
 
   getMetavariable() {
-    let metavariable;
+    let metavariable = null;
+
+    const declarationsLength = this.declarations.length;
 
-    const metavariablesLength = this.metavariables.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;
   }
 
-  // getMetavariableNode() {
-  //   let metavariableNode = null;
-  //
-  //   const declarationsLength = this.declarations.length;
-  //
-  //   if (declarationsLength === 0) {
-  //     const metavariableNodesLength = this.metavariableNodes.length;
-  //
-  //     if (metavariableNodesLength === 1) {
-  //       const firstMetavariableNode = first(this.metavariableNodes);
-  //
-  //       metavariableNode = firstMetavariableNode; ///
-  //     }
-  //   }
-  //
-  //   return metavariableNode;
-  // }
-  //
-  // 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;
-  // }
-
-  verify(localContext) {
+  getMetavariableNode() {
+    let metavariableNode = null;
+
+    const metavariable = this.getMetavariable();
+
+    if (metavariable !== null) {
+      metavariableNode = metavariable.getNode();
+    }
+
+    return metavariableNode;
+  }
+
+  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 metavariableNameMatches;
+  }
+
+  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;
 
     const frameString = this.string;  ///
@@ -114,19 +155,29 @@ class Frame {
     localContext.trace(`Verifying the '${frameString}' frame...`);
 
     const declarationsVerified = this.declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(localContext);
+            const declarationVerified = declaration.verify(assignments, stated, localContext);
 
-      return declarationVerified;
-    });
+            return declarationVerified;
+          }),
+          metavariablesVerified = this.metavariables.every((metavariable) => {
+            const metavariableVerified = metavariable.verify(localContext);
 
-    if (declarationsVerified) {
-      const metavariablesVerified = this.metavariables.every((metavariable) => {
-        const metavariableVerified = metavariable.verify(localContext);
+            return metavariableVerified;
+          });
 
-        return metavariableVerified;
-      });
+    if (declarationsVerified && metavariablesVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
 
-      verified = metavariablesVerified; ///
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
+      }
+
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        verified = true;
+      }
     }
 
     if (verified) {
@@ -136,7 +187,52 @@ class Frame {
     return verified;
   }
 
-  verifyGivenMetaType(metaType, localContext) {
+  verifyWhenStated(assignments, localContext) {
+    let verifiedWhenStated = false;
+
+    const frameString = this.string;  ///
+
+    localContext.trace(`Verifying the '${frameString}' frame when stated...`);
+
+    const declarationsLength = this.declarations.length;
+
+    if (declarationsLength === 0) {
+      const metavariablesLength = this.metavariables.length;
+
+      if (metavariablesLength === 1) {
+        verifiedWhenStated = true;
+      } else {
+        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
+      }
+    } else {
+      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
+    }
+
+
+    if (verifiedWhenStated) {
+      localContext.debug(`...verified the '${frameString}' frame when stated.`);
+    }
+
+    return verifiedWhenStated;
+  }
+
+  verifyWhenDerived(assignments, localContext) {
+    let verifiedWhenDerived;
+
+    const frameString = this.string;  ///
+
+    localContext.trace(`Verifying the '${frameString}' frame when derived...`);
+
+    verifiedWhenDerived = true;
+
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the '${frameString}' frame when derived.`);
+    }
+
+    return verifiedWhenDerived;
+  }
+
+  verifyGivenMetaType(metaType, assignments, stated, localContext) {
     let verifiedGivenMetaType = false;
 
     const frameString = this.string,  ///
@@ -147,7 +243,7 @@ class Frame {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const verified = this.verify(localContext)
+      const verified = this.verify(assignments, stated, localContext)
 
       verifiedGivenMetaType = verified; ///
     }
@@ -160,21 +256,26 @@ class Frame {
   }
 
   static fromFrameNode(frameNode, localContext) {
-    const declarationNodes = declarationNodesQuery(frameNode),
-          metavariableNodes = metavariableNodesQuery(frameNode),
-          declarations = declarationNodes.map((declarationNode) => {
-            const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
+    let frame = null;
 
-            return declaration;
-          }),
-          metavariables = metavariableNodes.map((metavariableNode) => {
-            const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
+    if (frameNode !== null) {
+      const declarationNodes = declarationNodesQuery(frameNode),
+            metavariableNodes = metavariableNodesQuery(frameNode),
+            declarations = declarationNodes.map((declarationNode) => {
+              const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
 
-            return metavariable;
-          }),
-          node = frameNode, ///
-          string = localContext.nodeAsString(node),
-          frame = new Frame(string, declarations, metavariables);
+              return declaration;
+            }),
+            metavariables = metavariableNodes.map((metavariableNode) => {
+              const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
+
+              return metavariable;
+            }),
+            node = frameNode, ///
+            string = localContext.nodeAsString(node);
+
+      frame = new Frame(string, node, declarations, metavariables);
+    }
 
     return frame;
   }
@@ -182,19 +283,22 @@ class Frame {
   static fromDefinedAssertionNode(definedAssertionNode, localContext) {
     let frame = null;
 
-    const frameMetavariableNode = frameMetavariableNodeQuery(definedAssertionNode);
+    const frameNode = frameNodeQuery(definedAssertionNode);
 
-    if (frameMetavariableNode !== null) {
-      const metavariableNode = frameMetavariableNode, ///
-            metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-            declarations = [],
-            metavariables = [
-              metavariable
-            ],
-            node = metavariableNode,  ///
-            string = localContext.nodeAsString(node);
+    if (frameNode !== null) {
+      const metavariableNode = metavariableNodeQuery(frameNode);
+
+      if (metavariableNode !== null) {
+        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              declarations = [],
+              metavariables = [
+                metavariable
+              ],
+              node = frameNode,  ///
+              string = localContext.nodeAsString(node);
 
-      frame = new Frame(string, declarations, metavariables);
+        frame = new Frame(string, node, declarations, metavariables);
+      }
     }
 
     return frame;
@@ -203,46 +307,26 @@ class Frame {
   static fromContainedAssertionNode(containedAssertionNode, localContext) {
     let frame = null;
 
-    const frameMetavariableNode = frameMetavariableNodeQuery(containedAssertionNode);
+    const frameNode = frameNodeQuery(containedAssertionNode);
 
-    if (frameMetavariableNode !== null) {
-      const metavariableNode = frameMetavariableNode, ///
-            metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-            declarations = [],
-            metavariables = [
-              metavariable
-            ],
-            node = metavariableNode,  ///
-            string = localContext.nodeAsString(node);
+    if (frameNode !== null) {
+      const metavariableNode = metavariableNodeQuery(frameNode);
 
-      frame = new Frame(string, declarations, metavariables);
+      if (metavariableNode !== null) {
+        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              declarations = [],
+              metavariables = [
+                metavariable
+              ],
+              node = frameNode,  ///
+              string = localContext.nodeAsString(node);
+
+        frame = new Frame(string, node, declarations, metavariables);
+      }
     }
 
     return frame;
   }
-
-  // static fromDeclarations(declarations) {
-  //   const metavariableNodes = [],
-  //         frame = new Frame(declarations, metavariableNodes);
-  //
-  //   return frame;
-  // }
-  //
-  // static fromMetavariableNode(metavariableNode) {
-  //   const declarations = [],
-  //         metavariableNodes = [
-  //           metavariableNode
-  //         ],
-  //         frame = new Frame(declarations, metavariableNodes);
-  //
-  //   return frame;
-  // }
-  //
-  // static fromDeclarationsAndMetavariableNodes(declarations, metavariableNodes) {
-  //   const frame = new Frame(declarations, metavariableNodes);
-  //
-  //   return frame;
-  // }
 }
 
 Object.assign(shim, {

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

@@ -1,11 +1,25 @@
 "use strict";
 
+import Frame from "./frame";
+import Declaration from "./declaration";
+import JudgementAssignment from "./assignment/judgement";
+
+import { nodeQuery } from "./utilities/query";
+
+const frameNodeQuery = nodeQuery("/judgement/frame"),
+      declarationNodeQuery = nodeQuery("/judgement/declaration");
+
 export default class Judgement {
-  constructor(frame, declaration) {
+  constructor(string, frame, declaration) {
+    this.string = string;
     this.frame = frame;
     this.declaration = declaration;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getFrame() {
     return this.frame;
   }
@@ -18,8 +32,100 @@ export default class Judgement {
 
   matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
 
-  static fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration) {
-    const judgement = new Judgement(frame, declaration);
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    const judgementString = this.string;  ///
+
+    localContext.trace(`Verifying the '${judgementString}' judgement...`);
+
+    const frameVerified = this.frame.verify(assignments, stated, localContext),
+          declarationVerified = this.declaration.verify(assignments, stated, localContext);
+
+    if (frameVerified && 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 (verified) {
+      localContext.debug(`...verified the '${judgementString}' judgement.`);
+    }
+
+    return verified;
+  }
+
+  verifyWhenStated(assignments, localContext) {
+    let verifiedWhenStated;
+
+    const judgementString = this.string;  ///
+
+    localContext.trace(`Verifying the '${judgementString}' judgement when stated...`);
+
+    if (assignments !== null) {
+      const judgement = this, ///
+            judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+            assignment = judgementAssignment;
+
+      assignments.push(assignment);
+    }
+
+    verifiedWhenStated = true;
+
+    if (verifiedWhenStated) {
+      localContext.debug(`...verified the '${judgementString}' judgement when stated.`);
+    }
+
+    return verifiedWhenStated;
+  }
+
+  verifyWhenDerived(assignments, localContext) {
+    let verifiedWhenDerived;
+
+    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 (metaLemmaMetatheorem !== null) {
+      const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext);
+
+      verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
+    }
+
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the '${judgementString}' judgement when derived.`);
+    }
+
+    return verifiedWhenDerived;
+  }
+
+  static fromJudgementNode(judgementNode, localContext) {
+    let judgement = null;
+
+    if (judgementNode !== null) {
+      const frameNode = frameNodeQuery(judgementNode),
+            declarationNode = declarationNodeQuery(judgementNode),
+            node = judgementNode, ///
+            string = localContext.nodeAsString(node),
+            frame = Frame.fromFrameNode(frameNode, localContext),
+            declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
+
+      judgement = new Judgement(string, frame, declaration);
+    }
 
     return judgement;
   }

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;