occam-verify-cli 0.0.1061 → 0.0.1065

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";
@@ -12,9 +13,9 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/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,42 +172,40 @@ export default class Metavariable {
 
     const statementString = statement.getString(),
           substitutionString = substitution.getString(),
-          metavariableString = this.string;
-
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution...`);
-
-    // let metavariableUnifiedWithStatementGivenSubstitution = false;
-    //
-    // const metavariableNode = metavariable.getNode(),
-    //   substitutionNode = substitution.getNode(),
-    //   complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-    //
-    // if (complexSubstitution !== null) {
-    //   const statementNode = statement.getNode(),
-    //     statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
-    //
-    //   if (statementNodeMatches) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // } else {
-    //   const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNode),
-    //     metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
-    //     metavariableB = metavariableFromStatementNode(statement, localContextB);
-    //
-    //   if (metavariableA === metavariableB) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = false;  ///
-    //   } else {
-    //     const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContextA, localContextB),
-    //       substitution = statementForMetavariableSubstitution;  ///
-    //
-    //     substitutions.addSubstitution(substitution, localContextA, localContextB);
-    //
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // }
+          metavariableString = this.string; ///
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          substitutionNode = substitution.getNode(),
+          complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+
+    if (complexSubstitution !== null) {
+      const statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnifiedGivenSubstitution = true;
+      }
+    } else {
+      const metavariable = metavariableFromStatementNode(statementNode, localContext);
+
+      if (this === metavariable) {  ///
+        statementUnifiedGivenSubstitution = false;  ///
+      } else {
+        const metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+        substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnifiedGivenSubstitution = true;
+      }
+    }
 
     if (statementUnifiedGivenSubstitution) {
-      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution.`);
+      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution.`);
     }
 
     return statementUnifiedGivenSubstitution;
@@ -230,12 +241,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 +273,12 @@ export default class Metavariable {
   }
 }
 
+Object.assign(shim, {
+  Metavariable
+});
+
+export default Metavariable;
+
 function metaTypeFromJSON(json, fileContext) {
   let { metaType } = json;
 
@@ -270,6 +292,21 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
+function metavariableFromStatementNode(statementNode, localContext) {
+  let metavariable = null;
+
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode, ///
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
+
+    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  }
+
+  return metavariable;
+}
+
 function statementMetavariableFromStatementNode(statementNode, localContext) {
   let statementMetavariable = null;
 

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/premise.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -80,26 +78,15 @@ export default class Premise {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const premise = this, ///
-          statementString = statement.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the premise's '${premiseStatementString}' statement...`);
+    const statementString = statement.getString(),
+          premiseString = this.getString();
 
-    const statementNode = statement.getNode(),
-          premiseStatementNode = premiseStatement.getNode(),
-          nodeA = premiseStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the premise's '${premiseStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;