occam-verify-cli 1.0.955 → 1.0.972

package/src/element/assumption/metaLevel.js

@@ -9,7 +9,7 @@ import { instantiateMetaLevelAssumption } from "../../process/instantiate";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../../utilities/breakPoint";
 import { metaLevelAssumptionFromMetaLevelAssumptionNode } from "../../utilities/element";
 import { metaLevelAssumptionStringFromReferenceAndStatement } from "../../utilities/string";
-import { join, ablate, attempt, descend, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
+import { ablate, attempt, descend, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelAssumption extends Element {
   constructor(context, string, node, breakPoint, reference, statement) {
@@ -80,6 +80,10 @@ export default define(class MetaLevelAssumption extends Element {
 
       context.debug(`...the '${metaLevelAssumptionString}' meta-level assumption is already valid.`);
     } else {
+      const temporaryContext = context; ///
+
+      context = this.getContext();
+
       attempt((context) => {
         const statementValidates = this.validateStatement(context);
 
@@ -90,7 +94,7 @@ export default define(class MetaLevelAssumption extends Element {
             const stated = context.isStated();
 
             let validatesWhenStated = false,
-                validatesWhenDerived = false;
+              validatesWhenDerived = false;
 
             if (stated) {
               validatesWhenStated = this.validateWhenStated(context);
@@ -109,6 +113,8 @@ export default define(class MetaLevelAssumption extends Element {
         }
       }, context);
 
+      context = temporaryContext; ///
+
       if (validates) {
         metaLevelAssumption = this;  ///
 
@@ -214,27 +220,25 @@ export default define(class MetaLevelAssumption extends Element {
     context.trace(`Unifying the '${assumptionString}' assumption with the '${metaLevelAssumptionString}' meta-level assumption...`);
 
     const metaLevelAssumptionContext = this.getContext(), ///
-          assumptionContext = assumption.getContext(),
-          specificContext = assumptionContext, ///
-          generalContext = metaLevelAssumptionContext;  ///
+          assumptionContext = assumption.getContext(), ///
+          generalContext = metaLevelAssumptionContext,
+          specificContext = assumptionContext;  ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const reference = assumption.getReference(),
-              referneceUnifies = this.unifyReference(reference, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const reference = assumption.getReference(),
+            referneceUnifies = this.unifyReference(reference, generalContext, specificContext);
 
-        if (referneceUnifies) {
-          const statement = assumption.getStatement(),
-                statementUnifieds = this.unifyStatement(statement, generalContext, specificContext);
+      if (referneceUnifies) {
+        const statement = assumption.getStatement(),
+              statementUnifieds = this.unifyStatement(statement, generalContext, specificContext);
 
-          if (statementUnifieds) {
-            specificContext.commit(context);
+        if (statementUnifieds) {
+          specificContext.commit(context);
 
-            assumptionUnifies = true;
-          }
+          assumptionUnifies = true;
         }
-      }, specificContext);
-    }, specificContext, context);
+      }
+    }, specificContext);
 
     if (assumptionUnifies) {
       context.debug(`...unified the '${assumptionString}' assumption with the '${metaLevelAssumptionString}' meta-level assumption...`);
@@ -313,8 +317,8 @@ export default define(class MetaLevelAssumption extends Element {
   static fromJSON(json, context) {
     let metaLevelAssumption;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context),
               node = metaLevelAssumptionNode,  ///
@@ -323,8 +327,8 @@ export default define(class MetaLevelAssumption extends Element {
               statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
 
         metaLevelAssumption = new MetaLevelAssumption(context, string, node, breakPoint, reference, statement);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return metaLevelAssumption;
   }

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

@@ -3,11 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { instantiateConstructor } from "../process/instantiate";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
 import { validateTermAsConstructor } from "../process/validate";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
@@ -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);