occam-verify-cli 0.0.1067 → 0.0.1068

package/src/assertion/defined.js

@@ -56,7 +56,7 @@ export default class DefinedAssertion {
     }
 
     if (this.frame!== null) {
-      frameVerified = this.frame.verify(localContext);
+      frameVerified = this.frame.verify(assignments, stated, localContext);
     }
 
     if (termVerified && frameVerified) {

package/src/assignment/judgement.js

@@ -11,13 +11,12 @@ export default class JudgementAssignment {
 
   assign(localContext) {
     const judgementAdded = localContext.addJudgement(this.judgement),
-          judgementNode = this.judgement.getNode(),
-          judgementString = localContext.nodeAsString(judgementNode),
+          judgementString = this.judgement.getString(),
           judgementAssigned = judgementAdded; ///
 
     judgementAssigned ?
-      localContext.trace(`Assigned the '${judgementString}' judgement.`, judgementNode) :
-        localContext.debug(`Unable to assign the '${judgementString}' judgement.`, judgementNode);
+      localContext.trace(`Assigned the '${judgementString}' judgement.`) :
+        localContext.debug(`Unable to assign the '${judgementString}' judgement.`);
 
     return judgementAssigned;
   }

package/src/conclusion.js

@@ -31,18 +31,18 @@ export default class Conclusion {
     const statementString = statement.getString(),
           conclusionString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
-
-    const localContextB = localContext;
+    const localContextB = localContext; ///
 
     localContext = LocalContext.fromFileContext(this.fileContext);
 
     const localContextA = localContext; ///
 
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+
     statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
     return statementUnified;

package/src/consequent.js

@@ -31,18 +31,18 @@ export default class Consequent {
     const statementString = statement.getString(),
           consequentString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
-
-    const localContextB = localContext;
+    const localContextB = localContext; ///
 
     localContext = LocalContext.fromFileContext(this.fileContext);
 
     const localContextA = localContext; ///
 
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
+
     statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
     }
 
     return statementUnified;

package/src/declaration.js

@@ -1,13 +1,24 @@
 "use strict";
 
-import { stripBracketsFromStatement } from "./utilities/brackets";
+import shim from "./shim";
+import Reference from "./reference";
+
+import { nodeQuery } from "./utilities/query";
+
+const referenceNodeQuery = nodeQuery("/declaration/reference"),
+      statementNodeQuery = nodeQuery("/declaration/statement");
 
 export default class Declaration {
-  constructor(reference, statement) {
+  constructor(string, reference, statement) {
+    this.string = string;
     this.reference = reference;
     this.statement = statement;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getReference() {
     return this.reference;
   }
@@ -16,8 +27,6 @@ export default class Declaration {
     return this.statement;
   }
 
-  // getMetavariableNode() { return this.reference.getMetavariableNode(); }
-  //
   // unifyStatement(statementNode) {
   //   statementNode = stripBracketsFromStatement(statementNode); ///
   //
@@ -59,4 +68,48 @@ export default class Declaration {
   //
   //   return declaration;
   // }
+
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    const declarationString = this.string;  ///
+
+    localContext.trace(`Verifying the '${declarationString}' declaration...`);
+
+    stated = true;
+
+    assignments = null;
+
+    const referenceVerified = this.reference.verify(localContext);
+
+    if (referenceVerified) {
+      const statementVerified = this.statement.verify(assignments, stated, localContext);
+
+      verified = statementVerified; ///
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${declarationString}' declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromDeclarationNode(declarationNode, localContext) {
+    let declaration = null;
+
+    if (declarationNode !== null) {
+      const { Statement } = shim,
+            referenceNode = referenceNodeQuery(declarationNode),
+            statementNode = statementNodeQuery(declarationNode),
+            reference = Reference.fromReferenceNode(referenceNode, localContext),
+            statement = Statement.fromStatementNode(statementNode, localContext),
+            node = declarationNode,  ///
+            string = localContext.nodeAsString(node);
+
+      declaration = new Declaration(string, reference, statement);
+    }
+
+    return declaration;
+  }
 }

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;
   }
@@ -44,24 +54,25 @@ class Frame {
     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;
-  // }
-  //
+  getMetavariableNode() {
+    let metavariableNode = null;
+
+    const declarationsLength = this.declarations.length;
+
+    if (declarationsLength === 0) {
+      const metavariablesLength = this.metavariables.length;
+
+      if (metavariablesLength === 1) {
+        const firstMetavariable = first(this.metavariables),
+              metavariable = firstMetavariable; ///
+
+        metavariableNode = metavariable.getNode();
+      }
+    }
+
+    return metavariableNode;
+  }
+
   // matchMetavariableName(metavariableName) {
   //   let metavariableNameMatches = false;
   //
@@ -106,15 +117,75 @@ class Frame {
   //   return metaLemmaOrMetaTheoremUnified;
   // }
 
-  verify(localContext) {
+  verify(assignments, stated, localContext) {
     let verified;
 
     const frameString = this.string;  ///
 
     localContext.trace(`Verifying the '${frameString}' frame...`);
 
+    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 '${frameString}' frame.`);
+    }
+
+    return verified;
+  }
+
+  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) {
+        const firstMetavariable = first(this.metavariables),
+              metavariable = firstMetavariable, ///
+              metavariableVerified = metavariable.verify(localContext);
+
+        verifiedWhenStated = metavariableVerified;  ///
+      } 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...`);
+
     const declarationsVerified = this.declarations.every((declaration) => {
-      const declarationVerified = declaration.verify(localContext);
+      const declarationVerified = declaration.verify(assignments, stated, localContext);
 
       return declarationVerified;
     });
@@ -126,17 +197,17 @@ class Frame {
         return metavariableVerified;
       });
 
-      verified = metavariablesVerified; ///
+      verifiedWhenDerived = metavariablesVerified; ///
     }
 
-    if (verified) {
-      localContext.debug(`...verified the '${frameString}' frame.`);
+    if (verifiedWhenDerived) {
+      localContext.debug(`...verified the '${frameString}' frame when derived.`);
     }
 
-    return verified;
+    return verifiedWhenDerived;
   }
 
-  verifyGivenMetaType(metaType, localContext) {
+  verifyGivenMetaType(metaType, assignments, stated, localContext) {
     let verifiedGivenMetaType = false;
 
     const frameString = this.string,  ///
@@ -147,7 +218,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 +231,26 @@ class Frame {
   }
 
   static fromFrameNode(frameNode, localContext) {
-    const declarationNodes = declarationNodesQuery(frameNode),
-          metavariableNodes = metavariableNodesQuery(frameNode),
-          declarations = declarationNodes.map((declarationNode) => {
-            const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
-
-            return declaration;
-          }),
-          metavariables = metavariableNodes.map((metavariableNode) => {
-            const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
-
-            return metavariable;
-          }),
-          node = frameNode, ///
-          string = localContext.nodeAsString(node),
-          frame = new Frame(string, declarations, metavariables);
+    let frame = null;
+
+    if (frameNode !== null) {
+      const declarationNodes = declarationNodesQuery(frameNode),
+            metavariableNodes = metavariableNodesQuery(frameNode),
+            declarations = declarationNodes.map((declarationNode) => {
+              const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
+
+              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 +258,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 +282,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);
+
+      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;
   }
-
-  // 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/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(),
+          metatheorem = localContext.findMetatheoremByReference(reference),
+          metaLemma = localContext.findMetaLemmaByReference(reference),
+          metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+    if (metaLemmaMetatheorem !== null) {
+      const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
+
+      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/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;
+}