occam-verify-cli 0.0.960 → 0.0.962

package/src/verify/statement/unqualified.js

@@ -1,16 +1,10 @@
 "use strict";
 
-import verifyEquality from "../../verify/equality";
-import verifyJudgement from "../../verify/judgement";
 import verifyStatement from "../../verify/statement";
-import verifyTypeAssertion from "../assertion/type";
 
 import { nodeQuery } from "../../utilities/query";
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified;
@@ -19,18 +13,18 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
-  const verifyUnqualifiedStatementFunctions = [
-    verifyDerivedUnqualifiedStatement,
-    verifyStatedUnqualifiedStatement
-  ];
+  const statementNode = statementNodeQuery(unqualifiedStatementNode),
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-  unqualifiedStatementVerified = verifyUnqualifiedStatementFunctions.some((verifyUnqualifiedStatementFunction) => {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatementFunction(unqualifiedStatementNode, assignments, derived, localContext);
+  if (statementVerified) {
+    if (derived) {
+      const derivedUnqualifiedStatementVerified = verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
 
-    if (unqualifiedStatementVerified) {
-      return true;
+      unqualifiedStatementVerified = derivedUnqualifiedStatementVerified; ///
+    } else {
+      unqualifiedStatementVerified = true;
     }
-  });
+  }
 
   if (unqualifiedStatementVerified) {
     localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
@@ -39,145 +33,21 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   return unqualifiedStatementVerified;
 }
 
-function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let derivedUnqualifiedStatementVerified = false;
+function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
+  let derivedUnqualifiedStatementVerified;
 
-  if (derived) {
-    const statementNode = statementNodeQuery(unqualifiedStatementNode),
-          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
-
-    localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
-    const statementUnified = localContext.unifyStatement(statementNode, localContext);
+  localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
 
-    if (statementUnified) {
-      derivedUnqualifiedStatementVerified = true;
-    } else {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            derivedStatementVerified = verifyDerivedStatement(statementNode, assignments, derived, localContext);
+  const statementNode = statementNodeQuery(unqualifiedStatementNode),
+        statementUnified = localContext.unifyStatement(statementNode, localContext);
 
-      derivedUnqualifiedStatementVerified = derivedStatementVerified; ///
-    }
+  derivedUnqualifiedStatementVerified = statementUnified;  ///
 
-    if (derivedUnqualifiedStatementVerified) {
-      localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
-    }
+  if (derivedUnqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
   }
 
   return derivedUnqualifiedStatementVerified;
 }
-
-function verifyStatedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let statedUnqualifiedStatementVerified = false;
-
-  if (!derived) {
-    const statementNode = statementNodeQuery(unqualifiedStatementNode),
-          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
-
-    localContext.trace(`Verifying the '${unqualifiedStatementString}' stated unqualified statement...`, unqualifiedStatementNode);
-
-    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
-
-    statedUnqualifiedStatementVerified = statementVerified; ///
-
-    if (statedUnqualifiedStatementVerified) {
-      localContext.debug(`...verified the '${unqualifiedStatementString}' stated unqualified statement.`, unqualifiedStatementNode);
-    }
-  }
-
-  return statedUnqualifiedStatementVerified;
-}
-
-function verifyDerivedStatement(statementNode, assignments, derived, localContext) {
-  let derivedStatementVerified;
-
-  const statementString = localContext.nodeAsString(statementNode);
-
-  localContext.trace(`Verifying the '${statementString}' derived statement...`, statementNode);
-
-  const verifyDerivedStatementFunctions = [
-    verifyDerivedStatementAsEquality,
-    verifyDerivedStatementAsJudgement,
-    verifyDerivedStatementAsTypeAssertion
-  ];
-
-  derivedStatementVerified = verifyDerivedStatementFunctions.every((verifyDerivedStatementFunction) => {  ///
-    const derivedStatementVerified = verifyDerivedStatementFunction(statementNode, assignments, derived, localContext);
-
-    if (derivedStatementVerified) {
-      return true;
-    }
-  });
-
-  if (derivedStatementVerified) {
-    localContext.debug(`...verified the '${statementString}' derived statement.`, statementNode);
-  }
-
-  return derivedStatementVerified;
-}
-
-function verifyDerivedStatementAsEquality(statementNode, assignments, derived, localContext) {
-  let derivedStatementVerifiedAsEquality = true; ///
-
-  const equalityNode = equalityNodeQuery(statementNode);
-
-  if (equalityNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' derived statement as an equality...`, statementNode);
-
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext);
-
-    derivedStatementVerifiedAsEquality = equalityVerified; ///
-
-    if (derivedStatementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' derived statement as an equality.`, statementNode);
-    }
-  }
-
-  return derivedStatementVerifiedAsEquality;
-}
-
-function verifyDerivedStatementAsJudgement(statementNode, assignments, derived, localContext) {
-  let derivedStatementVerifiedAsJudgement = true;
-
-  const judgementNode = judgementNodeQuery(statementNode);
-
-  if (judgementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' derived statement as a judgement...`, statementNode);
-
-    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
-
-    derivedStatementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (derivedStatementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' derived statement as a judgement.`, statementNode);
-    }
-  }
-
-  return derivedStatementVerifiedAsJudgement;
-}
-
-function verifyDerivedStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsTypeAssertion = true;  ///
-
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
-
-  if (typeAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' derived statement as a type assertion...`, statementNode);
-
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' derived statement as a type assertion.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsTypeAssertion;
-}

package/src/verify/statement.js

@@ -1,49 +1,72 @@
 "use strict";
 
 import shim from "../shim";
+import verifyFrame from "../verify/frame";
 import verifyEquality from "../verify/equality";
 import verifyJudgement from "../verify/judgement";
-import metaLevelVerifier from "../verifier/metaLevel";
-import bracketedCombinator from "../ocmbinator/bracketed";
+import verifyDeclaration from "../verify/declaration";
 import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
 import verifySubproofAssertion from "../verify/assertion/subproof";
 import verifyContainedAssertion from "../verify/assertion/contained";
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+import unifyStatementWithCombinators from "../unify/statementWithCombinators";
+import unifyStatementWithBracketedCombinator from "../unify/statementWithBracketedCombinator";
 
 import { nodeQuery } from "../utilities/query";
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
+const frameNodeQuery = nodeQuery("/statement/frame!"),
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
       judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      metavariableNodeQuery = nodeQuery("/*/metavariable!"),
+      declarationNodeQuery = nodeQuery("/statement/declaration!"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
 
+const unifyStatementFunctions = [
+        unifyStatementWithCombinators,
+        unifyStatementWithBracketedCombinator
+      ],
+      verifyStatementFunctions = [
+        verifyStatementAsEquality,
+        verifyStatementAsFrame,
+        verifyStatementAsJudgement,
+        verifyStatementAsDeclaration,
+        verifyStatementAsSubstitution,
+        verifyStatementAsTypeAssertion,
+        verifyStatementAsDefinedAssertion,
+        verifyStatementAsSubproofAssertion,
+        verifyStatementAsContainedAssertion
+      ];
+
 function verifyStatement(statementNode, assignments, derived, localContext) {
-  let statementVerified;
+  let statementVerified = false;
 
   const statementString = localContext.nodeAsString(statementNode);
 
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const statementUnifiedWithCombinators = unifyStatementWithCombinators(statementNode, assignments, derived, localContext);
+  if (!statementVerified) {
+    const statementVerifiedAsMetavariable = verifyStatementAsMetavariable(statementNode, assignments, derived, localContext);
 
-  if (statementUnifiedWithCombinators) {
-    statementVerified = true;
-  } else {
-    const verifyStatementFunctions = [
-      verifyStatementAsMetavariable,
-      verifyStatementAsEquality,
-      verifyStatementAsJudgement,
-      verifyStatementAsTypeAssertion,
-      verifyStatementAsDefinedAssertion,
-      verifyStatementAsSubproofAssertion,
-      verifyStatementAsContainedAssertion,
-      unifyStatementWithCombinators
-    ];
+    statementVerified = statementVerifiedAsMetavariable;  ///
+  }
+
+  if (!statementVerified) {
+    const statementUnified = unifyStatementFunctions.some((unifyStatementFunction) => {
+      const statementUnified = unifyStatementFunction(statementNode, assignments, derived, localContext);
+
+      if (statementUnified) {
+        return true;
+      }
+    });
 
+    statementVerified = statementUnified; ///
+  }
+
+  if (!statementVerified) {
     statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
       const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
@@ -76,9 +99,9 @@ function verifyStatementAsMetavariable(statementNode, assignments, derived, loca
 
     localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
 
-    const verified = metaLevelVerifier.verify(statementNode, localContext);
+    const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-    statementVerifiedAsMetavariable = verified; ///
+    statementVerifiedAsMetavariable = metavariableVerified;
 
     if (statementVerifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
@@ -110,6 +133,28 @@ function verifyStatementAsEquality(statementNode, assignments, derived, localCon
   return statementVerifiedAsEquality;
 }
 
+function verifyStatementAsFrame(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsFrame = false;
+
+  const frameNode = frameNodeQuery(statementNode);
+
+  if (frameNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a frame...`, statementNode);
+
+    const frameVerified = verifyFrame(frameNode, assignments, derived, localContext);
+
+    statementVerifiedAsFrame = frameVerified; ///
+
+    if (statementVerifiedAsFrame) {
+      localContext.debug(`...verified the '${statementString}' statement as a frame.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsFrame;
+}
+
 function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsJudgement = false;
 
@@ -132,6 +177,50 @@ function verifyStatementAsJudgement(statementNode, assignments, derived, localCo
   return statementVerifiedAsJudgement;
 }
 
+function verifyStatementAsDeclaration(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDeclaration = false;
+
+  const declarationNode = declarationNodeQuery(statementNode);
+
+  if (declarationNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`, statementNode);
+
+    const declarationVerified = verifyDeclaration(declarationNode, assignments, derived, localContext);
+
+    statementVerifiedAsDeclaration = declarationVerified; ///
+
+    if (statementVerifiedAsDeclaration) {
+      localContext.debug(`...verified the '${statementString}' statement as a declaration.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDeclaration;
+}
+
+function verifyStatementAsSubstitution(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsSubstitution = false;
+
+  const substitutionNode = substitutionNodeQuery(statementNode);
+
+  if (substitutionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a substitution...`, statementNode);
+
+    const substitutionVerified = verifySubstitution(substitutionNode, assignments, derived, localContext);
+
+    statementVerifiedAsSubstitution = substitutionVerified; ///
+
+    if (statementVerifiedAsSubstitution) {
+      localContext.debug(`...verified the '${statementString}' statement as a substitution.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsSubstitution;
+}
+
 function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
@@ -191,7 +280,7 @@ function verifyStatementAsSubproofAssertion(statementNode, assignments, derived,
     statementVerifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
     if (statementVerifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`, statementNode);
     }
   }
 
@@ -206,73 +295,38 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
   if (containedAssertionNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
 
     const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
 
     if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
     }
   }
 
   return statementVerifiedAsContainedAssertion;
 }
 
-function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
-  let statementUnifiedWithCombinators = false;
-
-  const equalityNode = equalityNodeQuery(statementNode),
-        judgementNode = judgementNodeQuery(statementNode),
-        metavariableNode = metavariableNodeQuery(statementNode),
-        typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        definedAssertionNode = definedAssertionNodeQuery(statementNode),
-        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode);
-
-  if (  (equalityNode === null) &&
-        (judgementNode === null) &&
-        (metavariableNode === null) &&
-        (typeAssertionNode === null) &&
-        (definedAssertionNode === null) &&
-        (subproofAssertionNode === null) &&
-        (containedAssertionNode === null) ) {
+function verifyMetavariable(metavariableNode, localContext) {
+  let metavariableVerified = false;
 
-    let combinators = localContext.getCombinators();
+  const metavariableString = localContext.nodeAsString(metavariableNode);
 
-    combinators = [ ///
-      bracketedCombinator,
-      ...combinators
-    ];
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-    statementUnifiedWithCombinators = combinators.some((combinator) => {
-      const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, localContext);
+  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
-      if (statementUnifiedWithCombinator) {
-        return true;
-      }
-    });
+  if (!metavariablePresent) {
+    localContext.trace(`The '${metavariableString}' metavariable is not present.`, metavariableNode);
+  } else {
+    metavariableVerified = true;
   }
 
-  return statementUnifiedWithCombinators;
-}
-
-function unifyStatementWithCombinator(statementNode, combinator, localContext) {
-  let statementUnifiedWithCombinator;
-
-  const statementString = localContext.nodeAsString(statementNode),
-        combinatorString = combinator.getString();
-
-  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
-
-  const combinatorStatementNode = combinator.getStatementNode();
-
-  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
-
-  if (statementUnifiedWithCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
-  return statementUnifiedWithCombinator;
+  return metavariableVerified;
 }

package/src/verify/statementAsCombinator.js

@@ -10,7 +10,7 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
 
   fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`, statementNode);
 
-  statementVerifiedAsCombinator = statementAsCombinatorVerifier.verify(statementNode, fileContext);
+  statementVerifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
   if (statementVerifiedAsCombinator) {
     const tokens = fileContext.getTokens(),

package/src/verify/statementGivenMetaType.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import shim from "../shim";
+
+import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+export default function verifyStatementGivenMetaType(statementNode, metaType, assignments, derived, localContext) {
+  let statementVerifiedGivenMetaType;
+
+  const metaTypeName = metaType.getName();
+
+  switch (metaTypeName) {
+    case FRAME_META_TYPE_NAME: {
+
+      debugger
+
+      break;
+    }
+
+    case STATEMENT_META_TYPE_NAME: {
+      const { verifyStatement } = shim,
+            statementVerified = verifyStatement(statementNode, assignments, derived, localContext)
+
+      statementVerifiedGivenMetaType = statementVerified;
+
+      break;
+    }
+
+    default: {
+
+      debugger
+
+    }
+  }
+
+  return statementVerifiedGivenMetaType;
+}

package/src/verify/supposition.js

@@ -5,7 +5,7 @@ import Supposition from "../supposition";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { assignAssignment } from "../utilities/assignments";
+import { assignAssignments } from "../utilities/assignments";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
@@ -25,9 +25,9 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
           unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
     if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
+      const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-      if (assignmentAssigned) {
+      if (assignmentsAssigned) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),
               supposition = Supposition.fromStatementNode(statementNode),
               proofStep = ProofStep.fromStatementNode(statementNode);