occam-verify-cli 0.0.1135 → 0.0.1137

package/src/dom/subDerivation.js

@@ -9,19 +9,20 @@ import { domAssigned } from "../dom";
 
 const { last } = arrayUtilities;
 
-const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
+const proofStepSubproofNodesQuery = nodesQuery("/subDerivation/proofStep|subproof");
 
 export default domAssigned(class SubDerivation {
-  constructor(proofSteps) {
-    this.proofSteps = proofSteps;
+  constructor(proofStepSubproofs) {
+    this.proofStepSubproofs = proofStepSubproofs;
   }
 
-  getProofSteps() {
-    return this.proofSteps;
+  getProofStepSubproofs() {
+    return this.proofStepSubproofs;
   }
 
   getLastProofStep() {
-    const lastProofStep = last(this.proofSteps);
+    const lastProofStepSubproof = last(this.proofStepSubproofs),
+          lastProofStep = lastProofStepSubproof;  ///
 
     return lastProofStep;
   }
@@ -29,10 +30,10 @@ export default domAssigned(class SubDerivation {
   verify(substitutions, context) {
     let verified;
 
-    verified = this.proofSteps.every((proofStep) => { ///
-      const proofStepVerifiedAndUnified = proofStep.verifyAndUnify(substitutions, context);
+    verified = this.proofStepSubproofs.every((proofStepSubproof) => { ///
+      const proofStepSubproofVerifiedAndUnified = proofStepSubproof.verifyAndUnify(substitutions, context);
 
-      if (proofStepVerifiedAndUnified) {
+      if (proofStepSubproofVerifiedAndUnified) {
         return true;
       }
     });
@@ -43,14 +44,16 @@ export default domAssigned(class SubDerivation {
   static name = "SubDerivation";
 
   static fromSubDerivationNode(subDerivationNode, fileContext) {
-    const { ProofStep } = dom,
-          proofStepNodes = proofStepNodesQuery(subDerivationNode),
-          proofSteps = proofStepNodes.map((proofStepNode) => {
-            const proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
-
-            return proofStep;
+    const { ProofStep, Subproof } = dom,
+          proofStepSubproofNodes = proofStepSubproofNodesQuery(subDerivationNode),
+          proofStepSubproofs = proofStepSubproofNodes.map((proofStepSubproofNode) => {
+            const subproof = Subproof.fromProofStepSubproofNode(proofStepSubproofNode, fileContext),
+                  proofStep = ProofStep.fromProofStepSubproofNode(proofStepSubproofNode, fileContext),
+                  proofStepSubproof = (proofStep || subproof);
+
+            return proofStepSubproof;
           }),
-          subDerivation = new SubDerivation(proofSteps);
+          subDerivation = new SubDerivation(proofStepSubproofs);
 
     return subDerivation;
   }

package/src/dom/subproof.js

@@ -6,8 +6,11 @@ import LocalContext from "../context/local";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { subproofStringFromSubproofNode } from "../utilities/subproof";
+import unifyMixins from "../mixins/proofStep/unify";
+import Substitutions from "../substitutions";
+import {assignAssignments} from "../utilities/assignments";
 
-const subproofNodeQuery = nodeQuery("/proofStep/subproof"),
+const subproofNodeQuery = nodeQuery("/subproof"),
       suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
@@ -52,6 +55,42 @@ export default domAssigned(class Subproof {
     return statements;
   }
 
+  isProofStep() {
+    const proofStep = false;
+
+    return proofStep;
+  }
+
+  unifyStatement(statement, context) {
+    let statementUnified;
+
+    const specificContext = context, ///
+          generalContext = context, ///
+          substitutions = Substitutions.fromNothing(),
+          subproof = this;
+
+    const subproofUnified = statement.unifySubproof(subproof, substitutions, generalContext, specificContext);
+
+    statementUnified = subproofUnified; ///
+
+    if (statementUnified) {
+      const equivalences = context.getEquivalences(),
+            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
+
+      statementUnified = substitutionsUnified;  ///
+    }
+
+    return statementUnified;
+  }
+
+  unify(substitutions, context) {
+    let unified;
+
+    unified = true;
+
+    return unified;
+  }
+
   verify(substitutions, context) {
     let subproofVerified = false;
 
@@ -78,12 +117,32 @@ export default domAssigned(class Subproof {
     return subproofVerified;
   }
 
+  verifyAndUnify(substitutions, context) {
+    let verifiedAndUnified = false;
+
+    const verified = this.verify(substitutions, context);
+
+    if (verified) {
+      const unified = this.unify(substitutions, context);
+
+      if (unified) {
+        const proofStepSubproof = this; ///
+
+        context.addProofStepSubproof(proofStepSubproof);
+
+        verifiedAndUnified = true; ///
+      }
+    }
+
+    return verifiedAndUnified;
+  }
+
   static name = "Subproof";
 
-  static fromProofStepNode(proofStepNode, fileContext) {
+  static fromProofStepSubproofNode(proofStepSubproofNode, fileContext) {
     let subproof = null;
 
-    const subproofNode = subproofNodeQuery(proofStepNode);
+    const subproofNode = subproofNodeQuery(proofStepSubproofNode);
 
     if (subproofNode !== null) {
       const { Supposition, SubDerivation } = dom,

package/src/dom/supposition.js

@@ -31,55 +31,53 @@ export default domAssigned(class Supposition {
     return unifiedIndependently;
   }
 
-  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
-    let proofStepUnified = false;
+  unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext) {
+    let proofStepSubproofUnified = false;
 
-    const subproof = proofStep.getSubproof(),
-          statement = proofStep.getStatement();
+    const proofStepSubProofProofStep = proofStepSubproof.isProofStep(),
+          subproof = proofStepSubProofProofStep ?
+                       null :
+                         proofStepSubproof,
+          proofStep = proofStepSubProofProofStep ?
+                        proofStepSubproof :
+                          null;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
 
-      proofStepUnified = subproofUnified; ///
+      proofStepSubproofUnified = subproofUnified; ///
     }
 
-    if (statement !== null) {
-      const statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    if (proofStep !== null) {
+      const statementUnified = this.unifyProofStep(proofStep, substitutions, generalContext, specificContext);
 
-      proofStepUnified = statementUnified;  ///
+      proofStepSubproofUnified = statementUnified;  ///
     }
 
-    if (proofStepUnified) {
+    if (proofStepSubproofUnified) {
       substitutions.resolve(generalContext, specificContext);
     }
 
     const context = specificContext;  ///
 
-    proofStepUnified ?
+    proofStepSubproofUnified ?
       substitutions.continue() :
         substitutions.rollback(context);
 
-    return proofStepUnified;
+    return proofStepSubproofUnified;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
-
-    const supposition = this, ///
-          suppositionString = supposition.getString(),
-          statementString = statement.getString();
+  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
+    let proofStepUnified;
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+    const statement = proofStep.getStatement(),
+          statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+    proofStepUnified = statementUnified;  ///
 
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
-    }
-
-    return statementUnified;
+    return proofStepUnified;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
@@ -106,14 +104,32 @@ export default domAssigned(class Supposition {
     return subproofUnified;
   }
 
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const supposition = this, ///
+          suppositionString = supposition.getString(),
+          statementString = statement.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+    }
+
+    return statementUnified;
+  }
+
   verify(context) {
     let verified = false;
 
     const suppositionString = this.string; ///
 
-    if (this.statement !== null) {
-      context.trace(`Verifying the '${suppositionString}' supposition...`);
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
 
+    if (this.statement !== null) {
       const stated = true,
             assignments = [],
             statementVerified = this.statement.verify(assignments, stated, context);
@@ -123,21 +139,22 @@ export default domAssigned(class Supposition {
 
         if (assignmentsAssigned) {
           const { ProofStep } = dom,
-                proofStep = ProofStep.fromStatement(this.statement, context);
+                proofStep = ProofStep.fromStatement(this.statement, context),
+                proofStepSubproof = proofStep;  ///
 
-          context.addProofStep(proofStep);
+          context.addProofStepSubproof(proofStepSubproof);
 
           verified = true;
         }
       }
-
-      if (verified) {
-        context.debug(`...verified the '${suppositionString}' supposition.`);
-      }
     } else {
       context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
     }
 
+    if (verified) {
+      context.debug(`...verified the '${suppositionString}' supposition.`);
+    }
+
     return verified;
   }
 

package/src/dom/topLevelAssertion.js

@@ -139,8 +139,8 @@ export default class TopLevelAssertion {
     return statementUnified;
   }
 
-  unifyStatementAndProofSteps(statement, proofSteps, context) {
-    let statementAndProofStepsUnified = false;
+  unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context) {
+    let statementAndProofStepSubproofsUnified = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
@@ -150,16 +150,16 @@ export default class TopLevelAssertion {
           statementUnifiedWithConsequent = this.unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithConsequent) {
-      const proofStepsUnifiedWithSuppositions = this.unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext);
+      const proofStepSubproofsUnifiedWithSuppositions = this.unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext);
 
-      if (proofStepsUnifiedWithSuppositions) {
+      if (proofStepSubproofsUnifiedWithSuppositions) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndProofStepsUnified = substitutionsResolved; ///
+        statementAndProofStepSubproofsUnified = substitutionsResolved; ///
       }
     }
 
-    return statementAndProofStepsUnified;
+    return statementAndProofStepSubproofsUnified;
   }
 
   unifyStatementWithConsequent(statement, substitutions, generalContext, specificContext) {
@@ -172,30 +172,30 @@ export default class TopLevelAssertion {
     return consequentUnified;
   }
 
-  unifyProofStepsWithSuppositions(proofSteps, substitutions, generalContext, specificContext) {
-    proofSteps = reverse(proofSteps); ///
+  unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext) {
+    proofStepSubproofs = reverse(proofStepSubproofs); ///
 
-    const proofStepsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const proofStepsUnifiedWithSupposition = this.unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext);
+    const proofStepSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const proofStepSubproofsUnifiedWithSupposition = this.unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext);
 
-      if (proofStepsUnifiedWithSupposition) {
+      if (proofStepSubproofsUnifiedWithSupposition) {
         return true;
       }
     });
 
-    return proofStepsUnifiedWithSuppositions;
+    return proofStepSubproofsUnifiedWithSuppositions;
   }
 
-  unifyProofStepsWithSupposition(proofSteps, supposition, substitutions, generalContext, specificContext) {
-    let proofStepsUnifiedWithSupposition  =false;
+  unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext) {
+    let proofStepSubproofsUnifiedWithSupposition  =false;
 
     const suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, generalContext, specificContext);
 
     if (suppositionUnifiedIndependently) {
-      proofStepsUnifiedWithSupposition = true;
+      proofStepSubproofsUnifiedWithSupposition = true;
     } else {
-      const proofStep = extract(proofSteps, (proofStep) => {
-        const proofStepUnified = supposition.unifyProofStep(proofStep, substitutions, generalContext, specificContext);
+      const proofStep = extract(proofStepSubproofs, (proofStepSubproof) => {
+        const proofStepUnified = supposition.unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext);
 
         if (proofStepUnified) {
           return true;
@@ -203,11 +203,11 @@ export default class TopLevelAssertion {
       }) || null;
 
       if (proofStep !== null) {
-        proofStepsUnifiedWithSupposition = true;
+        proofStepSubproofsUnifiedWithSupposition = true;
       }
     }
 
-    return proofStepsUnifiedWithSupposition;
+    return proofStepSubproofsUnifiedWithSupposition;
   }
 
   verify() {

package/src/mixins/proofStep/unify.js

@@ -16,8 +16,8 @@ function unifyAWithRule(statement, reference, substitutions, context) {
 
       context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
 
-      const proofSteps = context.getProofSteps(),
-            statementAndProofStepsUnified = rule.unifyStatementAndProofSteps(statement, proofSteps, context);
+      const proofStepSubproofs = context.getProofStepSubproofs(),
+            statementAndProofStepsUnified = rule.unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context);
 
       unifiedWithRule = statementAndProofStepsUnified;  ///
 
@@ -71,8 +71,8 @@ function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitut
 
       context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
 
-      const proofSteps = context.getProofSteps(),
-            statementAndProofStepsUnified = axiomLemmaTheoremConjecture.unifyStatementAndProofSteps(statement, proofSteps, context);
+      const proofStepSubproofs = context.getProofStepSubproofs(),
+            statementAndProofStepsUnified = axiomLemmaTheoremConjecture.unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context);
 
       if (statementAndProofStepsUnified) {
         const metavariable = reference.getMetavariable(),
@@ -153,12 +153,12 @@ function unifyAsTypeAssertion(statement, reference, substitutions, context) {
   return unifiedAsTypeAssertion;
 }
 
-function unifyWithProofSteps(statement, reference, substitutions, context) {
+function unifyWithProofStepSubproofs(statement, reference, substitutions, context) {
   let unifiedWithProofSteps = false;
 
   if (reference === null) {
-    const proofSteps = context.getProofSteps(),
-          statementUnifiedWithProofSteps = statement.unifyWithProofSteps(proofSteps, context);
+    const proofStepSubproofs = context.getProofStepSubproofs(),
+          statementUnifiedWithProofSteps = statement.unifyWithProofStepSubproofs(proofStepSubproofs, context);
 
     unifiedWithProofSteps = statementUnifiedWithProofSteps; ///
   }
@@ -173,7 +173,7 @@ const unifyMixins = [
   unifyAsEquality,
   unifyAsJudgement,
   unifyAsTypeAssertion,
-  unifyWithProofSteps
+  unifyWithProofStepSubproofs
 ];
 
 export default unifyMixins;

package/src/utilities/subproof.js

@@ -4,22 +4,15 @@ import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
 const suppositionStatementNodesQuery = nodesQuery("/subproof/supposition/statement"),
-      lastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/statement");
+      lastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/proofStep[-1]/statement");
 
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
-  let subproofString = null;
-
   const tokens = fileContext.getTokens(),
         suppositionStatementNodes = suppositionStatementNodesQuery(subproofNode),
         lastProofStepStatementNode = lastProofStepStatementNodeQuery(subproofNode),
-        suppositionStatementNodesLength = suppositionStatementNodes.length;
-
-  if ((lastProofStepStatementNode !== null) && (suppositionStatementNodesLength)) {
-    const suppositionStatementsString = nodesAsString(suppositionStatementNodes, tokens),
-          lastProofStepStatementString = nodeAsString(lastProofStepStatementNode, tokens);
-
-    subproofString = `[${suppositionStatementsString}]...${lastProofStepStatementString}`;
-  }
+        suppositionStatementsString = nodesAsString(suppositionStatementNodes, tokens),
+        lastProofStepStatementString = nodeAsString(lastProofStepStatementNode, tokens),
+        subproofString = `[${suppositionStatementsString}]...${lastProofStepStatementString}`;
 
   return subproofString;
 }