occam-verify-cli 0.0.1135 → 0.0.1137

package/src/dom/premise.js

@@ -31,69 +31,67 @@ export default domAssigned(class Premise {
     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 premise = this, ///
-          premiseString = premise.getString(),
-          statementString = statement.getString();
+  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
+    let proofStepUnified;
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+    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 '${premiseString}' premise.`);
-    }
-
-    return statementUnified;
+    return proofStepUnified;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnified = false;
 
     const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
+      subproofString = subproof.getString(),
+      premiseStatement = premise.getStatement(),
+      premiseStatementString = premiseStatement.getString();
 
     specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
 
     const context = generalContext,
-          subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+      subproofAssertion = subproofAssertionFromStatement(this.statement, context);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
@@ -106,14 +104,32 @@ export default domAssigned(class Premise {
     return subproofUnified;
   }
 
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const premise = this, ///
+          premiseString = premise.getString(),
+          statementString = statement.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+    }
+
+    return statementUnified;
+  }
+
   verify(context) {
     let verified = false;
 
     const premiseString = this.string; ///
 
-    if (this.statement !== null) {
-      context.trace(`Verifying the '${premiseString}' premise...`);
+    context.trace(`Verifying the '${premiseString}' premise...`);
 
+    if (this.statement !== null) {
       const stated = true,
             assignments = [],
             statementVerified = this.statement.verify(assignments, stated, context);
@@ -123,21 +139,22 @@ export default domAssigned(class Premise {
 
         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 '${premiseString}' premise.`);
-      }
     } else {
       context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
     }
 
+    if (verified) {
+      context.debug(`...verified the '${premiseString}' premise.`);
+    }
+
     return verified;
   }
 

package/src/dom/proofStep.js

@@ -4,13 +4,15 @@ import dom from "../dom";
 import unifyMixins from "../mixins/proofStep/unify";
 import Substitutions from "../substitutions";
 
+import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 
+const proofStepNodeQuery = nodeQuery("/proofStep");
+
 export default domAssigned(class ProofStep {
-  constructor(string, subproof, statement, reference) {
+  constructor(string, statement, reference) {
     this.string = string;
-    this.subproof = subproof;
     this.statement = statement;
     this.reference = reference;
   }
@@ -19,10 +21,6 @@ export default domAssigned(class ProofStep {
     return this.string;
   }
 
-  getSubproof() {
-    return this.subproof;
-  }
-
   getStatement() {
     return this.statement;
   }
@@ -37,29 +35,29 @@ export default domAssigned(class ProofStep {
     return qualified;
   }
 
-  unify(substitutions, context) {
-    let unified;
+  isProofStep() {
+    const proofStep = true;
 
-    if (this.subproof !== null) {
-      unified = true; ///
-    }
+    return proofStep;
+  }
 
-    if (this.statement !== null) {
-      const proofStepString = this.string;  ///
+  unify(substitutions, context) {
+    let unified;
 
-      context.trace(`Unifying the '${proofStepString}' proof step...`);
+    const proofStepString = this.string;  ///
 
-      unified = unifyMixins.some((unifyMixin) => {
-        const unified = unifyMixin(this.statement, this.reference, substitutions, context);
+    context.trace(`Unifying the '${proofStepString}' proof step...`);
 
-        if (unified) {
-          return true;
-        }
-      });
+    unified = unifyMixins.some((unifyMixin) => {
+      const unified = unifyMixin(this.statement, this.reference, substitutions, context);
 
       if (unified) {
-        context.debug(`...unified the '${proofStepString}' proof step.`);
+        return true;
       }
+    });
+
+    if (unified) {
+      context.debug(`...unified the '${proofStepString}' proof step.`);
     }
 
     return unified;
@@ -72,15 +70,7 @@ export default domAssigned(class ProofStep {
           generalContext = context, ///
           substitutions = Substitutions.fromNothing();
 
-    if (this.subproof !== null) {
-      const subproofUnified = statement.unifySubproof(this.subproof, substitutions, generalContext, specificContext);
-
-      statementUnified = subproofUnified; ///
-    }
-
-    if (this.statement !== null) {
-      statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
-    }
+    statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
       const equivalences = context.getEquivalences(),
@@ -105,9 +95,9 @@ export default domAssigned(class ProofStep {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const proofStep = this; ///
+          const proofStepSubproof = this; ///
 
-          context.addProofStep(proofStep);
+          context.addProofStepSubproof(proofStepSubproof);
 
           verifiedAndUnified = true; ///
         }
@@ -120,17 +110,11 @@ export default domAssigned(class ProofStep {
   verify(substitutions, assignments, context) {
     let verified = false;
 
-    if (false) {
-      ///
-    } else if (this.subproof !== null) {
-      const subproofVerified = this.subproof.verify(substitutions, context);
-
-      verified = subproofVerified;  ///
-    } else if (this.statement !== null) {
-      const proofStepString = this.string;  ///
+    const proofStepString = this.string;
 
-      context.trace(`Verifying the '${proofStepString}' proof step...`);
+    context.trace(`Verifying the '${proofStepString}' proof step...`);
 
+    if (this.statement !== null) {
       const qualified = this.isQualified(),
             stated = qualified, ///
             statementVerified = this.statement.verify(assignments, stated, context);
@@ -144,16 +128,14 @@ export default domAssigned(class ProofStep {
           verified = referenceVerified; ///
         }
       }
-
-      if (verified) {
-        context.debug(`...verified the '${proofStepString}' proof step.`);
-      }
     } else {
-      const proofStepString = this.string;
-
       context.debug(`Cannot verify the '${proofStepString}' proof step because it is nonsense.`);
     }
 
+    if (verified) {
+      context.debug(`...verified the '${proofStepString}' proof step.`);
+    }
+
     return verified;
   }
 
@@ -162,21 +144,26 @@ export default domAssigned(class ProofStep {
   static fromStatement(statement, context) {
     const statementString = statement.getString(),
           string = statementString, ///
-          subproof = null,
           reference = null,
-          proofStep = new ProofStep(string, subproof, statement, reference);
+          proofStep = new ProofStep(string, statement, reference);
 
     return proofStep;
   }
 
-  static fromProofStepNode(proofStepNode, fileContext) {
-    const { Subproof, Statement, Reference } = dom,
-          node = proofStepNode, ///
-          string = fileContext.nodeAsString(node),
-          subproof = Subproof.fromProofStepNode(proofStepNode, fileContext),
-          statement = Statement.fromProofStepNode(proofStepNode, fileContext),
-          reference = Reference.fromProofStepNode(proofStepNode, fileContext),
-          proofStep = new ProofStep(string, subproof, statement, reference);
+  static fromProofStepSubproofNode(proofStepSubproofNode, fileContext) {
+    let proofStep = null;
+
+    const proofStepNode = proofStepNodeQuery(proofStepSubproofNode);
+
+    if (proofStepNode !== null) {
+      const { Statement, Reference } = dom,
+            node = proofStepNode, ///
+            string = fileContext.nodeAsString(node),
+            statement = Statement.fromProofStepNode(proofStepNode, fileContext),
+            reference = Reference.fromProofStepNode(proofStepNode, fileContext);
+
+      proofStep = new ProofStep(string, statement, reference);
+    }
 
     return proofStep;
   }

package/src/dom/proofStep.old.js

@@ -0,0 +1,183 @@
+"use strict";
+
+import dom from "../dom";
+import unifyMixins from "../mixins/proofStep/unify";
+import Substitutions from "../substitutions";
+
+import { domAssigned } from "../dom";
+import { assignAssignments } from "../utilities/assignments";
+
+export default domAssigned(class ProofStep {
+  constructor(string, subproof, statement, reference) {
+    this.string = string;
+    this.subproof = subproof;
+    this.statement = statement;
+    this.reference = reference;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getSubproof() {
+    return this.subproof;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  isQualified() {
+    const qualified = (this.reference !== null);
+
+    return qualified;
+  }
+
+  unify(substitutions, context) {
+    let unified;
+
+    if (this.subproof !== null) {
+      unified = true; ///
+    }
+
+    if (this.statement !== null) {
+      const proofStepString = this.string;  ///
+
+      context.trace(`Unifying the '${proofStepString}' proof step...`);
+
+      unified = unifyMixins.some((unifyMixin) => {
+        const unified = unifyMixin(this.statement, this.reference, substitutions, context);
+
+        if (unified) {
+          return true;
+        }
+      });
+
+      if (unified) {
+        context.debug(`...unified the '${proofStepString}' proof step.`);
+      }
+    }
+
+    return unified;
+  }
+
+  unifyStatement(statement, context) {
+    let statementUnified;
+
+    const specificContext = context, ///
+          generalContext = context, ///
+          substitutions = Substitutions.fromNothing();
+
+    if (this.subproof !== null) {
+      const subproofUnified = statement.unifySubproof(this.subproof, substitutions, generalContext, specificContext);
+
+      statementUnified = subproofUnified; ///
+    }
+
+    if (this.statement !== null) {
+      statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+    }
+
+    if (statementUnified) {
+      const equivalences = context.getEquivalences(),
+            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
+
+      statementUnified = substitutionsUnified;  ///
+    }
+
+    return statementUnified;
+  }
+
+  verifyAndUnify(substitutions, context) {
+    let verifiedAndUnified = false;
+
+    const assignments = [],
+          verified = this.verify(substitutions, assignments, context);
+
+    if (verified) {
+      const unified = this.unify(substitutions, context);
+
+      if (unified) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const proofStep = this; ///
+
+          context.addProofStep(proofStep);
+
+          verifiedAndUnified = true; ///
+        }
+      }
+    }
+
+    return verifiedAndUnified;
+  }
+
+  verify(substitutions, assignments, context) {
+    let verified = false;
+
+    if (false) {
+      ///
+    } else if (this.subproof !== null) {
+      const subproofVerified = this.subproof.verify(substitutions, context);
+
+      verified = subproofVerified;  ///
+    } else if (this.statement !== null) {
+      const proofStepString = this.string;  ///
+
+      context.trace(`Verifying the '${proofStepString}' proof step...`);
+
+      const qualified = this.isQualified(),
+            stated = qualified, ///
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        if (this.reference === null) {
+          verified = true;
+        } else {
+          const referenceVerified = this.reference.verify(context);
+
+          verified = referenceVerified; ///
+        }
+      }
+
+      if (verified) {
+        context.debug(`...verified the '${proofStepString}' proof step.`);
+      }
+    } else {
+      const proofStepString = this.string;
+
+      context.debug(`Cannot verify the '${proofStepString}' proof step because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  static name = "ProofStep";
+
+  static fromStatement(statement, context) {
+    const statementString = statement.getString(),
+          string = statementString, ///
+          subproof = null,
+          reference = null,
+          proofStep = new ProofStep(string, subproof, statement, reference);
+
+    return proofStep;
+  }
+
+  static fromProofStepNode(proofStepNode, fileContext) {
+    const { Subproof, Statement, Reference } = dom,
+          node = proofStepNode, ///
+          string = fileContext.nodeAsString(node),
+          subproof = Subproof.fromProofStepNode(proofStepNode, fileContext),
+          statement = Statement.fromProofStepNode(proofStepNode, fileContext),
+          reference = Reference.fromProofStepNode(proofStepNode, fileContext),
+          proofStep = new ProofStep(string, subproof, statement, reference);
+
+    return proofStep;
+  }
+});

package/src/dom/reference.js

@@ -9,7 +9,7 @@ import { referenceMetaType } from "../dom/metaType";
 import { unifyLabelWithReference } from "../utilities/unification";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-const proofStepReferenceNodeQuery = nodeQuery("/proofStep|lastProofStep/reference"),
+const proofStepReferenceNodeQuery = nodeQuery("/proofStep/reference"),
       declarationReferenceNodeQuery = nodeQuery("/declaration/reference");
 
 export default domAssigned(class Reference {

package/src/dom/rule.js

@@ -71,8 +71,8 @@ export default domAssigned(class Rule {
     return metavariableNameMatches;
   }
 
-  unifyStatementAndProofSteps(statement, proofSteps, context) {
-    let statementAndProofStepsUnified = false;
+  unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context) {
+    let statementAndProofStepSubproofsUnified = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
@@ -82,16 +82,16 @@ export default domAssigned(class Rule {
           statementUnifiedWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithConclusion) {
-      const proofStepsUnifiedWithPremises = this.unifyProofStepsWithPremises(proofSteps, substitutions, generalContext, specificContext);
+      const proofStepSubproofsUnifiedWithPremises = this.unifyProofStepSubproofsWithPremises(proofStepSubproofs, substitutions, generalContext, specificContext);
 
-      if (proofStepsUnifiedWithPremises) {
+      if (proofStepSubproofsUnifiedWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndProofStepsUnified = substitutionsResolved; ///
+        statementAndProofStepSubproofsUnified = substitutionsResolved; ///
       }
     }
 
-    return statementAndProofStepsUnified;
+    return statementAndProofStepSubproofsUnified;
   }
 
   unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext) {
@@ -104,42 +104,42 @@ export default domAssigned(class Rule {
     return statementUnifiedWithConclusion;
   }
 
-  unifyProofStepsWithPremises(proofSteps, substitutions, generalContext, specificContext) {
-    proofSteps = reverse(proofSteps); ///
+  unifyProofStepSubproofsWithPremises(proofStepSubproofs, substitutions, generalContext, specificContext) {
+    proofStepSubproofs = reverse(proofStepSubproofs); ///
 
-    const proofStepsUnifiedWithPremises = backwardsEvery(this.premises, (premise) => {
-      const proofStepUnifiedWithPremise = this.unifyProofStepsWithPremise(proofSteps, premise, substitutions, generalContext, specificContext);
+    const proofStepSubproofsUnifiedWithPremises = backwardsEvery(this.premises, (premise) => {
+      const proofStepUnifiedWithPremise = this.unifyProofStepSubproofsWithPremise(proofStepSubproofs, premise, substitutions, generalContext, specificContext);
 
       if (proofStepUnifiedWithPremise) {
         return true;
       }
     });
 
-    return proofStepsUnifiedWithPremises;
+    return proofStepSubproofsUnifiedWithPremises;
   }
 
-  unifyProofStepsWithPremise(proofSteps, premise, substitutions, generalContext, specificContext) {
-    let proofStepsUnifiedWithPremise  =false;
+  unifyProofStepSubproofsWithPremise(proofStepSubproofs, premise, substitutions, generalContext, specificContext) {
+    let proofStepSubproofsUnifiedWithPremise  =false;
 
     const premiseUnifiedIndependently = premise.unifyIndependently(substitutions, generalContext, specificContext);
 
     if (premiseUnifiedIndependently) {
-      proofStepsUnifiedWithPremise = true;
+      proofStepSubproofsUnifiedWithPremise = true;
     } else {
-      const proofStep = extract(proofSteps, (proofStep) => {
-        const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, generalContext, specificContext);
+      const proofStep = extract(proofStepSubproofs, (proofStepSubproof) => {
+        const proofStepSubproofUnified = premise.unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext);
 
-        if (proofStepUnified) {
+        if (proofStepSubproofUnified) {
           return true;
         }
       }) || null;
 
       if (proofStep !== null) {
-        proofStepsUnifiedWithPremise = true;
+        proofStepSubproofsUnifiedWithPremise = true;
       }
     }
 
-    return proofStepsUnifiedWithPremise;
+    return proofStepSubproofsUnifiedWithPremise;
   }
 
   verify() {

package/src/dom/statement.js

@@ -192,12 +192,12 @@ export default domAssigned(class Statement {
     return unifiedIndependently;
   }
 
-  unifyWithProofSteps(proofSteps, context) {
+  unifyWithProofStepSubproofs(proofStepSubproofs, context) {
     let unifiedWithProofSteps;
 
-    unifiedWithProofSteps = backwardsSome(proofSteps, (proofStep) => {
+    unifiedWithProofSteps = backwardsSome(proofStepSubproofs, (proofStepSubproof) => {
       const statement = this, ///
-            statementUnified =proofStep.unifyStatement(statement, context);
+            statementUnified =proofStepSubproof.unifyStatement(statement, context);
 
       if (statementUnified) {
         return true;