occam-verify-cli 0.0.906 → 0.0.908

package/src/premise.js

@@ -199,14 +199,8 @@ export default class Premise {
     return json;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
-          statementString = statement, ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+  static fromStatementNode(statementNode) {
+    const metastatementNode = null,
           premise = new Premise(metastatementNode, statementNode);
 
     return premise;
@@ -219,8 +213,14 @@ export default class Premise {
     return premise;
   }
 
-  static fromStatementNode(statementNode) {
-    const metastatementNode = null,
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metastatement, statement } = json,
+          metastatementString = metastatement,  ///
+          statementString = statement, ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           premise = new Premise(metastatementNode, statementNode);
 
     return premise;

package/src/utilities/assignments.js

@@ -2,7 +2,7 @@
 
 import { first } from "../utilities/array";
 
-export function assignAssignment(assignments, localContextOrLocalMetaContext) {
+export function assignAssignment(assignments, localContext) {
   let assignmentAssigned = true;
 
   const assignmentsLength = assignments.length;
@@ -11,7 +11,7 @@ export function assignAssignment(assignments, localContextOrLocalMetaContext) {
     const firstAssignment = first(assignments),
           assignment = firstAssignment;
 
-    assignmentAssigned = assignment.assign(localContextOrLocalMetaContext);
+    assignmentAssigned = assignment.assign(localContext);
   }
 
   return assignmentAssigned;

package/src/verifier/node/metastatement.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "../../context/local";
 import NodeVerifier from "../../verifier/node";
 
 import { nodeQuery } from "../../utilities/query";
@@ -89,7 +88,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
   }
 
   verifyVariableNode(variableNode, localMetaContext, verifyAhead) {
-    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+    const localContext = localMetaContext,  ///
           standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
           variableNodeVerified = standaloneVariableVerified;  ///
 
@@ -97,7 +96,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
   }
 
   verifyTermNode(termNode, localMetaContext, verifyAhead) {
-    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+    const localContext = localMetaContext,  ///
           standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
           termNodeVerified = standaloneTermVerified;  ///
 

package/src/verify/conclusion.js

@@ -1,11 +1,14 @@
 "use strict";
 
 import Conclusion from "../conclusion";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
 export default function verifyConclusion(conclusionNode, conclusions, localMetaContext) {
@@ -15,21 +18,43 @@ export default function verifyConclusion(conclusionNode, conclusions, localMetaC
 
   localMetaContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
 
-  if (unqualifiedMetastatementVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+  if (unqualifiedStatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          localContext = localMetaContext,  ///
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    conclusions.push(conclusion);
+    conclusionVerified = unqualifiedStatementVerified; ///
+  }
+
+  if (unqualifiedMetastatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
-    conclusionVerified = true;
+    conclusionVerified = unqualifiedMetastatementVerified; ///
   }
 
   if (conclusionVerified) {
+    let conclusion;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+      conclusion = Conclusion.fromStatementNode(statementNode);
+    }
+
+    if (unqualifiedMetastatementNode !== null) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+      conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+    }
+
+    conclusions.push(conclusion);
+
     localMetaContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
   }
 

package/src/verify/metaConsequent.js

@@ -1,11 +1,14 @@
 "use strict";
 
 import MetaConsequent from "../metaConsequent";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
 
 export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localMetaContext) {
@@ -15,18 +18,40 @@ export default function verifyMetaConsequent(metaConsequentNode, metaConsequents
 
   localMetaContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaConsequentNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode);
 
-  if (unqualifiedMetastatementVerified) {
-    metaConsequentVerified = true;
+  if (unqualifiedStatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          localContext = localMetaContext,  ///
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+    metaConsequentVerified = unqualifiedStatementVerified; ///
+  }
+
+  if (unqualifiedMetastatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+
+    metaConsequentVerified = unqualifiedMetastatementVerified; ///
   }
 
   if (metaConsequentVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          metaConsequent = MetaConsequent.fromMetastatementNode(metastatementNode);
+    let metaConsequent;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+      metaConsequent = MetaConsequent.fromStatementNode(statementNode);
+    }
+
+    if (unqualifiedMetastatementNode !== null) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+      metaConsequent = MetaConsequent.fromMetastatementNode(metastatementNode);
+    }
 
     metaConsequents.push(metaConsequent);
 

package/src/verify/metaProofStep.js

@@ -53,7 +53,8 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
 
     if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       qualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -75,7 +76,8 @@ export default function verifyMetaProofStep(metaProofStepNode, substitutions, lo
     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       unqualifiedMetastatementVerified = assignmentAssigned; ///
     }

package/src/verify/metaSupposition.js

@@ -2,12 +2,15 @@
 
 import MetaproofStep from "../step/metaproof";
 import MetaSupposition from "../metaSupposition";
+import verifyUnqualifiedStatement from "./statement/unqualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
 
 export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localMetaContext) {
@@ -17,21 +20,54 @@ export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositi
 
   localMetaContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaSuppositionNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode);
 
-  if (unqualifiedMetastatementVerified) {
-    const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+  if (unqualifiedStatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          localContext = localMetaContext,  ///
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    metaSuppositionVerified = assignmentAssigned; ///
+    if (unqualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      metaSuppositionVerified = assignmentAssigned; ///
+    }
+  }
+
+  if (unqualifiedMetastatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+
+    if (unqualifiedMetastatementVerified) {
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
+
+      metaSuppositionVerified = assignmentAssigned; ///
+    }
   }
 
   if (metaSuppositionVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode),
-          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+    let metaSupposition,
+        metaproofStep;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+      metaSupposition = MetaSupposition.fromStatementNode(statementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
+    }
+
+    if (unqualifiedMetastatementNode !== null) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+      metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+    }
 
     metaSuppositions.push(metaSupposition);
 

package/src/verify/metavariableAgainstStatement.js

@@ -38,8 +38,8 @@ export default function verifyMetavariableAgainstStatement(metavariableNodeA, st
 
         statementNodeB = substitutionStatementNode; ///
 
-        const substitution = substitutionSubstitution,
-              localContext = localContextB,  ///
+        const localContext = localContextB,  ///
+              substitution = substitutionSubstitution,
               statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
         if (statementVerifiedAgainstStatement) {
@@ -60,8 +60,8 @@ export default function verifyMetavariableAgainstStatement(metavariableNodeA, st
   } else {
     let verifiedAhead;
 
-    const metavariableNode = metavariableNodeA, ///
-          statementNode = statementNodeB, ///
+    const statementNode = statementNodeB, ///
+          metavariableNode = metavariableNodeA, ///
           statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
           substitution = statementForMetavariableSubstitution;  ///
 

package/src/verify/premise.js

@@ -2,12 +2,15 @@
 
 import Premise from "../premise";
 import MetaproofStep from "../step/metaproof";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 import { assignAssignment } from "../utilities/assignments";
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
 
 export default function verifyPremise(premiseNode, premises, localMetaContext) {
@@ -17,7 +20,21 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
   localMetaContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode);
+
+  if (unqualifiedStatementNode !== null) {
+    const derived = false,
+          assignments = [],
+          localContext = localMetaContext,  ///
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      premiseVerified = assignmentAssigned; ///
+    }
+  }
 
   if (unqualifiedMetastatementNode !== null) {
     const derived = false,
@@ -25,16 +42,32 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
           unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       premiseVerified = assignmentAssigned; ///
     }
   }
 
   if (premiseVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
-          premise = Premise.fromMetastatementNode(metastatementNode);
+    let premise,
+        metaproofStep;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
+
+      premise = Premise.fromStatementNode(statementNode);
+    }
+
+    if (unqualifiedMetastatementNode !== null) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      premise = Premise.fromMetastatementNode(metastatementNode);
+    }
 
     premises.push(premise);
 

package/src/verify/ruleProofStep.js

@@ -1,11 +1,9 @@
 "use strict";
 
-import LocalContext from "../context/local";
 import MetaproofStep from "../step/metaproof";
 import verifyRuleSubproof from "../verify/ruleSubproof";
 import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
@@ -47,7 +45,7 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     let qualifiedStatementVerified;
 
     const assignments = [],
-          localContext = LocalContext.fromLocalMetaContext(localMetaContext);
+          localContext = localMetaContext;  ///
 
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
 
@@ -76,7 +74,8 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
 
     if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       qualifiedMetastatementVerified = assignmentAssigned; ///
     }
@@ -98,7 +97,8 @@ export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext)
     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
     if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+      const localContext = localMetaContext,  ///
+            assignmentAssigned = assignAssignment(assignments, localContext);
 
       unqualifiedMetastatementVerified = assignmentAssigned; ///
     }