occam-verify-cli 0.0.1059 → 0.0.1063

package/src/frame.js

@@ -1,107 +1,252 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
+import shim from "./shim";
+import Declaration from "./declaration";
+import Metavariable from "./metavariable";
 
-import { metavariableNameFromMetavariableNode } from "./utilities/name";
+import { FRAME_META_TYPE_NAME } from "./metaTypeNames";
+import { nodeQuery, nodesQuery } from "./utilities/query";
 
-const { first } = arrayUtilities;
+const declarationNodesQuery = nodesQuery("/frame/declaration"),
+      metavariableNodesQuery = nodesQuery("/frame/metavariable"),
+      frameMetavariableNodeQuery = nodeQuery("/*/frame/metavariable!");
 
-export default class Frame {
-  constructor(declarations, metavariableNodes) {
+class Frame {
+  constructor(string, declarations, metavariables) {
+    this.string = string;
     this.declarations = declarations;
-    this.metavariableNodes = metavariableNodes;
+    this.metavariables = metavariables;
+  }
+
+  getString() {
+    return this.string;
   }
 
   getDeclarations() {
     return this.declarations;
   }
 
-  getMetavariableNodes() {
-    return this.metavariableNodes;
+  getMetavariables() {
+    return this.metavariables;
   }
 
-  getMetavariableNode() {
-    let metavariableNode = null;
+  getMetavariable() {
+    let metavariable;
 
-    const declarationsLength = this.declarations.length;
+    const metavariablesLength = this.metavariables.length;
 
-    if (declarationsLength === 0) {
-      const metavariableNodesLength = this.metavariableNodes.length;
+    if (metavariablesLength === 1) {
+      const firstMetavariable = first(this.metavariables);
 
-      if (metavariableNodesLength === 1) {
-        const firstMetavariableNode = first(this.metavariableNodes);
-
-        metavariableNode = firstMetavariableNode; ///
-      }
+      metavariable = firstMetavariable; ///
     }
 
-    return metavariableNode;
+    return metavariable;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
-
-    const metavariableNode = this.getMetavariableNode();
+  // 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) {
+    let verified;
+
+    const frameString = this.string;  ///
+
+    localContext.trace(`Verifying the '${frameString}' frame...`);
+
+    const declarationsVerified = this.declarations.every((declaration) => {
+      const declarationVerified = declaration.verify(localContext);
+
+      return declarationVerified;
+    });
 
-    if (metavariableNode !== null) {
-      const name = metavariableName;  ///
+    if (declarationsVerified) {
+      const metavariablesVerified = this.metavariables.every((metavariable) => {
+        const metavariableVerified = metavariable.verify(localContext);
 
-      metavariableName = metavariableNameFromMetavariableNode(metavariableNode);  ///
+        return metavariableVerified;
+      });
 
-      const nameMatchesMetavariableName = (name === metavariableName);
+      verified = metavariablesVerified; ///
+    }
 
-      metavariableNameMatches = nameMatchesMetavariableName;  ///
+    if (verified) {
+      localContext.debug(`...verified the '${frameString}' frame.`);
     }
 
-    return metavariableNameMatches;
+    return verified;
   }
 
-  unifySubstitution(substitution) {
-    const substitutionUnified = this.declarations.some((declaration) => {
-      const substitutionUnifiedWithDeclaration = declaration.unifySubstitution(substitution);
+  verifyGivenMetaType(metaType, localContext) {
+    let verifiedGivenMetaType = false;
 
-      if (substitutionUnifiedWithDeclaration) {
-        return true;
-      }
-    });
+    const frameString = this.string,  ///
+          metaTypeString = metaType.getString();
 
-    return substitutionUnified;
-  }
+    localContext.trace(`Verifying the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
-  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) {
-    const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          substitutionsUnified = substitutions.everySubstitution((substitution) => {
-            const substitutionUnified = this.unifySubstitution(substitution);
+    const metaTypeName = metaType.getName();
 
-            if (substitutionUnified) {
-              return true;
-            }
-          }),
-          metaLemmaOrMetaTheoremUnified = substitutionsUnified; ///
+    if (metaTypeName === FRAME_META_TYPE_NAME) {
+      const verified = this.verify(localContext)
+
+      verifiedGivenMetaType = verified; ///
+    }
 
-    return metaLemmaOrMetaTheoremUnified;
+    if (verifiedGivenMetaType) {
+      localContext.debug(`...verified the '${frameString}' frame given the '${metaTypeString}' meta-type.`);
+    }
+
+    return verifiedGivenMetaType;
   }
 
-  static fromDeclarations(declarations) {
-    const metavariableNodes = [],
-          frame = new Frame(declarations, metavariableNodes);
+  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);
 
     return frame;
   }
 
-  static fromMetavariableNode(metavariableNode) {
-    const declarations = [],
-          metavariableNodes = [
-            metavariableNode
-          ],
-          frame = new Frame(declarations, metavariableNodes);
+  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+    let frame = null;
+
+    const frameMetavariableNode = frameMetavariableNodeQuery(definedAssertionNode);
+
+    if (frameMetavariableNode !== null) {
+      const metavariableNode = frameMetavariableNode, ///
+            metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+            declarations = [],
+            metavariables = [
+              metavariable
+            ],
+            node = metavariableNode,  ///
+            string = localContext.nodeAsString(node);
+
+      frame = new Frame(string, declarations, metavariables);
+    }
 
     return frame;
   }
 
-  static fromDeclarationsAndMetavariableNodes(declarations, metavariableNodes) {
-    const frame = new Frame(declarations, metavariableNodes);
+  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+    let frame = null;
+
+    const frameMetavariableNode = frameMetavariableNodeQuery(containedAssertionNode);
+
+    if (frameMetavariableNode !== null) {
+      const metavariableNode = frameMetavariableNode, ///
+            metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+            declarations = [],
+            metavariables = [
+              metavariable
+            ],
+            node = metavariableNode,  ///
+            string = localContext.nodeAsString(node);
+
+      frame = new Frame(string, 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, {
+  Frame
+});
+
+export default Frame;

package/src/metavariable.js

@@ -3,6 +3,7 @@
 import shim from "./shim";
 import Argument from "./argument";
 import LocalContext from "./context/local";
+import metavariableUnifier from "./unifier/metavariable";
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
@@ -14,7 +15,7 @@ const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export default class Metavariable {
+class Metavariable {
   constructor(fileContext, string, node, name, metaType) {
     this.fileContext = fileContext;
     this.string = string;
@@ -62,13 +63,25 @@ export default class Metavariable {
   }
 
   verify(localContext) {
-    let verified = false;
+    let verified;
 
     const metavariableString = this.string; ///
 
     localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
 
-    debugger
+    const metavariableName = this.name,
+          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+    if (metavariable !== null) {
+      const metavariableA = metavariable, ///
+            metavariableB = this,
+            metavariableNodeA = metavariableA.getNode(), ///
+            metavariableNodeB = metavariableB.getNode(),
+            metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+      verified = metavariableUnified; ///
+
+    }
 
     if (verified) {
       localContext.debug(`...verified the '${metavariableString}' metavariable.`);
@@ -116,7 +129,7 @@ export default class Metavariable {
     let statementUnified = false;
 
     const statementString = statement.getString(),
-          metavariableString = this.string;
+          metavariableString = this.string; ///
 
     localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
 
@@ -159,7 +172,7 @@ export default class Metavariable {
 
     const statementString = statement.getString(),
           substitutionString = substitution.getString(),
-          metavariableString = this.string;
+          metavariableString = this.string; ///
 
     localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution...`);
 
@@ -230,12 +243,17 @@ export default class Metavariable {
   }
 
   static fromMetavariableNode(metavariableNode, fileContext) {
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          node = metavariableNode,  ///
-          name = metavariableName,  ///
-          string = fileContext.nodeAsString(node),
-          metaType = null,
-          metavariable = new Metavariable(fileContext, string, node, name, metaType);
+    let metavariable = null;
+
+    if (metavariableNode !== null) {
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            node = metavariableNode,  ///
+            name = metavariableName,  ///
+            string = fileContext.nodeAsString(node),
+            metaType = null;
+
+      metavariable = new Metavariable(fileContext, string, node, name, metaType);
+    }
 
     return metavariable;
   }
@@ -257,6 +275,12 @@ export default class Metavariable {
   }
 }
 
+Object.assign(shim, {
+  Metavariable
+});
+
+export default Metavariable;
+
 function metaTypeFromJSON(json, fileContext) {
   let { metaType } = json;
 

package/src/mixins/statement/verify.js

@@ -1,18 +1,18 @@
 "use strict";
 
 import Equality from "../../equality";
+import Metavariable from "../../metavariable";
 import TypeAssertion from "../../assertion/type";
+import DefinedAssertion from "../../assertion/defined";
+import SubproofAssertion from "../../assertion/subproof";
+import ContainedAssertion from "../../assertion/contained";
+import StatementSubstitution from "../../substitution/statement";
 
 import verifyFrame from "../../verify/frame";
 import verifyJudgement from "../../verify/judgement";
 import verifyDeclaration from "../../verify/declaration";
-import metavariableUnifier from "../../unifier/metavariable";
-import verifyDefinedAssertion from "../../verify/assertion/defined";
-import verifyContainedAssertion from "../../verify/assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../../utilities/name";
-import SubproofAssertion from "../../assertion/subproof";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
@@ -28,16 +28,29 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
   let verifiedAsMetavariable = false;
 
   const statementNode = statement.getNode(),
-        metavariableNode = metavariableNodeQuery(statementNode);
+        metavariableNode = metavariableNodeQuery(statementNode),
+        metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
 
-  if (metavariableNode !== null) {
+  if (metavariable !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`);
 
-    const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
+    const metavariableVerified = metavariable.verify(localContext);
+
+    if (metavariableVerified) {
+      let substitutionVerified = true;
+
+      const statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext);
+
+      if (statementSubstitution !== null) {
+        const statementSubstitutionVerified = statementSubstitution.verify(assignments, stated, localContext);
 
-    verifiedAsMetavariable = metavariableUnified;  ///
+        substitutionVerified = statementSubstitutionVerified; ///
+      }
+
+      verifiedAsMetavariable = substitutionVerified; ///
+    }
 
     if (verifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`);
@@ -168,14 +181,15 @@ function verifyAsDefinedAssertion(statement, assignments, stated, localContext)
   let verifiedAsDefinedAssertion = false;
 
   const statementNode = statement.getNode(),
-        definedAssertionNode = definedAssertionNodeQuery(statementNode);
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, localContext);
 
-  if (definedAssertionNode !== null) {
+  if (definedAssertion !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
 
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext);
+    const definedAssertionVerified = definedAssertion.verify(assignments, stated, localContext);
 
     verifiedAsDefinedAssertion = definedAssertionVerified; ///
 
@@ -215,14 +229,15 @@ function verifyAsContainedAssertion(statement, assignments, stated, localContext
   let verifiedAsContainedAssertion = false;
 
   const statementNode = statement.getNode(),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+        containedAssertionNode = containedAssertionNodeQuery(statementNode),
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
 
-  if (containedAssertionNode !== null) {
+  if (containedAssertion !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, stated, localContext);
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
 
     verifiedAsContainedAssertion = containedAssertionVerified; ///
 
@@ -247,30 +262,3 @@ const verifyMixins = [
 ];
 
 export default verifyMixins;
-
-function unifyMetavariable(metavariableNode, localContext) {
-  let metavariableUnified;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Unifying the '${metavariableString}' metavariable...`);
-
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-  if (metavariable !== null) {
-    const metavariableNodeA = metavariableNode; ///
-
-    metavariableNode = metavariable.getNode();
-
-    const metavariableNodeB = metavariableNode; ///
-
-    metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-  }
-
-  if (metavariableUnified) {
-    localContext.debug(`...unified the '${metavariableString}' metavariable.`);
-  }
-
-  return metavariableUnified;
-}

package/src/statement.js

@@ -6,9 +6,14 @@ import verifyMixins from "./mixins/statement/verify";
 import StatementSubstitution from "./substitution/statement";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
+import { nodeQuery, nodesQuery } from "./utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 import { statementNodeFromStatementString } from "./utilities/node";
 
+const statementNodeQuery = nodeQuery("/*//statement"),
+      statementVariableNodesQuery = nodesQuery("/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
+
 class Statement {
   constructor(string, node, substitution) {
     this.string = string;
@@ -36,6 +41,60 @@ class Statement {
     return equalTo;
   }
 
+  isVariableContained(variable, localContext) {
+    let variableContained;
+
+    const variableString = variable.getString(),
+          statementString = this.string;  ///
+
+    localContext.trace(`The '${variableString}' variable is contained in hte '${statementString}' statement...`);
+
+    const variableNode = variable.getNode(),
+          statementNode = this.node,
+          statementVariableNodes = statementVariableNodesQuery(statementNode);
+
+    variableContained = statementVariableNodes.some((statementVariableNode) => {  ///
+      const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+      if (variableNodeMatchesStatementVariableNode) {
+        return true;
+      }
+    });
+
+    if (variableContained) {
+      localContext.debug(`...the '${variableString}' variable is contained in hte '${statementString}' statement.`);
+    }
+
+    return variableContained;
+  }
+
+  isMetavariableContained(metavariable, localContext) {
+    let metavariableContained;
+
+    const metavariableString = metavariable.getString(),
+          statementString = this.string;  ///
+
+    localContext.trace(`The '${metavariableString}' metavariable is contained in hte '${statementString}' statement...`);
+
+    const metavariableNode = metavariable.getNode(),
+          statementNode = this.node,
+          statementMetavariableNodes = statementMetavariableNodesQuery(statementNode);
+
+    metavariableContained = statementMetavariableNodes.some((statementMetavariableNode) => {  ///
+      const metavariableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+
+      if (metavariableNodeMatchesStatementMetavariableNode) {
+        return true;
+      }
+    });
+
+    if (metavariableContained) {
+      localContext.debug(`...the '${metavariableString}' metavariable is contained in hte '${statementString}' statement.`);
+    }
+
+    return metavariableContained;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -96,7 +155,7 @@ class Statement {
     const metaTypeString = metaType.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' given the '${metaTypeString}' meta-type...`);
+    localContext.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
@@ -107,7 +166,7 @@ class Statement {
     }
 
     if (verifiedGivenMetaType) {
-      localContext.debug(`...verified the '${statementString}' given the '${metaTypeString}' meta-type.`);
+      localContext.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
     return verifiedGivenMetaType;
@@ -162,13 +221,35 @@ class Statement {
 
     return statement;
   }
+
+  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+    const statementNode = statementNodeQuery(definedAssertionNode),
+          node = statementNode, ///
+          string = localContext.nodeAsString(node),
+          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
+          substitution = statementSubstitution, ///
+          statement = new Statement(string, node, substitution);
+
+    return statement;
+  }
+
+  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+    const statementNode = statementNodeQuery(containedAssertionNode),
+          node = statementNode, ///
+          string = localContext.nodeAsString(node),
+          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
+          substitution = statementSubstitution, ///
+          statement = new Statement(string, node, substitution);
+
+    return statement;
+  }
 }
 
+Object.assign(Statement.prototype, unifyMixins);
+
 Object.assign(shim, {
   Statement
 });
 
-Object.assign(Statement.prototype, unifyMixins);
-
 export default Statement;