occam-verify-cli 0.0.967 → 0.0.971

package/src/verify/judgement.js

@@ -11,20 +11,20 @@ import { nodeQuery } from "../utilities/query";
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
       metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
 
-export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
+const verifyJudgementFunctions = [
+  verifyDerivedJudgement,
+  verifyStatedJudgement
+];
+
+export default function verifyJudgement(judgementNode, assignments, stated, localContext) {
   let judgementVerified;
 
   const judgementString = localContext.nodeAsString(judgementNode);
 
   localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
 
-  const verifyJudgementFunctions = [
-    verifyDerivedJudgement,
-    verifyStatedJudgement
-  ];
-
   judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
-    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, derived, localContext);
+    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, stated, localContext);
 
     if (judgementVerified) {
       return true;
@@ -38,10 +38,10 @@ export default function verifyJudgement(judgementNode, assignments, derived, loc
   return judgementVerified;
 }
 
-function verifyDerivedJudgement(judgementNode, assignments, derived, localContext) {
+function verifyDerivedJudgement(judgementNode, assignments, stated, localContext) {
   let derivedJudgementVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const judgementString = localContext.nodeAsString(judgementNode);
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
@@ -55,7 +55,7 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
       if (judgement !== null) {
         const frames = [],
               frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+              frameVerified = verifyFrame(frameNode, frames, assignments, stated, localContext);
 
         if (frameVerified) {
           const firstFrame = first(frames),
@@ -100,10 +100,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
   return derivedJudgementVerified;
 }
 
-function verifyStatedJudgement(judgementNode, assignments, derived, localContext) {
+function verifyStatedJudgement(judgementNode, assignments, stated, localContext) {
   let statedJudgementVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const judgementString = localContext.nodeAsString(judgementNode);
 
     localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
@@ -114,7 +114,7 @@ function verifyStatedJudgement(judgementNode, assignments, derived, localContext
     if (metavariableVerified) {
       const frames = [],
             frameNode = frameNodeQuery(judgementNode),
-            frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
+            frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),

package/src/verify/metavariable.js

@@ -2,7 +2,7 @@
 
 import { nodeQuery } from "../utilities/query";
 import { unifyTermWithTermType } from "../metavariable";
-import { nameFromMetavariableNode } from "../utilities/name";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type");
@@ -14,8 +14,8 @@ export default function verifyMetavariable(metavariableNode, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const name = nameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByName(name);
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
   if (metavariable === null) {
     localContext.debug(`The metavariable '${metavariableString}' is not present.`, metavariableNode);

package/src/verify/premise.js

@@ -2,7 +2,7 @@
 
 import Premise from "../premise";
 import ProofStep from "../proofStep";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignments } from "../utilities/assignments";
@@ -20,16 +20,16 @@ export default function verifyPremise(premiseNode, premises, localContext) {
   const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode);
 
   if (unqualifiedStatementNode !== null) {
-    const derived = false,
+    const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
+    if (statementVerified) {
       const assignmentsAssigned = assignAssignments(assignments, localContext);
 
       if (assignmentsAssigned) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              metaproofStep = ProofStep.fromStatementNode(statementNode),
+        const metaproofStep = ProofStep.fromStatementNode(statementNode),
               premise = Premise.fromStatementNode(statementNode);
 
         premises.push(premise);

package/src/verify/proofStep.js

@@ -7,7 +7,6 @@ import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { assignAssignments } from "../utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
@@ -23,45 +22,29 @@ export default function verifyProofStep(proofStepNode, substitutions, localConte
 
   let proofStep = null;
 
-  if (subproofNode !== null) {
-    let subproofVerified;
-
-    subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
+  if (false) {
+    ///
+  } else if (subproofNode !== null) {
+    const subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
       proofStep = ProofStep.fromSubproofNode(subproofNode);
     }
-  } else {
-    if (qualifiedStatementNode !== null) {
-      const derived = false,  ///
-            assignments = [],
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext);
-
-      if (qualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+  } else if (qualifiedStatementNode !== null) {
+    const qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-        if (assignmentsAssigned) {
-          const statementNode = statementNodeQuery(qualifiedStatementNode);
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode);
 
-          proofStep = ProofStep.fromStatementNode(statementNode);
-        }
-      }
+      proofStep = ProofStep.fromStatementNode(statementNode);
     }
+  } else if (unqualifiedStatementNode !== null) {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
 
-    if (unqualifiedStatementNode !== null) {
-      const derived = true,
-            assignments = [],
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        if (assignmentsAssigned) {
-          const statementNode = statementNodeQuery(unqualifiedStatementNode);
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-          proofStep = ProofStep.fromStatementNode(statementNode);
-        }
-      }
+      proofStep = ProofStep.fromStatementNode(statementNode);
     }
   }
 

package/src/verify/statement/qualified.js

@@ -1,35 +1,35 @@
 "use strict";
 
 import verifyStatement from "../../verify/statement";
+import unifyQualifiedStatement from "../../unify/statement/qualified";
 
 import { nodeQuery } from "../../utilities/query";
+import { assignAssignments } from "../../utilities/assignments";
 
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-const unifyDerivedQualifiedStatementFunctions = [
-  unifyDerivedQualifiedStatementAWithRule,
-  unifyDerivedQualifiedStatementAWithAxiom,
-  unifyDerivedQualifiedStatementAWithLemma,
-  unifyDerivedQualifiedStatementAWithTheorem,
-  unifyDerivedQualifiedStatementAWithConjecture,
-  unifyDerivedQualifiedStatementAWithReference
-];
-
-export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, derived, localContext) {
-  let qualifiedStatementVerified;
+export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementVerified = false;
 
   const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const statementNode = statementNodeQuery(qualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+  if (!qualifiedStatementVerified) {
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
+
+    if (statementVerified) {
+      const qualifiedStatementUnified = unifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
 
-  if (statementVerified) {
-    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
+      if (qualifiedStatementUnified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-    qualifiedStatementVerified = derivedQualifiedStatementUnified; ///
+        qualifiedStatementVerified = assignmentsAssigned; ///
+      }
+    }
   }
 
   if (qualifiedStatementVerified) {
@@ -38,184 +38,3 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
 
   return qualifiedStatementVerified;
 }
-
-function unifyDerivedQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnified;
-
-  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-  localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement...`, qualifiedStatementNode);
-
-  derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunctions.some((unifyDerivedQualifiedStatementFunction) => {
-    const derivedQualifiedStatementUnified = unifyDerivedQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
-
-    return derivedQualifiedStatementUnified;
-  });
-
-  if (derivedQualifiedStatementUnified) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement.`, qualifiedStatementNode);
-  }
-
-  return derivedQualifiedStatementUnified;
-}
-
-function unifyDerivedQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithRule = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        rule = localContext.findRuleByMetavariableNode(metavariableNode);
-
-  if (rule !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
-
-    const statementUnified = rule.unifyStatement(statementNode, localContext);
-
-    derivedQualifiedStatementUnifiedWithRule = statementUnified;  ///
-
-    if (derivedQualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
-    }
-  }
-
-  return derivedQualifiedStatementUnifiedWithRule;
-}
-
-function unifyDerivedQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithAxiom = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
-
-  if (axiom !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
-
-    const statementUnified = axiom.unifyStatement(statementNode, localContext);
-
-    derivedQualifiedStatementUnifiedWithAxiom = statementUnified; ///
-
-    if (derivedQualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
-    }
-  }
-
-  return derivedQualifiedStatementUnifiedWithAxiom;
-}
-
-function unifyDerivedQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithLemma = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
-
-  if (lemma !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
-
-    const statementUnified = lemma.unifyStatement(statementNode, localContext);
-
-    derivedQualifiedStatementUnifiedWithLemma = statementUnified; ///
-
-    if (derivedQualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
-    }
-  }
-
-  return derivedQualifiedStatementUnifiedWithLemma;
-}
-
-function unifyDerivedQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithTheorem = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
-
-  if (theorem !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
-
-    const statementUnified = theorem.unifyStatement(statementNode, localContext);
-
-    derivedQualifiedStatementUnifiedWithTheorem = statementUnified; ///
-
-    if (derivedQualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
-    }
-  }
-
-  return derivedQualifiedStatementUnifiedWithTheorem;
-}
-
-function unifyDerivedQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithConjecture = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
-
-  if (conjecture !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
-
-    const statementUnified = conjecture.unifyStatement(statementNode, localContext);
-
-    derivedQualifiedStatementUnifiedWithConjecture = statementUnified; ///
-
-    if (derivedQualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
-    }
-  }
-
-  return derivedQualifiedStatementUnifiedWithConjecture;
-}
-
-function unifyDerivedQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
-  let derivedQualifiedStatementUnifiedWithReference = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        metavariableString = localContext.nodeAsString(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
-        qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-  localContext.trace(`Unifying the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
-
-  if (metavariablePresent) {
-
-    debugger
-
-    // const statementNode = statementNodeQuery(qualifiedStatementNode),
-    //       localContextA = null,
-    //       localContextB = localContext, ///
-    //       statementNodeB = statementNode, ///
-    //       substitutionNodeA = null,
-    //       metavariableNodeA = metavariableNode, ///
-    //       metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
-    //         const verifiedAhead = true;
-    //
-    //         return verifiedAhead;
-    //       });
-    //
-    // derivedQualifiedStatementUnifiedWithReference = metavariableUnifiedWithStatement; ///
-  }
-
-  if (derivedQualifiedStatementUnifiedWithReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' derived qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
-  }
-
-  return derivedQualifiedStatementUnifiedWithReference;
-}

package/src/verify/statement/unqualified.js

@@ -1,35 +1,48 @@
 "use strict";
 
 import verifyStatement from "../../verify/statement";
+import unifyUnqualifiedStatement from "../../unify/statement/unqualified";
 
 import { nodeQuery } from "../../utilities/query";
+import { assignAssignments } from "../../utilities/assignments";
 import { verifyStatementTrivially } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let unqualifiedStatementVerified;
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, localContext) {
+  let unqualifiedStatementVerified = false;
 
   const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+  if (!unqualifiedStatementVerified) {
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-  if (statementVerified) {
-    if (derived) {
+    if (statementVerified) {
+      const unqualifiedStatementUnified = unifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
+
+      unqualifiedStatementVerified = unqualifiedStatementUnified; ///
+    }
+  }
+
+  if (!unqualifiedStatementVerified) {
+    const stated = false,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
+
+    if (statementVerified) {
       const statementVerifiedTrivially = verifyStatementTrivially(statementNode, localContext);
 
       if (statementVerifiedTrivially) {
-        unqualifiedStatementVerified = true;
-      } else {
-        const derivedUnqualifiedStatementUnified = unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext);
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-        unqualifiedStatementVerified = derivedUnqualifiedStatementUnified; ///
+        unqualifiedStatementVerified = assignmentsAssigned;  ///
       }
-    } else {
-      unqualifiedStatementVerified = true;
     }
   }
 
@@ -39,22 +52,3 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
   return unqualifiedStatementVerified;
 }
-
-function unifyDerivedUnqualifiedStatement(unqualifiedStatementNode, localContext) {
-  let derivedUnqualifiedStatementUnified;
-
-  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
-
-  localContext.trace(`Unifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
-
-  const statementNode = statementNodeQuery(unqualifiedStatementNode),
-        statementUnified = localContext.unifyStatement(statementNode, localContext);
-
-  derivedUnqualifiedStatementUnified = statementUnified;  ///
-
-  if (derivedUnqualifiedStatementUnified) {
-    localContext.debug(`...unified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
-  }
-
-  return derivedUnqualifiedStatementUnified;
-}