occam-verify-cli 0.0.960 → 0.0.962

package/src/unify/statementWithMetaType.js

@@ -1,50 +1,14 @@
 "use strict";
 
-import shim from "../shim";
+import verifyStatementGivenMetaType from "../verify/statementGivenMetaType";
 
-import { nodeQuery } from "../utilities/query";
-import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+export default function unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext) {
+  let statementUnifiedWithMetaType;
 
-const metavariableNodeQuery = nodeQuery("/statement/metavariable"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
+  const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
+        statementVerifiedGivenMetaType = verifyStatementGivenMetaType(statementNode, metaType, assignments, derived, localContext);
 
-export default function unifyStatementWithMetaType(statementNode, metaTypeNode, localContext) {
-  let statementUnifiedWithMetaType = false;
-
-  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
-        metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
-        metaTypeName = metaTypeTerminalNodeContent; ///
-
-  switch (metaTypeName) {
-    case FRAME_META_TYPE_NAME: {
-      const metavariableNode = metavariableNodeQuery(statementNode);
-
-      if (metavariableNode !== null) {
-        const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-
-        if (metavariable !== null) {
-          const metavariableMetaTypeName = metavariable.getMetaTypeName();
-
-          if (metavariableMetaTypeName === metaTypeName) {
-            statementUnifiedWithMetaType = true;
-          }
-        }
-      }
-
-      break;
-    }
-
-    case STATEMENT_META_TYPE_NAME: {
-      const { verifyStatement } = shim,
-            derived = false,
-            assignments = [],
-            statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
-
-      statementUnifiedWithMetaType = statementVerified;
-
-      break;
-    }
-  }
+  statementUnifiedWithMetaType = statementVerifiedGivenMetaType;  ///
 
   return statementUnifiedWithMetaType;
 }

package/src/unify/termWithBracketedConstructor.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import shim from "../shim";
+import bracketedConstructor from "../constructor/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { unifyTermWithConstructor } from "../unify/termWithConstructors";
+
+const termNodeQuery = nodeQuery("/term/argument/term");
+
+export default function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithBracketedConstructor;
+
+  const termString = localContext.nodeAsString(termNode),
+        bracketedTerms = [];
+
+  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);
+
+  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
+    let verifiedAhead;
+
+    const bracketedTermNode = termNode; ///
+
+    termNode = termNodeQuery(bracketedTermNode); ///
+
+    const { verifyTerm } = shim,
+          termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+
+    verifiedAhead = termVVerified;  ///
+
+    return verifiedAhead;
+  });
+
+  if (termUnifiedWithBracketedConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);
+  }
+
+  return termUnifiedWithBracketedConstructor;
+}

package/src/unify/termWithConstructors.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import Term from "../term";
+import termWithConstructorUnifier from "../unifier/termWithConstructor";
+
+import { nodeQuery } from "../utilities/query";
+
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+export default function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithConstructors = false;
+
+  const variableNode = variableNodeQuery(termNode);
+
+  if (variableNode === null) {
+    const constructors = localContext.getConstructors();
+
+    termUnifiedWithConstructors = constructors.some((constructor) => {
+      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
+
+      if (termUnifiedWithConstructor) {
+        return true;
+      }
+    });
+  }
+
+  return termUnifiedWithConstructors;
+}
+
+export function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+  let termUnifiedWithConstructor = false;
+
+  const termString = localContext.nodeAsString(termNode),
+        constructorString = constructor.getString(),
+        constructorTermNode = constructor.getTermNode();
+
+  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
+
+  const termNodeA = termNode,  ///
+        constructorTermNodeB = constructorTermNode,  ///
+        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
+
+  if (unified) {
+    let verifiedAhead;
+
+    const type = constructor.getType(),
+          term = Term.fromTermNodeAndType(termNode, type);
+
+    terms.push(term);
+
+    verifiedAhead = verifyAhead();
+
+    terms.pop();
+
+    termUnifiedWithConstructor = verifiedAhead;  ///
+  }
+
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
+  }
+
+  return termUnifiedWithConstructor;
+}

package/src/unify/termWithType.js

@@ -1,31 +1,15 @@
 "use strict";
 
-import shim from "../shim";
-
-import { first } from "../utilities/array";
+import verifyTermGivenType from "../verify/termGivenType";
 
 export default function unifyTermWithType(termNode, typeNode, localContext) {
   let termUnifiedWithType;
 
-  const { verifyTerm } = shim,
-        terms = [],
-        termVerified = verifyTerm(termNode, terms, localContext, () => {
-          let verifiedAhead = false;
-
-          const firstTerm = first(terms),
-                term = firstTerm, ///
-                termType = term.getType(),
-                type = localContext.findTypeByTypeNode(typeNode),
-                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-
-          if (termTypeEqualToOrSubTypeOfType) {
-            verifiedAhead = true;
-          }
+  const type = localContext.findTypeByTypeNode(typeNode),
+        termVerifiedGivenType = verifyTermGivenType(termNode, type, localContext);
 
-          return verifiedAhead;
-        });
+  termUnifiedWithType = termVerifiedGivenType;  ///
 
-  termUnifiedWithType = termVerified; ///
 
   return termUnifiedWithType;
 }

package/src/utilities/assignments.js

@@ -1,18 +1,11 @@
 "use strict";
 
-import { first } from "../utilities/array";
+export function assignAssignments(assignments, localContext) {
+  const assignmentsAssigned = assignments.every((assigment) => {
+    const assignmentAssigned = assigment.assign(localContext);
 
-export function assignAssignment(assignments, localContext) {
-  let assignmentAssigned = true;
+    return assignmentAssigned
+  });
 
-  const assignmentsLength = assignments.length;
-
-  if (assignmentsLength === 1) {
-    const firstAssignment = first(assignments),
-          assignment = firstAssignment;
-
-    assignmentAssigned = assignment.assign(localContext);
-  }
-
-  return assignmentAssigned;
+  return assignmentsAssigned;
 }

package/src/verifier/intrinsicLevel.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import shim from "../shim";
+import Verifier from "../verifier";
+
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term!");
+
+class IntrinsicLevelVerifier extends Verifier {
+  verify(node, localContext) {
+    let verified;
+
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext);
+
+    verified = nonTerminalNodeVerified;  ///
+
+    return verified;
+  }
+
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, localContext) => {
+        const { verifyTerm } = shim,
+              terms = [],
+              termVerified = verifyTerm(termNode, terms, localContext, () => {
+                const verifiedAhead = true;
+
+                return verifiedAhead;
+              });
+
+        return termVerified;
+      }
+    }
+  ];
+}
+
+const intrinsicLevelVerifier = new IntrinsicLevelVerifier();
+
+export default intrinsicLevelVerifier;

package/src/verifier/metaLevel.js

@@ -1,22 +1,20 @@
 "use strict";
 
+import shim from "../shim";
 import Verifier from "../verifier";
-import verifyTerm from "../verify/term";
-import verifyVariable from "../verify/variable";
-import verifyMetavariable from "../verify/metavariable";
 
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term!"),
-      variableNodeQuery = nodeQuery("/variable!"),
-      metavariableNodeQuery = nodeQuery("/metavariable!");
+      statementNodeQuery = nodeQuery("/statement!");
 
 class MetaLevelVerifier extends Verifier {
-  verify(node, localContext) {
+  verify(node, assignments, derived, localContext) {
     let verified;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext);
+          childNodes = nonTerminalNode.getChildNodes(),
+          nonTerminalNodeVerified = this.verifyChildNodes(childNodes, assignments, derived, localContext);
 
     verified = nonTerminalNodeVerified;  ///
 
@@ -25,25 +23,19 @@ class MetaLevelVerifier extends Verifier {
 
   static maps = [
     {
-      nodeQuery: metavariableNodeQuery,
-      verify: (metavariableNode, localContext) => {
-        const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+      nodeQuery: statementNodeQuery,
+      verify: (statementNode, assignments, derived, localContext) => {
+        const { verifyStatement } = shim,
+              statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-        return metavariableVerified;
-      }
-    },
-    {
-      nodeQuery: variableNodeQuery,
-      verify: (variableNode, localContext) => {
-        const variableVerified = verifyVariable(variableNode, localContext);
-
-        return variableVerified;
+        return statementVerified;
       }
     },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext) => {
-        const terms = [],
+      verify: (termNode, assignments, derived, localContext) => {
+        const { verifyTerm } = shim,
+              terms = [],
               termVerified = verifyTerm(termNode, terms, localContext, () => {
                 const verifiedAhead = true;
 

package/src/verifier/statementAsCombinator.js

@@ -1,18 +1,18 @@
 "use strict";
 
+import shim from "../shim";
 import Verifier from "../verifier";
 import verifyType from "../verify/type";
-import verifyTerm from "../verify/term";
-import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
+import LocalContext from "../context/local";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
       statementNodeQuery = nodeQuery("/statement!");
 
 class StatementAsCombinatorVerifier extends Verifier {
-  verify(statementNode, fileContext) {
+  verifyStatement(statementNode, fileContext) {
     let statementVerifiedAsCombinator;
 
     const nonTerminalNode = statementNode, ///
@@ -27,9 +27,11 @@ class StatementAsCombinatorVerifier extends Verifier {
   static maps = [
     {
       nodeQuery: statementNodeQuery,
-      verify: (statementNode, localContext) => {
-        const derived = false,
+      verify: (statementNode, fileContext) => {
+        const { verifyStatement } = shim,
+              derived = false,
               assignments = [],
+              localContext = LocalContext.fromFileContext(fileContext),
               statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
         return statementVerified;
@@ -37,8 +39,10 @@ class StatementAsCombinatorVerifier extends Verifier {
     },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext) => {
-        const terms = [],
+      verify: (termNode, fileContext) => {
+        const { verifyTerm } = shim,
+              terms = [],
+              localContext = LocalContext.fromFileContext(fileContext),
               termVerified = verifyTerm(termNode, terms, localContext, () => {
                 const verifiedAhead = true;
 

package/src/verifier/termAsConstructor.js

@@ -1,7 +1,7 @@
 "use strict";
 
+import shim from "../shim";
 import Verifier from "../verifier";
-import verifyTerm from "../verify/term";
 import verifyType from "../verify/type";
 import LocalContext from "../context/local";
 
@@ -11,7 +11,7 @@ const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!");
 
 class TermAsConstructorVerifier extends Verifier {
-  verify(termNode, fileContext) {
+  verifyTerm(termNode, fileContext) {
     let termVerifiedAsConstructor;
 
     const nonTerminalNode = termNode, ///
@@ -31,7 +31,8 @@ class TermAsConstructorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, fileContext, verifyAhead) => {
-        const terms = [],
+        const { verifyTerm } = shim,
+              terms = [],
               localContext = LocalContext.fromFileContext(fileContext),
               termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 

package/src/verify/assertion/contained.js

@@ -83,9 +83,7 @@ function verifyStatedContainedAssertion(containedAssertionNode, assignments, der
 
     localContext.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`, containedAssertionNode);
 
-    const verified = metaLevelVerifier.verify(containedAssertionNode, localContext);
-
-    statedContainedAssertionVerified = verified; ///
+    debugger
 
     if (statedContainedAssertionVerified) {
       localContext.debug(`...verified the '${containedAssertionString}' stated contained assertion.`, containedAssertionNode);

package/src/verify/assertion/defined.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import verifyTerm from "../../verify/term";
-import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
@@ -112,9 +111,7 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
 
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
-    const verified = metaLevelVerifier.verify(definedAssertionNode, localContext);
-
-    statedDefinedAssertionVerified = verified; ///
+    debugger
 
     if (statedDefinedAssertionVerified) {
       localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`, definedAssertionNode);

package/src/verify/assertion/subproof.js

@@ -2,6 +2,11 @@
 
 import metaLevelVerifier from "../../verifier/metaLevel";
 
+const verifySubproofAssertionFunctions = [
+  verifyDerivedSubproofAssertion,
+  verifyStatedSubproofAssertion
+];
+
 export default function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
   let subproofAssertionVerified;
 
@@ -9,18 +14,17 @@ export default function verifySubproofAssertion(subproofAssertionNode, assignmen
 
   localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`, subproofAssertionNode);
 
-  const verifySubproofAssertionFunctions = [
-    verifyDerivedSubproofAssertion,
-    verifyStatedSubproofAssertion
-  ];
+  const verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, derived, localContext);
 
-  subproofAssertionVerified = verifySubproofAssertionFunctions.some((verifySubproofAssertionFunction) => {
-    const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
+  if (verified) {
+    subproofAssertionVerified = verifySubproofAssertionFunctions.some((verifySubproofAssertionFunction) => {
+      const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
 
-    if (subproofAssertionVerified) {
-      return true;
-    }
-  });
+      if (subproofAssertionVerified) {
+        return true;
+      }
+    });
+  }
 
   if (subproofAssertionVerified) {
     localContext.debug(`...verified the '${subproofAssertionString}' subproof assertion.`, subproofAssertionNode);
@@ -30,30 +34,30 @@ export default function verifySubproofAssertion(subproofAssertionNode, assignmen
 }
 
 function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
-  let derivedSubproofAssertionVerified = false;
+  let derivedSubproofAssertionVerified;
 
   if (derived) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
-    if (derivedSubproofAssertionVerified) {
-      localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`, subproofAssertionNode);
-    }
+    localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`, subproofAssertionNode);
+
+    derivedSubproofAssertionVerified = false;
+
+    localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`, subproofAssertionNode);
   }
 
   return derivedSubproofAssertionVerified;
 }
 
 function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
-  let statedSubproofAssertionVerified = false;
+  let statedSubproofAssertionVerified;
 
   if (!derived) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
     localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`, subproofAssertionNode);
 
-    const verified = metaLevelVerifier.verify(subproofAssertionNode, localContext);
-
-    statedSubproofAssertionVerified = verified; ///
+    statedSubproofAssertionVerified = true;
 
     if (statedSubproofAssertionVerified) {
       localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`, subproofAssertionNode);

package/src/verify/assertion/type.js

@@ -6,7 +6,6 @@ import VariableAssignment from "../../assignment/variable";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import local from "../../context/local";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),

package/src/verify/declaration.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import shim from "../shim";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 
@@ -9,38 +8,62 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/declaration/statement!"),
       metavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
-export default function verifyDeclaration(declarationNode, declarations, localContext) {
-  let declarationVerified = false;
+export default function verifyDeclaration(declarationNode, assignments, derived, localContext) {
+  let declarationVerified;
 
   const declarationString = localContext.nodeAsString(declarationNode);
 
   localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
+  const verifyDeclarationFunctions = [
+    verifyDerivedDeclaration,
+    verifyStatedDeclaration
+  ];
+
+  declarationVerified = verifyDeclarationFunctions.some((verifyDeclarationFunction) => {
+    const declarationVerified = verifyDeclarationFunction(declarationNode, assignments, derived, localContext);
+
+    if (declarationVerified) {
+      return true;
+    }
+  });
+
+  if (declarationVerified) {
+    localContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
+  }
+
+  return declarationVerified;
+}
+
+function verifyStatedDeclaration(declarationNode, declarations, localContext) {
+  let statedDeclarationVerified = false;
+
+  const declarationString = localContext.nodeAsString(declarationNode);
+
+  localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
+
   const metavariableNode = metavariableNodeQuery(declarationNode),
         metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
   if (metavariableVerified) {
     const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyStatement } = shim,
-          derived = false,
-          assignments = [],
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+    debugger
 
     if (statementVerified) {
       const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
 
       declarations.push(declaration);
 
-      declarationVerified = true;
+      statedDeclarationVerified = true;
     }
   }
 
-  if (declarationVerified) {
-    localContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
+  if (statedDeclarationVerified) {
+    localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
   }
 
-  return declarationVerified;
+  return statedDeclarationVerified;
 }
 
 function verifyMetavariable(metavariableNode, localContext) {

package/src/verify/frame.js

@@ -10,13 +10,40 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, frames, assignments, derived, localContext) {
+export default function verifyFrame(frameNode, assignments, derived, localContext) {
   let frameVerified;
 
   const frameString = localContext.nodeAsString(frameNode);
 
   localContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
+  const verifyFrameFunctions = [
+    verifyDerivedFrame,
+    verifyStatedFrame
+  ];
+
+  frameVerified = verifyFrameFunctions.some((verifyFrameFunction) => {
+    const frameVerified = verifyFrameFunction(frameNode, assignments, derived, localContext);
+
+    if (frameVerified) {
+      return true;
+    }
+  });
+
+  if (frameVerified) {
+    localContext.debug(`...verified the '${frameString}' frame.`, frameNode);
+  }
+
+  return frameVerified;
+}
+
+function verifyStatedFrame(frameNode, frames, assignments, derived, localContext) {
+  let statedFrameVerified;
+
+  const frameString = localContext.nodeAsString(frameNode);
+
+  localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
+
   const declarations = [],
         declarationNodes = declarationNodesQuery(frameNode),
         metavariableNodes = metavariableNodesQuery(frameNode),
@@ -36,14 +63,14 @@ export default function verifyFrame(frameNode, frames, assignments, derived, loc
 
     frames.push(frame);
 
-    frameVerified = true;
+    statedFrameVerified = true;
   }
 
-  if (frameVerified) {
-    localContext.debug(`...verified the '${frameString}' frame.`, frameNode);
+  if (statedFrameVerified) {
+    localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
   }
 
-  return frameVerified;
+  return statedFrameVerified;
 }
 
 function verifyMetavariable(metavariableNode, declarations, localContext) {