occam-verify-cli 1.0.956 → 1.0.973

package/src/element/assumption.js

@@ -30,6 +30,8 @@ export default define(class Assumption extends Element {
     return assumptionNode;
   }
 
+  getStatementNode() { return this.statement.getStatementNode(); }
+
   getMetavariable() { return this.reference.getMetavariable(); }
 
   getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
@@ -50,6 +52,19 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
+  findSubproofAssertion(context) {
+    let subproofAssertion = null;
+
+    const statementNode = this.getStatementNode(),
+          subproofAssertionNode = statementNode.getSubproofAssertionNode();
+
+    if (subproofAssertionNode !== null) {
+      subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+    }
+
+    return subproofAssertion;
+  }
+
   findValidAssumption(context) {
     const assumptionNode = this.getAssumptionNode(),
           assumption = context.findAssumptionByAssumptionNode(assumptionNode),
@@ -206,8 +221,56 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
+  unifyStatement(statement, generalContext, specificContext) {
+    let statementUnifies;
+
+    const context = specificContext, ///
+          statementString = statement.getString(),
+          proofAssertionString = this.getString();  ///
+
+    context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' assumption's statement...`);
+
+    statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+
+    if (statementUnifies) {
+      context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' assumption's statement.`);
+    }
+
+    return statementUnifies;
+  }
+
+  unifyDeduction(deduction, context) {
+    let deductionUnifies = false;
+
+    const deductionString = deduction.getString(),
+          assumptionString = this.getString();  ///
+
+    context.trace(`Unifying the '${deductionString}' deduction with the '${assumptionString}' assumption's statement...`);
+
+    const deductionContext = deduction.getContext(),
+          generalContext = context, ///
+          specificContext = deductionContext; ///
+
+    reconcile((specificContext) => {
+      const statement = deduction.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+
+      if (statementUnifies) {
+        specificContext.commit(context);
+
+        deductionUnifies = true;
+      }
+    }, specificContext);
+
+    if (deductionUnifies) {
+      context.debug(`...unified the '${deductionString}' deduction with the '${assumptionString}' assumption's statement.`);
+    }
+
+    return deductionUnifies;
+  }
+
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionUnifies;
+    let topLevelMetaAssertionUnifies = false;
 
     const assumptionString = this.getString(),  ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
@@ -218,7 +281,22 @@ export default define(class Assumption extends Element {
       topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
       if (topLevelMetaAssertionUnifies) {
-        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+        const subproofAssertion = this.findSubproofAssertion(context);
+
+        if (subproofAssertion !== null) {
+          topLevelMetaAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+        } else {
+          const unconditional = topLevelMetaAssertion.isUnconditional();
+
+          if (unconditional) {
+            const deduction = topLevelMetaAssertion.getDeduction(),
+                  deductionUnifies = this.unifyDeduction(deduction, context);
+
+            if (deductionUnifies) {
+              topLevelMetaAssertionUnifies = true;
+            }
+          }
+        }
       }
     }, context);
 

package/src/element/combinator.js

@@ -75,25 +75,22 @@ export default define(class Combinator extends Element {
   }
 
   unifyStatement(statement, context) {
-    let statementUnifies;
+    let statementUnifies = false;
 
     const statementString = statement.getString(),
           combinatorString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
 
-    const specifiContext = context; ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specifiContext; ///
-
     const combinator = this, ///
+          combinatorContext = combinator.getContext(),
+          generalContext = combinatorContext, ///
+          specifiContext = context, ///
           statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, generalContext, specifiContext);
 
-    statementUnifies = statementUnifiesWithCombinator; ///
+    if (statementUnifiesWithCombinator) {
+      statementUnifies = true;
+    }
 
     if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
@@ -131,8 +128,8 @@ export default define(class Combinator extends Element {
   static fromJSON(json, context) {
     let combinator;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               combinatorNode = instantiateCombinator(string, context),
               node = combinatorNode,  ///
@@ -140,8 +137,8 @@ export default define(class Combinator extends Element {
               statement = statementFromCombinatorNode(combinatorNode, context);
 
         combinator = new Combinator(context, string, node, breakPoint, statement);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return combinator;
   }

package/src/element/conclusion.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateConclusion } from "../process/instantiate";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { declare, attempt, sequester, serialise, unserialise, instantiate } from "../utilities/context";
+import { elide, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Conclusion extends Element {
   constructor(context, string, node, breakPoint, statement) {
@@ -35,11 +35,15 @@ export default define(class Conclusion extends Element {
     context.trace(`Verifying the '${conclusionString}' conclusion...`);
 
     if (this.statement !== null) {
-      const validates = this.validate(context);
-
-      if (validates) {
-        verifies = true;
-      }
+      declare((context) => {
+        elide((context) => {
+          const validates = this.validate(context);
+
+          if (validates) {
+            verifies = true;
+          }
+        }, context);
+      }, context);
     } else {
       context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
     }
@@ -58,18 +62,16 @@ export default define(class Conclusion extends Element {
 
     context.trace(`Validating the '${conclusionString}' conclusion...`);
 
-    declare((context) => {
-      attempt((context) => {
-        const statementValidates = this.validateStatement(context);
+    attempt((context) => {
+      const statementValidates = this.validateStatement(context);
 
-        if (statementValidates) {
-          validates = true;
-        }
+      if (statementValidates) {
+        validates = true;
+      }
 
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
+      if (validates) {
+        this.commit(context);
+      }
     }, context);
 
     if (validates) {
@@ -86,13 +88,11 @@ export default define(class Conclusion extends Element {
 
     context.trace(`Validating the '${conclusionString}' conclusion's statement...`);
 
-    sequester((context) => {
-      const statement = this.statement.validate(context);
+    const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
-    }, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.trace(`...validated the '${conclusionString}' conclusion's statement.`);
@@ -109,20 +109,21 @@ export default define(class Conclusion extends Element {
 
     context.trace(`Unifying the '${stepString}' step with the '${conclusionString}' conclusion...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context;  ///
+    const stepContext = step.getContext(),
+          conclusionContext = this.getContext(),
+          generalContext = conclusionContext, ///
+          specificContext = stepContext;  ///
 
-    context = specificContext;  ///
+    reconcile((specificContext) => {
+      const statement = step.getStatement(),
+            statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
-    const statement = step.getStatement(),
-          statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      stepUnifies = true;
-    }
+        stepUnifies = true;
+      }
+    }, specificContext);
 
     if (stepUnifies) {
       context.debug(`...unified the '${stepString}' step with the '${conclusionString}' conclusion.`);
@@ -160,8 +161,8 @@ export default define(class Conclusion extends Element {
   static fromJSON(json, context) {
     let conclusion;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               conclusionNode = instantiateConclusion(string, context),
               node = conclusionNode,  ///
@@ -169,8 +170,8 @@ export default define(class Conclusion extends Element {
               statement = statementFromConclusionNode(conclusionNode, context);
 
         conclusion = new Conclusion(context, string, node, breakPoint, statement);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return conclusion;
   }

package/src/element/constructor.js

@@ -106,19 +106,14 @@ export default define(class Constructor extends Element {
 
     const termString = term.getString(),
           includeType = false,
-          constructorString = this.getString(includeType);
+          constructorString = this.getString(includeType);  ///
 
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 
-    const specifiContext = context; ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specifiContext; ///
-
     const constructor = this, ///
+          constructorContext = constructor.getContext(),
+          generalContext = constructorContext,  ///
+          specifiContext = context, ///
           termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);
 
     if (termUnifiesWithConstructor) {
@@ -175,8 +170,8 @@ export default define(class Constructor extends Element {
   static fromJSON(json, context) {
     let constructor;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               constructorNode = instantiateConstructor(string, context),
               node = constructorNode, ///
@@ -185,8 +180,8 @@ export default define(class Constructor extends Element {
               type = typeFromJSON(json, context);
 
         constructor = new Constructor(context, string, node, breakPoint, term, type);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return constructor;
   }

package/src/element/deduction.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateDeduction } from "../process/instantiate";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { declare, attempt, sequester, serialise, unserialise, instantiate } from "../utilities/context";
+import { elide, declare, attempt, serialise, unserialise, instantiate, reconcile } from "../utilities/context";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, breakPoint, statement) {
@@ -35,11 +35,15 @@ export default define(class Deduction extends Element {
     context.trace(`Verifying the '${deductionString}' deduction...`);
 
     if (this.statement !== null) {
-      const validates = this.validate(context);
-
-      if (validates) {
-        verifies = true;
-      }
+      declare((context) => {
+        elide((context) => {
+          const validates = this.validate(context);
+
+          if (validates) {
+            verifies = true;
+          }
+        }, context);
+      }, context);
     } else {
       context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
     }
@@ -58,18 +62,16 @@ export default define(class Deduction extends Element {
 
     context.trace(`Validating the '${deductionString}' deduction...`);
 
-    declare((context) => {
-      attempt((context) => {
-        const statementValidates = this.validateStatement(context);
+    attempt((context) => {
+      const statementValidates = this.validateStatement(context);
 
-        if (statementValidates) {
-          validates = true;
-        }
+      if (statementValidates) {
+        validates = true;
+      }
 
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
+      if (validates) {
+        this.commit(context);
+      }
     }, context);
 
     if (validates) {
@@ -86,13 +88,11 @@ export default define(class Deduction extends Element {
 
     context.trace(`Validating the '${deductionnString}' deductionn's statement...`);
 
-    sequester((context) => {
-      const statement = this.statement.validate(context);
+    const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
-    }, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.trace(`...validated the '${deductionnString}' deductionn's statement.`);
@@ -109,20 +109,21 @@ export default define(class Deduction extends Element {
 
     context.trace(`Unifying the '${stepString}' step with the '${deductionString}' deduction...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context;  ///
+    const stepContext = step.getContext(),
+          deductionContext = this.getContext(),
+          generalContext = deductionContext, ///
+          specificContext = stepContext;  ///
 
-    context = specificContext;  ///
+    reconcile((specificContext) => {
+      const statement = step.getStatement(),
+            statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
-    const statement = step.getStatement(),
-          statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      stepUnifies = true;
-    }
+        stepUnifies = true;
+      }
+    }, specificContext);
 
     if (stepUnifies) {
       context.debug(`...unified the '${stepString}' step with the '${deductionString}' deduction.`);
@@ -160,8 +161,8 @@ export default define(class Deduction extends Element {
   static fromJSON(json, context) {
     let deduction;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               deductionNode = instantiateDeduction(string, context),
               node = deductionNode,  ///
@@ -169,8 +170,8 @@ export default define(class Deduction extends Element {
               statement = statementFromDeductionNode(deductionNode, context);
 
         deduction = new Deduction(context, string, node, breakPoint, statement);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return deduction;
   }

package/src/element/equivalence.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
+import { ablate, instantiate } from "../utilities/context";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
@@ -217,13 +217,15 @@ export default define(class Equivalence extends Element {
 
     type = combinedType;  ///
 
-    instantiate((context) => {
-      const terms = combinedTerms,  ///
-            equivalenceString = equivalenceStringFromTerms(terms),
-            string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const terms = combinedTerms,  ///
+              equivalenceString = equivalenceStringFromTerms(terms),
+              string = equivalenceString,  ///
+              equivalenceNode = instantiateEquivalence(string, context);
 
-      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+        equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+      }, context);
     }, context);
 
     equivalence.setType(type);
@@ -238,13 +240,15 @@ export default define(class Equivalence extends Element {
 
     const type = equality.getType();
 
-    instantiate((context) => {
-      const terms = equality.getTerms(),
-            equivalenceString = equivalenceStringFromTerms(terms),
-            string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const terms = equality.getTerms(),
+              equivalenceString = equivalenceStringFromTerms(terms),
+              string = equivalenceString,  ///
+              equivalenceNode = instantiateEquivalence(string, context);
 
-      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+        equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+      }, context);
     }, context);
 
     equivalence.setType(type);

package/src/element/hypothesis.js

@@ -36,11 +36,13 @@ export default define(class Hypothesis extends Element {
     context.trace(`Verifying the '${hypothesisString}' hypothesis...`);
 
     if (this.statement !== null) {
-      const validates = this.validate(context);
+      declare((context) => {
+        const validates = this.validate(context);
 
-      if (validates) {
-        verifies = true;
-      }
+        if (validates) {
+          verifies = true;
+        }
+      }, context)
     } else {
       context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);
     }
@@ -59,19 +61,17 @@ export default define(class Hypothesis extends Element {
 
     context.trace(`Validating the '${hypothesisString}' hypothesis...`);
 
-    declare((context) => {
-      attempt((context) => {
-        const statementValidates = this.validateStatement(context);
+    attempt((context) => {
+      const statementValidates = this.validateStatement(context);
 
-        if (statementValidates) {
-          validates = true;
-        }
+      if (statementValidates) {
+        validates = true;
+      }
 
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
-    }, context)
+      if (validates) {
+        this.commit(context);
+      }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${hypothesisString}' hypothesis.`);
@@ -80,6 +80,26 @@ export default define(class Hypothesis extends Element {
     return validates;
   }
 
+  discharge(context) {
+    let discharges = false;
+
+    const hypothesisString = this.getString(); ///
+
+    context.trace(`Discharging the '${hypothesisString}' hypothesis...`);
+
+    const statementDischarges = this.dischargeStatement(context);
+
+    if (statementDischarges) {
+      discharges = true;
+    }
+
+    if (discharges) {
+      context.debug(`...discharged the '${hypothesisString}' hypothesis.`);
+    }
+
+    return discharges;
+  }
+
   validateStatement(context) {
     let statementValidates = false;
 
@@ -100,6 +120,26 @@ export default define(class Hypothesis extends Element {
     return statementValidates;
   }
 
+  dischargeStatement(context) {
+    let statementDischarges = false;
+
+    const hypothesisString = this.getString();
+
+    context.trace(`Discharging the '${hypothesisString}' hypothesis's statement... `);
+
+    const discharges = this.statement.discharge(context);  ///
+
+    if (discharges) {
+      statementDischarges = true;
+    }
+
+    if (statementDischarges) {
+      context.debug(`...discharged the '${hypothesisString}' hypothesis' statement. `);
+    }
+
+    return statementDischarges;
+  }
+
   static name = "Hypothesis";
 
   toJSON() {
@@ -129,8 +169,8 @@ export default define(class Hypothesis extends Element {
   static fromJSON(json, context) {
     let hypothesis;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               hypothesisNode = instantiateHypothesis(string, context),
               node = hypothesisNode,  ///
@@ -138,8 +178,8 @@ export default define(class Hypothesis extends Element {
               statement = statementFromHypothesisNode(hypothesisNode, context);
 
         hypothesis = new Hypothesis(context, string, node, breakPoint, statement);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return hypothesis;
   }

package/src/element/judgement.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateJudgement } from "../process/instantiate";
-import { reconcile, instantiate } from "../utilities/context";
+import { reconcile, instantiate,} from "../utilities/context";
 import { judgementFromStatementNode } from "../utilities/element";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";