occam-verify-cli 1.0.924 → 1.0.932

package/src/context.js

@@ -353,42 +353,6 @@ export default class Context extends ContextBase {
     return metaLevelAssumption;
   }
 
-  findSubstitutionByVariableNode(variableNode) {
-    const context = this.getContext(),
-          substitution = context.findSubstitutionByVariableNode(variableNode);
-
-    return substitution;
-  }
-
-  findSubstitutionByMetavariableNode(metavariableNode) {
-    const context = this.getContext(),
-          substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
-
-    return substitution;
-  }
-
-  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
-    const context = this.getContext(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariableNode(metavariableNode);
-
-    return simpleSubstitution;
-  }
-
-  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
-    const context = this.getContext(),
-          complexSubstitution = context.findComplexSubstitutionsByMetavariableNode(metavariableNode);
-
-    return complexSubstitution;
-  }
-
-  findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
-    const context = this.getContext();
-
-    substitution = context.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution); ///
-
-    return substitution;
-  }
-
   findTypeByTypeName(typeName) {
     const context = this.getContext(),
           type = context.findTypeByTypeName(typeName);
@@ -529,13 +493,6 @@ export default class Context extends ContextBase {
     return metavariablePresent;
   }
 
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
-    const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
-
-    return substitutionPresent;
-  }
-
   isTypePresentByNominalTypeName(nominalTypeName) {
     const context = this.getContext(),
           typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
@@ -611,6 +568,30 @@ export default class Context extends ContextBase {
     context.addDerivedSubstitutions(derivedSubstitutions);
   }
 
+  addAxiom(axiom) {
+    const context = this.getContext();
+
+    context.addAxiom(axiom);
+  }
+
+  addLemma(lemma) {
+    const context = this.getContext();
+
+    context.addLemma(lemma);
+  }
+
+  addTheorem(theorem) {
+    const context = this.getContext();
+
+    context.addTheorem(theorem);
+  }
+
+  addConjecture(conjecture) {
+    const context = this.getContext();
+
+    context.addConjecture(conjecture);
+  }
+
   addTerm(term) {
     const context = this.getContext();
 

package/src/element/assertion/contained.js

@@ -211,10 +211,7 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Validating the '${containedAssertionString}' derived contained assertion...`);
 
-    const generalCotnext = null,
-          specificContext = context;  ///
-
-    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, context);
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${containedAssertionString}' derived contained assertion.`);
@@ -231,10 +228,10 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Unifying the '${containedAssertionString}' contained assertion independently...`);
 
-    const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
-          frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
-          statement = statementFromStatementAndSubstitutions(this.statement, generalContext, specificContext),
-          validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, generalContext, specificContext);
+    const term = termFromTermAndSubstitutions(this.term, context),
+          frame = frameFromFrameAndSubstitutions(this.frame, context),
+          statement = statementFromStatementAndSubstitutions(this.statement, context),
+          validatesWhenDerived = validateWhenDerived(term, frame, statement, this.negated, context);
 
     if (validatesWhenDerived) {
       unifiesIndependently = true;
@@ -281,11 +278,9 @@ export default define(class ContainedAssertion extends Assertion {
   }
 });
 
-function validateWhenDerived(term, frame, statement, negated, generalContext, specificContext) {
+function validateWhenDerived(term, frame, statement, negated, context) {
   let validatesWhenDerived = false;
 
-  const context = specificContext;  ///
-
   if (statement !== null) {
     if (term !== null) {
       const termContained = statement.isTermContained(term, context);

package/src/element/assertion/defined.js

@@ -180,10 +180,7 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Validating the '${definedAssertionString}' derived defined assertion...`);
 
-    const generalContext = null,
-          specificContext = context;  ///
-
-    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, generalContext, specificContext);
+    validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.negated, context);
 
     if (validatesWhenDerived) {
       context.debug(`...validates the '${definedAssertionString}' derived defined assertion.`);
@@ -200,9 +197,9 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Unifying the '${definedAssertionString}' defined assertion independently...`);
 
-    const term = termFromTermAndSubstitutions(this.term, generalContext, specificContext),
-          frame = frameFromFrameAndSubstitutions(this.frame, generalContext, specificContext),
-          validatesWhenDerived = validateWhenDerived(term, frame, this.negated, generalContext, specificContext);
+    const term = termFromTermAndSubstitutions(this.term, context),
+          frame = frameFromFrameAndSubstitutions(this.frame, context),
+          validatesWhenDerived = validateWhenDerived(term, frame, this.negated, context);
 
     if (validatesWhenDerived) {
       unifiesIndependently = true;
@@ -248,10 +245,35 @@ export default define(class DefinedAssertion extends Assertion {
   }
 });
 
-function validateWhenDerived(term, frame, negated, generalContext, specificContext) {
-  let validatesWhenDerived = false;
+function isVariableDefined(variable, context) {
+  const equivalences = context.getEquivalences(),
+        groundedTerms = [],
+        definedVariables = [];
+
+  separateGroundedTermsAndDefinedVariables(equivalences, groundedTerms, definedVariables, context);
+
+  const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+          const definedVariableComparesToVariable = definedVariable.compareVariable(variable);
+
+          if (definedVariableComparesToVariable === variable) {
+            return true;
+          }
+        }),
+        variableDefined = variableMatchesDefinedVariable; ///
+
+  return variableDefined;
+}
+
+function isMetavariableDefined(metavariable, context) {
+  const metavariableNode = metavariable.getNode(),
+        declaredJudgementPresent = context.isDeclaredJudgementPresentByMetavariableNode(metavariableNode),
+        metavariableDefined = declaredJudgementPresent; ///
 
-  const context = specificContext;  ///
+  return metavariableDefined
+}
+
+function validateWhenDerived(term, frame, negated, context) {
+  let validatesWhenDerived = false;
 
   if (term !== null) {
     const variableIdentifier = term.getVariableIdentifier(),
@@ -284,29 +306,3 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   return validatesWhenDerived;
 }
 
-function isVariableDefined(variable, context) {
-  const equivalences = context.getEquivalences(),
-        groundedTerms = [],
-        definedVariables = [];
-
-  separateGroundedTermsAndDefinedVariables(equivalences, groundedTerms, definedVariables, context);
-
-  const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-          const definedVariableComparesToVariable = definedVariable.compareVariable(variable);
-
-          if (definedVariableComparesToVariable === variable) {
-            return true;
-          }
-        }),
-        variableDefined = variableMatchesDefinedVariable; ///
-
-  return variableDefined;
-}
-
-function isMetavariableDefined(metavariable, context) {
-  const metavariableNode = metavariable.getNode(),
-        declaredJudgementPresent = context.isDeclaredJudgementPresentByMetavariableNode(metavariableNode),
-        metavariableDefined = declaredJudgementPresent; ///
-
-  return metavariableDefined
-}

package/src/element/assertion/type.js

@@ -6,6 +6,7 @@ import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
 import { instantiateTypeAssertion } from "../../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
+import { termFromTermAndSubstitutions } from "../../utilities/substitutions";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
@@ -125,10 +126,19 @@ export default define(class TypeAssertion extends Assertion {
       let validatesForwards = false;
 
       const termType = term.getType(),
-            termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(this.type);
+            termTypeEqualToType = termType.isEqualTo(this.type),
+            termTypeSuperTypeOfType = termType.isSuperTypeOf(this.type);
 
-      if (termTypeEqualToOrSuperTypeOfType) {
+      if (false) {
+        ///
+      } else if (termTypeEqualToType) {
         validatesForwards = true;
+      } else if (termTypeSuperTypeOfType) {
+        const termEstablished = term.isEstablished();
+
+        if (termEstablished) {
+          validatesForwards = true;
+        }
       }
 
       return validatesForwards;
@@ -154,22 +164,7 @@ export default define(class TypeAssertion extends Assertion {
 
     context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const term = this.term.validate(context, (term) => {
-      let validatesForwards = false;
-
-      const termType = term.getType(),
-            termTypeProvisional = termType.isProvisional();
-
-      if (!termTypeProvisional) {
-        const termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(this.type);
-
-        if (termTypeEqualToOrSubTypeOfType) {
-          validatesForwards = true;
-        }
-      }
-
-      return validatesForwards;
-    });
+    const term = validateWhenDerived(this.term, this.type, context);
 
     if (term !== null) {
       this.term = term;
@@ -184,6 +179,31 @@ export default define(class TypeAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
+  unifyIndependently(generalContext, specificContext) {
+    let unifiesIndependently = false;
+
+    const context = specificContext, ///
+          typeAssertionString = this.getString(); ///
+
+    context.trace(`Unifying the '${typeAssertionString}' type assertion independently...`);
+
+    let term;
+
+    term = termFromTermAndSubstitutions(this.term, context);
+
+    term = validateWhenDerived(term, this.type, context); //
+
+    if (term !== null) {
+      unifiesIndependently = true;
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${typeAssertionString}' type assertion independently.`);
+    }
+
+    return unifiesIndependently;
+  }
+
   assign(context) {
     const stated = context.isStated();
 
@@ -244,3 +264,26 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertion;
   }
 });
+
+function validateWhenDerived(term, type, context) {
+  if (term !== null) {
+    term = term.validate(context, (term) => {
+      let validatesForwards = false;
+
+      const termType = term.getType(),
+            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+      if (termTypeEqualToOrSubTypeOfType) {
+        const termEstablished = term.isEstablished();
+
+        if (termEstablished) {
+          validatesForwards = true;
+        }
+      }
+
+      return validatesForwards;
+    });
+  }
+
+  return term;
+}

package/src/element/constructor/bracketed.js

@@ -37,10 +37,13 @@ export default define(class BracketedConstructor extends Constructor {
         bracketlessTerm = bracketlessTerm.validate(context, (bracketlessTerm) => {  ///
           let validatesForwards;
 
-          const type = bracketlessTerm.getType();
+          const type = bracketlessTerm.getType(),
+                provisional = bracketlessTerm.isProvisional();
 
           bracketedTerm.setType(type);
 
+          bracketedTerm.setProvisional(provisional);
+
           validatesForwards = validateForwards(bracketedTerm);
 
           return validatesForwards;

package/src/element/constructor.js

@@ -8,6 +8,7 @@ import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
 import { validateTermAsConstructor } from "../process/validate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { provisionallyStringFromProvisional } from "../utilities/string";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
@@ -123,12 +124,16 @@ export default define(class Constructor extends Element {
     if (termUnifiesWithConstructor) {
       let validatesForwards;
 
-      const typeString = this.type.getString();
+      const typeString = this.type.getString(),
+            provisional = this.type.isProvisional(),
+            provisionallyString = provisionallyStringFromProvisional(provisional)
 
-      context.trace(`Setting the '${termString}' term's type to the '${constructorString}' constructor's '${typeString}' type.`);
+      context.trace(`Setting the '${termString}' term's type to the '${constructorString}' constructor's '${typeString}' type${provisionallyString}.`);
 
       term.setType(this.type);
 
+      term.setProvisional(provisional);
+
       validatesForwards = validateForwards(term);
 
       if (validatesForwards) {

package/src/element/declaration/variable.js

@@ -89,6 +89,8 @@ export default define(class VariableDeclaration extends Declaration {
       } else {
         this.variable.setType(type);
 
+        this.variable.setProvisional(this.provisional);
+
         typeVerifies = true;
       }
     }

package/src/element/hypothesis.js

@@ -3,9 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { descend, instantiate } from "../utilities/context";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
+import { declare, attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Hypothesis extends Element {
   constructor(context, string, node, lineIndex, statement) {
@@ -25,95 +25,112 @@ export default define(class Hypothesis extends Element {
     return hypothesisNode;
   }
 
-  compareProofAssertion(proofAssertion, context) {
-    let comparesToProofAssertion = false;
+  async verify(context) {
+    let verifies = false;
 
-    const hypothesisString = this.getString(), ///
-          proofAssertionString = proofAssertion.getString();
+    await this.break(context);
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`);
+    const hypothesisString = this.getString(); ///
 
-    const proofAssertionStatement = proofAssertion.getStatement(),
-          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
+    context.trace(`Verifying the '${hypothesisString}' hypothesis...`);
 
-    if (statementEqualToStepStatement) {
-      comparesToProofAssertion = true;
+    if (this.statement !== null) {
+      const validates = this.validate(context);
+
+      if (validates) {
+        verifies = true;
+      }
+    } else {
+      context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);
     }
 
-    if (comparesToProofAssertion) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`);
+    if (verifies) {
+      context.debug(`...verified the '${hypothesisString}' hypothesis.`);
     }
 
-    return comparesToProofAssertion;
+    return verifies;
   }
 
-  async verify(context) {
-    let verifies = false;
-
-    await this.break(context);
+  validate(context) {
+    let validates = false;
 
     const hypothesisString = this.getString(); ///
 
-    context.trace(`Verifying the '${hypothesisString}' hypothesis...`);
+    context.trace(`Validating the '${hypothesisString}' hypothesis...`);
 
-    if (false) {
-      ///
-    } else if (this.statement !== null) {
-      let statementValidates = false;
+    declare((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      descend((context) => {
-        const statement = this.statement.validate(context);
+        if (statementValidates) {
+          validates = true;
+        }
 
-        if (statement !== null) {
-          statementValidates = true;
+        if (validates) {
+          this.commit(context);
         }
       }, context);
+    }, context)
 
-      if (statementValidates) {
-        const subproofOrProofAssertion = this;  ///
+    if (validates) {
+      context.debug(`...validated the '${hypothesisString}' hypothesis.`);
+    }
 
-        context.assignAssignments();
+    return validates;
+  }
 
-        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+  validateStatement(context) {
+    let statementValidates = false;
 
-        verifies = true;
-      }
-    } else {
-      context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);
+    const hypothesisString = this.getString();
+
+    context.trace(`Validating the '${hypothesisString}' hypothesis's statement... `);
+
+    const statement = this.statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${hypothesisString}' hypothesis.`);
+    if (statementValidates) {
+      context.debug(`...validated the '${hypothesisString}' hypothesis's statement. `);
     }
 
-    return verifies;
+    return statementValidates;
   }
 
   static name = "Hypothesis";
 
   toJSON() {
-    const string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          json = {
-            string,
-            lineIndex
-          };
-
-    return json;
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const string = this.getString(),
+            lineIndex = this.getLineIndex(),
+            json = {
+              context,
+              string,
+              lineIndex
+            };
+
+      return json;
+    }, context);
   }
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string, lineIndex } = json,
-            hypothesisNode = instantiateHypothesis(string, context),
-            node = hypothesisNode,  ///
-            statement = statementFromHypothesisNode(hypothesisNode, context);
+    let hypothesis;
 
-      context = null;
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string, lineIndex } = json,
+              hypothesisNode = instantiateHypothesis(string, context),
+              node = hypothesisNode,  ///
+              statement = statementFromHypothesisNode(hypothesisNode, context);
 
-      const hypothesis = new Hypothesis(context, string, node, lineIndex, statement);
+        hypothesis = new Hypothesis(context, string, node, lineIndex, statement);
+      }, context);
+    }, json, context);
 
-      return hypothesis;
-    }, context);
+    return hypothesis;
   }
 });

package/src/element/metavariable.js

@@ -353,10 +353,13 @@ export default define(class Metavariable extends Element {
           frameUnifies = true;
         }
       } else {
-        const { FrameSubstitution } = elements,
-              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, generalContext, specificContext);
+        const { FrameSubstitution } = elements;
 
-        frameSubstitution.validate(context);
+        let frameSubstitution;
+
+        frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, generalContext, specificContext);
+
+        frameSubstitution = frameSubstitution.validate(context);  ///
 
         const derivedSubstitution = frameSubstitution;  ///
 
@@ -407,12 +410,15 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
       } else {
-        const { StatementSubstitution } = elements,
-              statementSubstitution = (substitution !== null) ?
-                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, generalContext, specificContext) :
-                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, generalContext, specificContext);
+        const { StatementSubstitution } = elements;
+
+        let statementSubstitution;
 
-        statementSubstitution.validate(substitution, context);
+        statementSubstitution = (substitution !== null) ?
+                                  StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, generalContext, specificContext) :
+                                    StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, generalContext, specificContext);
+
+        statementSubstitution = statementSubstitution.validate(substitution, context);  ///
 
         const derivedSubstitution = statementSubstitution;  ///
 
@@ -458,10 +464,13 @@ export default define(class Metavariable extends Element {
           referenceUnifies = true;
         }
       } else {
-        const { ReferenceSubstitution } = elements,
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, generalContext, specificContext);
+        const { ReferenceSubstitution } = elements;
+
+        let referenceSubstitution;
+
+        referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, generalContext, specificContext);
 
-        referenceSubstitution.validate(context);
+        referenceSubstitution = referenceSubstitution.validate(context);  ///
 
         const derivedSubstitution = referenceSubstitution;  ///
 

package/src/element/proofAssertion/step.js

@@ -43,12 +43,6 @@ export default define(class Step extends ProofAssertion {
     return statementNode;
   }
 
-  isSatisfied() {
-    const satisfied = (this.signatureAssertion !== null);
-
-    return satisfied;
-  }
-
   isQualified() {
     const qualified = ((this.reference !== null) || (this.signatureAssertion !== null));