occam-verify-cli 0.0.959 → 0.0.961

package/src/unify/{termAgainstTerm.js → termWithTerm.js}

@@ -2,15 +2,15 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext) {
-  let termUnifiedAgainstTerm = false;
+export default function unifyTermWithTerm(leftTermNode, rightTermNode, localContext) {
+  let termUnifiedWithTerm = false;
 
   const equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    termUnifiedAgainstTerm = true;
+    termUnifiedWithTerm = true;
   }
 
-  return termUnifiedAgainstTerm;
+  return termUnifiedWithTerm;
 }

package/src/unify/termWithType.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import verifyTermGivenType from "../verify/termGivenType";
+
+export default function unifyTermWithType(termNode, typeNode, localContext) {
+  let termUnifiedWithType;
+
+  const type = localContext.findTypeByTypeNode(typeNode),
+        termVerifiedGivenType = verifyTermGivenType(termNode, type, localContext);
+
+  termUnifiedWithType = termVerifiedGivenType;  ///
+
+
+  return termUnifiedWithType;
+}

package/src/unify/{variableAgainstTerm.js → variableWithTerm.js}

@@ -6,8 +6,8 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
-  let variableUnifiedAgainstTerm = false;
+export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
+  let variableUnifiedWithTerm = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
@@ -21,7 +21,7 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
     const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
     if (substitutionMatchesTermNodeB) {
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
@@ -38,11 +38,11 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
         substitutions.addSubstitution(substitution, localContextA, localContextB);
       }
 
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   }
 
-  return variableUnifiedAgainstTerm;
+  return variableUnifiedWithTerm;
 }
 
 function variableFromTermNode(termNode, localContext) {

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

@@ -5,7 +5,7 @@ export default function verifyError(errorNode, fileContext) {
 
   const errorString = fileContext.nodeAsString(errorNode)
 
-  fileContext.debug(`The '${errorString}' cannot be verified.`, errorNode);
+  fileContext.debug(`The '${errorString}' error cannot be verified.`, errorNode);
 
   return errorVerified;
 }

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) {

package/src/verify/judgement.js

@@ -70,10 +70,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedAgainstDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedAgainstJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+              const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
 
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedAgainstDeclaration && metaLemmaMetatheoremUnifiedAgainstJudgement);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
             } else {
               const metavariableString = localContext.nodeAsString(metavariableNode);
 

package/src/verify/metavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { nodeQuery } from "../utilities/query";
+import { unifyTermWithTermType } from "../metavariable";
 import { nameFromMetavariableNode } from "../utilities/name";
-import { unifyTermAgainstTermType } from "../metavariable";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type");
@@ -43,9 +43,9 @@ export default function verifyMetavariable(metavariableNode, localContext) {
 
         localContext.debug(`No term was found when the metavariable's term type is '${termTypeName}'.`, termNode);
       } else {
-        const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, termType, localContext);
+        const termUnifiedWithTermType = unifyTermWithTermType(termNode, termType, localContext);
 
-        metavariableVerified = termUnifiedAgainstTermType; ///
+        metavariableVerified = termUnifiedWithTermType; ///
       }
     }
   }

package/src/verify/premise.js

@@ -5,7 +5,7 @@ import ProofStep from "../proofStep";
 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("/premise/unqualifiedStatement!");
@@ -25,9 +25,9 @@ export default function verifyPremise(premiseNode, premises, localContext) {
           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),
               metaproofStep = ProofStep.fromStatementNode(statementNode),
               premise = Premise.fromStatementNode(statementNode);