occam-nominal 1.0.310 → 1.0.317

package/src/element/rule.js

@@ -68,7 +68,7 @@ export default define(class Rule extends Element {
             verifyPremises = this.verifyPremises.bind(this),
             verifyConclusion = this.verifyConclusion.bind(this);
 
-      all([
+      return all([
         verifyLabels,
         verifyPremises,
         verifyConclusion,
@@ -87,13 +87,29 @@ export default define(class Rule extends Element {
     }, context);
   });
 
+  verifyLabels(context, conntinuation) {
+    const ruleString = this.getString();  ///
+
+    context.trace(`Verifying the '${ruleString}' rule's labels...`);
+
+    return every(this.labels, (label, continuation) => {
+      return this.verifyLabel(label, context, continuation);
+    }, (labelsVerify) => {
+      if (labelsVerify) {
+        context.debug(`...verified the '${ruleString}' rule's labels.`);
+      }
+
+      return conntinuation(labelsVerify);
+    });
+  }
+
   verifyLabel(label, context, continuation) {
     const ruleString = this.getString(),  ///
           labelString = label.getString();
 
     context.trace(`Verifying the '${ruleString}' rule's '${labelString}' label...`);
 
-    label.verify((labelVerifies) => {
+    return label.verify((labelVerifies) => {
       if (labelVerifies) {
         context.debug(`...verified the '${ruleString}' rule's '${labelString}' label.`);
       }
@@ -115,7 +131,7 @@ export default define(class Rule extends Element {
 
     const statement = this.conclusion.getStatement();
 
-    this.proof.verify(statement, context, (proofVerifies) => {
+    return this.proof.verify(statement, context, (proofVerifies) => {
       if (proofVerifies) {
         context.debug(`...verified the '${ruleString}' rule's proof.`);
       }
@@ -124,29 +140,13 @@ export default define(class Rule extends Element {
     });
   }
 
-  verifyLabels(context, conntinuation) {
-    const ruleString = this.getString();  ///
-
-    context.trace(`Verifying the '${ruleString}' rule's labels...`);
-
-    return every(this.labels, (label, continuation) => {
-      return this.verifyLabel(label, context, continuation);
-    }, (labelsVerify) => {
-      if (labelsVerify) {
-        context.debug(`...verified the '${ruleString}' rule's labels.`);
-      }
-
-      return conntinuation(labelsVerify);
-    });
-  }
-
   verifyPremise(premise, context, continuation) {
     const ruleString = this.getString(),  ///
           premiseString = premise.getString();
 
     context.trace(`Verifying the '${ruleString}' rule's '${premiseString}' premise...`);
 
-    premise.verify(context, (premiseVerifies) => {
+    return premise.verify(context, (premiseVerifies) => {
       if (premiseVerifies) {
         const subproofOrProofAssertion = premise;  ////
 
@@ -185,7 +185,7 @@ export default define(class Rule extends Element {
 
     context.trace(`Verifying the '${ruleString}' rule's '${conclusionString}' conclusion...`);
 
-    this.conclusion.verify(context, (conclusionVerifies) => {
+    return this.conclusion.verify(context, (conclusionVerifies) => {
       if (conclusionVerifies) {
         context.debug(`...verified the '${ruleString}' rule's '${conclusionString}' conclusion.`);
       }
@@ -201,7 +201,7 @@ export default define(class Rule extends Element {
 
     context.trace(`Unifying the '${stepString}' step with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
 
-    this.conclusion.unifyStep(step, context, (stepUnifies) => {
+    return this.conclusion.unifyStep(step, context, (stepUnifies) => {
       let stepUnifiesWithConclusion = false;
 
       if (stepUnifies) {
@@ -217,7 +217,7 @@ export default define(class Rule extends Element {
   }
 
   unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context, continuation) {
-    this.unifyStepWithConclusion(step, context, (statementUnifiesWithConclusion) => {
+    return this.unifyStepWithConclusion(step, context, (statementUnifiesWithConclusion) => {
       if (!statementUnifiesWithConclusion) {
         const stepAndSubproofOrProofAssertionsUnify = false;
 
@@ -242,12 +242,14 @@ export default define(class Rule extends Element {
 
   unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context, continuation) {
     return extract(subproofOrProofAssertions, (subproofOrProofAssertion, continuation) => {
-      premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context, continuation);
+      return premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context, continuation);
     }, (subproofOrProofAssertion = null) => {
       if (subproofOrProofAssertion !== null) {
         const subproofOrProofAssertionsUnifiesWithPremise = true;
 
-        return continuation(subproofOrProofAssertionsUnifiesWithPremise);
+        return context.resolveDerivedSubstitutions(() => {
+          return continuation(subproofOrProofAssertionsUnifiesWithPremise);
+        });
       }
 
       return premise.unifyIndependently(context, continuation);

package/src/element/statement.js

@@ -9,29 +9,26 @@ import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../process/validation";
 import { dischargeStatements } from "../process/discharge";
 import { instantiateStatement } from "../process/instantiate";
+import { substitutionFromStatementNode } from "../utilities/element";
 
 const { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;
 
 export default define(class Statement extends Element {
-  getStatementNode() {
-    const node = this.getNode(),
-          statementNode = node; ///
+  constructor(context, string, node, breakPoint, substitution) {
+    super(context, string, node, breakPoint);
 
-    return statementNode;
+    this.substitution = substitution;
   }
 
-  getTermSubstitutionNode() {
-    const statementNode = this.getNode(),
-          termSubstitutionNode = statementNode.getTermSubstitutionNode();
-
-    return termSubstitutionNode;
+  getSubstitution() {
+    return this.substitution;
   }
 
-  getFrameSubstitutionNode() {
-    const statementNode = this.getNode(),
-          frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
+  getStatementNode() {
+    const node = this.getNode(),
+          statementNode = node; ///
 
-    return frameSubstitutionNode;
+    return statementNode;
   }
 
   getMetavariableNode() {
@@ -71,6 +68,19 @@ export default define(class Statement extends Element {
     return equalTo;
   }
 
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
+  }
+
+  isComplex() {
+    const simple = this.isSimple(),
+          complex = !simple;
+
+    return complex;
+  }
+
   isSingular() {
     const statementNode = this.getStatementNode(),
           singular = statementNode.isSingular();
@@ -207,7 +217,7 @@ export default define(class Statement extends Element {
 
     const statement = this;
 
-    exists(validateStatements, statement, context, (statementValidates) => {
+    return exists(validateStatements, statement, context, (statementValidates) => {
       let statement = null;
 
       if (statementValidates) {
@@ -218,7 +228,7 @@ export default define(class Statement extends Element {
         context.debug(`...validated the '${statementString}' statement.`);
       }
 
-      continuation(statement);
+      return continuation(statement);
     });
   }
 
@@ -254,7 +264,7 @@ export default define(class Statement extends Element {
 
     context.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
-    unifyStatement(generalStatement, specificStatement, generalContext, specificContext, (statementUnifies) => {
+    return unifyStatement(generalStatement, specificStatement, generalContext, specificContext, (statementUnifies) => {
       if (statementUnifies) {
         context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
       }
@@ -263,9 +273,7 @@ export default define(class Statement extends Element {
     });
   }
 
-  unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently = false;
-
+  unifyIndependently(generalContext, specificContext, continuation) {
     const context = specificContext,  ///
           statementString = this.getString();  ///
 
@@ -278,39 +286,60 @@ export default define(class Statement extends Element {
 
     if (typeAssertionNode !== null) {
       const context = generalContext, ///
-            typeAssertion = context.findAssertionByAssertionNode(typeAssertionNode),
-            typeAssertionUnifiesIndependently = typeAssertion.unifyIndependently(generalContext, specificContext);
+            typeAssertion = context.findAssertionByAssertionNode(typeAssertionNode);
 
-      if (typeAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
+      typeAssertion.unifyIndependently(generalContext, specificContext, (typeAssertionUnifiesIndependently) => {
+        let unifiesIndependently = false;
+
+        if (typeAssertionUnifiesIndependently) {
+          unifiesIndependently = true;
+        }
+
+        if (unifiesIndependently) {
+          context.debug(`...unified the '${statementString}' statement independently.`);
+        }
+
+        return continuation(unifiesIndependently);
+      });
     }
 
     if (definedAssertionNode !== null) {
       const context = generalContext, ///
-            definedAssertion = context.findAssertionByAssertionNode(definedAssertionNode),
-            definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(generalContext, specificContext);
+            definedAssertion = context.findAssertionByAssertionNode(definedAssertionNode);
 
-      if (definedAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
+      definedAssertion.unifyIndependently(generalContext, specificContext, (definedAssertionUnifiesIndependently) => {
+        let unifiesIndependently = false;
+
+        if (definedAssertionUnifiesIndependently) {
+          unifiesIndependently = true;
+        }
+
+        if (unifiesIndependently) {
+          context.debug(`...unified the '${statementString}' statement independently.`);
+        }
+
+        return continuation(unifiesIndependently);
+      });
     }
 
     if (containedAssertionNode !== null) {
       const context = generalContext, ///
-            containedAssertion = context.findAssertionByAssertionNode(containedAssertionNode),
-            containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(generalContext, specificContext);
+            containedAssertion = context.findAssertionByAssertionNode(containedAssertionNode);
 
-      if (containedAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
+      containedAssertion.unifyIndependently(generalContext, specificContext, (containedAssertionUnifiesIndependently) => {
+        let unifiesIndependently = false;
 
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${statementString}' statement independently.`);
-    }
+        if (containedAssertionUnifiesIndependently) {
+          unifiesIndependently = true;
+        }
+
+        if (unifiesIndependently) {
+          context.debug(`...unified the '${statementString}' statement independently.`);
+        }
 
-    return unifiesIndependently;
+        return continuation(unifiesIndependently);
+      });
+    }
   }
 
   static name = "Statement";
@@ -339,11 +368,12 @@ export default define(class Statement extends Element {
       const { string } = json,
             statementNode = instantiateStatement(string, context),
             node = statementNode, ///
-            breakPoint = breakPointFromJSON(json);
+            breakPoint = breakPointFromJSON(json),
+            substitution = substitutionFromStatementNode(statementNode, context);
 
       context = null;
 
-      const statement = new Statement(context, string, node, breakPoint);
+      const statement = new Statement(context, string, node, breakPoint, substitution);
 
       return statement;
     }, context);

package/src/element/substitution/frame.js

@@ -9,7 +9,7 @@ import { define } from "../../elements";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { elide, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablate, ablates, descend, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
 
 const { breakPointFromJSON } = breakPointUtilities;
 
@@ -70,7 +70,7 @@ export default define(class FrameSubstitution extends Substitution {
 
   compareFrame(frame, context) {
     const frameEqualToReplacementFrame = this.replacementFrame.isEqualTo(frame),
-        comparedToFrame = frameEqualToReplacementFrame; ///
+          comparedToFrame = frameEqualToReplacementFrame; ///
 
     return comparedToFrame;
   }
@@ -87,9 +87,7 @@ export default define(class FrameSubstitution extends Substitution {
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
 
-      continuatino(frameSubstitution);
-
-      return;
+      return continuatino(frameSubstitution);
     }
 
     const generalContext = this.getGeneralContext(),
@@ -99,7 +97,7 @@ export default define(class FrameSubstitution extends Substitution {
       const validateTargetFrame = this.validateTargetFrame.bind(this),
             validateReplacementFrame = this.validateReplacementFrame.bind(this);
 
-      all([
+      return all([
         validateTargetFrame,
         validateReplacementFrame
       ], generalContext, specificContext, (validates) => {
@@ -121,7 +119,7 @@ export default define(class FrameSubstitution extends Substitution {
           context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
         }
 
-        continuatino(frameSubstitution);
+        return continuatino(frameSubstitution);
       });
     }, generalContext, specificContext);
   }
@@ -140,28 +138,24 @@ export default define(class FrameSubstitution extends Substitution {
 
       context.debug(`The '${targetFrameString}' target frame is not singular.`);
 
-      continuatino(targetFrameValidates);
-
-      return;
+      return continuatino(targetFrameValidates);
     }
 
-    manifest((context) => {
-      elide((context) => {
-        this.targetFrame.validate(context, (targetFrame) => {
-          let targetFrameValidates = false;
+    elide((context) => {
+      return this.targetFrame.validate(context, (targetFrame) => {
+        let targetFrameValidates = false;
 
-          if (targetFrame !== null) {
-            targetFrameValidates = true;
-          }
+        if (targetFrame !== null) {
+          targetFrameValidates = true;
+        }
 
-          if (targetFrameValidates) {
-            context.debug(`...validated the '${frameSubstitutionString}' frame substitution's target frame...`);
-          }
+        if (targetFrameValidates) {
+          context.debug(`...validated the '${frameSubstitutionString}' frame substitution's target frame...`);
+        }
 
-          continuatino(targetFrameValidates);
-        });
-      }, context);
-    }, specificContext, context);
+        return continuatino(targetFrameValidates);
+      });
+    }, context);
   }
 
   validateReplacementFrame(generalContext, specificContext, continuatino) {
@@ -171,7 +165,7 @@ export default define(class FrameSubstitution extends Substitution {
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's replacement frame...`);
 
     elide((context) => {
-      this.replacementFrame.validate(context, (replacementFrame) => {
+      return this.replacementFrame.validate(context, (replacementFrame) => {
         let replacementFrameValidates = false;
 
         if (replacementFrame !== null) {
@@ -182,14 +176,12 @@ export default define(class FrameSubstitution extends Substitution {
           context.debug(`...validated the '${frameSubstitutionString}' frame substitution's replacement frame.`);
         }
 
-        continuatino(replacementFrameValidates);
+        return continuatino(replacementFrameValidates);
       });
     }, context);
   }
 
-  unifySubstitution(substitution, context) {
-    let substitutionUnifies = false;
-
+  unifySubstitution(substitution, context, continuation) {
     const generalSubstitution = this, ///
           specificSubstitution = substitution,
           generalSubstitutionString = generalSubstitution.getString(),
@@ -198,29 +190,27 @@ export default define(class FrameSubstitution extends Substitution {
     context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
     reconcile((context) => {
-      const replacementFrameUnifies = this.unifyReplacementFrame(substitution, context);
-
-      if (replacementFrameUnifies) {
-        const targetFrameUnifies = this.unifyTargetFrame(substitution, context);
-
-        if (targetFrameUnifies) {
+      const unifyTargetFrame = this.unifyTargetFrame.bind(this),
+            unifyReplacementFrame = this.unifyReplacementFrame.bind(this);
+
+      return all([
+        unifyReplacementFrame,
+        unifyTargetFrame
+      ], substitution, context, (substitutionUnifies) => {
+        if (substitutionUnifies) {
           context.commit();
-
-          substitutionUnifies = true;
         }
-      }
-    }, context);
 
-    if (substitutionUnifies) {
-      context.debug(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
-    }
+        if (substitutionUnifies) {
+          context.debug(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+        }
 
-    return substitutionUnifies;
+        return continuation(substitutionUnifies);
+      });
+    }, context);
   }
 
-  unifyTargetFrame(substitution, context) {
-    let targetFrameUnifies = false;
-
+  unifyTargetFrame(substitution, context, continuation) {
     const generalSubstitution = this, ///
           specificSubstitution = substitution,
           generalSubstitutionString = generalSubstitution.getString(),
@@ -241,28 +231,33 @@ export default define(class FrameSubstitution extends Substitution {
       const frameNode = generalFrame.getFrameNode(),
             metavariable = metavariableFromFrameNode(frameNode, generalContext);
 
-      if (metavariable !== null) {
-        const frame = specificFrame,  ///
-              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+      if (metavariable === null) {
+        const targetFrameUnifies = false;
+
+        return continuation(targetFrameUnifies);
+      }
+
+      const frame = specificFrame;  ///
+
+      return metavariable.unifyFrame(frame, generalContext, specificContext, (frameUnifies) => {
+        let targetFrameUnifies = false;
 
         if (frameUnifies) {
           specificContext.commit(context);
 
           targetFrameUnifies = true;
         }
-      }
-    }, specificContext);
 
-    if (targetFrameUnifies) {
-      context.trace(`...unified the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame.`);
-    }
+        if (targetFrameUnifies) {
+          context.trace(`...unified the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame.`);
+        }
 
-    return targetFrameUnifies;
+        return continuation(targetFrameUnifies);
+      });
+    }, specificContext);
   }
 
-  unifyReplacementFrame(substitution, context) {
-    let replacementFrameUnifies = false;
-
+  unifyReplacementFrame(substitution, context, continuation) {
     const generalSubstitution = this, ///
           specificSubstitution = substitution,
           generalSubstitutionString = generalSubstitution.getString(),
@@ -283,23 +278,30 @@ export default define(class FrameSubstitution extends Substitution {
       const frameNode = generalFrame.getNode(),
             metavariable = metavariableFromFrameNode(frameNode, generalContext);
 
-      if (metavariable !== null) {
-        const frame = specificFrame,  ///
-              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+      if (metavariable === null) {
+        const replacementFrameUnifies = false;
+
+        return continuation(replacementFrameUnifies);
+      }
+
+      const frame = specificFrame;  ///
+
+      return metavariable.unifyFrame(frame, generalContext, specificContext, (frameUnifies) => {
+        let replacementFrameUnifies = false;
 
         if (frameUnifies) {
           specificContext.commit(context);
 
           replacementFrameUnifies = true;
         }
-      }
-    }, specificContext);
 
-    if (replacementFrameUnifies) {
-      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame.`);
-    }
+        if (replacementFrameUnifies) {
+          context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame.`);
+        }
 
-    return replacementFrameUnifies;
+        return continuation(replacementFrameUnifies);
+      });
+    }, specificContext);
   }
 
   static name = "FrameSubstitution";
@@ -331,16 +333,20 @@ export default define(class FrameSubstitution extends Substitution {
     return frameSubstitutionn;
   }
 
-  static fromStatement(statement, context) {
+  static fromStatementNode(statementNode, context) {
     let frameSubstitution = null;
 
-    const frameSubstitutionNode = statement.getFrameSubstitutionNode();
+    const frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      const generalContext = context, ///
-            specificContext = context;  ///
+      ablate((context) => {
+        descend((context) => {
+          const generalContext = context, ///
+                specificContext = context;  ///
 
-      frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
+          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
+        }, context);
+      }, context);
     }
 
     return frameSubstitution;
@@ -350,16 +356,16 @@ export default define(class FrameSubstitution extends Substitution {
     let frameSubstitution
 
     ablates((generalContext, specificContext) => {
-      const context = specificContext;  ///
-
-      instantiate((context) => {
-        const specificContext = context,  ///
-              frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-              string = frameSubstitutionString,  ///
-              frameSubstitutionNode = instantiateFrameSubstitution(string, context);
-
-        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
-      }, context);
+      instantiate((specificContext) => {
+        manifest((generalContext) => {
+          const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+                string = frameSubstitutionString,  ///
+                context = specificContext,  ///
+                frameSubstitutionNode = instantiateFrameSubstitution(string, context);
+
+          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
+        }, generalContext, specificContext);
+      }, specificContext);
     }, generalContext, specificContext);
 
     return frameSubstitution;