occam-verify-cli 1.0.924 → 1.0.932

package/src/element/section.js

@@ -1,38 +1,26 @@
 "use strict";
 
-import { Element } from "occam-languages";
+import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
+import {enclose} from "../utilities/context";
+
+const { asyncEvery } = asynchronousUtilities;
 
 export default define(class Section extends Element {
-  constructor(context, string, node, lineIndex, hypotheses, axiom, lemma, theorem, conjecture) {
+  constructor(context, string, node, lineIndex, hypotheses, topLevelAssertion) {
     super(context, string, node, lineIndex);
 
     this.hypotheses = hypotheses;
-    this.axiom = axiom;
-    this.lemma = lemma;
-    this.theorem = theorem;
-    this.conjecture = conjecture;
+    this.topLevelAssertion = topLevelAssertion;
   }
 
   getHypotheses() {
     return this.hypotheses;
   }
 
-  getAxiom() {
-    return this.axiom;
-  }
-
-  getLemma() {
-    return this.lemma;
-  }
-
-  getTheorem() {
-    return this.theorem;
-  }
-
-  getConjecture() {
-    return this.conjecture;
+  getTopLevelAssertion() {
+    return this.topLevelAssertion;
   }
 
   getSectionNode() {
@@ -45,22 +33,27 @@ export default define(class Section extends Element {
   async verify(context) {
     let verifies = false;
 
+    await this.break(context);
+
     const sectionString = this.getString();  ///
 
     context.trace(`Verifying the '${sectionString}' section...`);
 
-    const hypothesesVerify = this.verifyHypotheses();
+    await enclose(async (context) => {
+      const hypothesesVerify = await this.verifyHypotheses(context);
 
-    if (hypothesesVerify) {
-      const topLevelAssertion = (this.axiom || this.lemma || this.theorem || this.conjecture),
-            topLevelAssertionVerifies = await topLevelAssertion.verify(context);
+      if (hypothesesVerify) {
+        context.assignAssignments();
 
-      if (topLevelAssertionVerifies) {
-        topLevelAssertion.setHypotheses(this.hypotheses);
+        const topLevelAssertionVerifies = await this.topLevelAssertion.verify(context);
 
-        verifies = true;
+        if (topLevelAssertionVerifies) {
+          this.topLevelAssertion.setHypotheses(this.hypotheses);
+
+          verifies = true;
+        }
       }
-    }
+    }, context);
 
     if (verifies) {
       context.debug(`...verified the '${sectionString}' section.`);
@@ -69,9 +62,9 @@ export default define(class Section extends Element {
     return verifies;
   }
 
-  verifyHypotheses() {
-    const hypothesesVerify = this.hypotheses.every((hypothesis) => {
-      const hypothesisVerifies = hypothesis.verify(this.context);
+  async verifyHypotheses(context) {
+    const hypothesesVerify = await asyncEvery(this.hypotheses, async (hypothesis) => {
+      const hypothesisVerifies = await hypothesis.verify(context);
 
       if (hypothesisVerifies) {
         return true;

package/src/element/statement.js

@@ -7,7 +7,6 @@ import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
-import {getEntryStats} from "necessary/lib/utilities/fileSystem";
 
 export default define(class Statement extends Element {
   getStatementNode() {
@@ -307,9 +306,20 @@ export default define(class Statement extends Element {
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
     const statementNode = this.getStatementNode(),
+          typeAssertionNode = statementNode.getTypeAssertionNode(),
           definedAssertionNode = statementNode.getDefinedAssertionNode(),
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
+    if (typeAssertionNode !== null) {
+      const context = generalContext, ///
+            typeAssertion = context.findAssertionByAssertionNode(typeAssertionNode),
+            typeAssertionUnifiesIndependently = typeAssertion.unifyIndependently(generalContext, specificContext);
+
+      if (typeAssertionUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
     if (definedAssertionNode !== null) {
       const context = generalContext, ///
             definedAssertion = context.findAssertionByAssertionNode(definedAssertionNode),

package/src/element/substitution/statement.js

@@ -257,29 +257,29 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
 
-    context = complexSubstitution.getContext();
-
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
+    const simpleSubstitution = this,  ///
+          simpleSubstitutionGSpecificContext = simpleSubstitution.getSpecificContext(),
+          complexSubstitutionGSpecificContext = complexSubstitution.getSpecificContext(),
+          generalContext = simpleSubstitutionGSpecificContext,  ///
+          specificContext = complexSubstitutionGSpecificContext;  ///
 
     let simpleSubstitutionUnifies = false;
 
-    reconcile((specificContext) => {
-      const replacementStatement = complexSubstitution.getReplacementStatement(),
-            replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
+    join((context) => {
+      const specificContext = context;  ///
 
-      if (replacementStatementUnifies) {
-        const context = specificContext,  ///
-              soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
+      reconcile((specificContext) => {
+        const replacementStatement = complexSubstitution.getReplacementStatement(),
+              replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
 
-        substitution = soleNonTrivialDerivedSubstitution;  ///
-      }
-    }, specificContext);
+        if (replacementStatementUnifies) {
+          const context = specificContext,  ///
+                soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
+
+          substitution = soleNonTrivialDerivedSubstitution;  ///
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (substitution !== null) {
       substitution = substitution.validate(context);  ///
@@ -320,8 +320,9 @@ export default define(class StatementSubstitution extends Substitution {
     let resolved = false;
 
     const metavariableNode = this.getMetavariableNode(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariableNode(metavariableNode),
-          complexSubstitution = this; ///
+          simpleDerivedSubstitution = context.findSimpleDerivedSubstitutionByMetavariableNode(metavariableNode), ///
+          complexSubstitution = this,
+          simpleSubstitution = simpleDerivedSubstitution; ///
 
     if (simpleSubstitution !== null) {
       const substitutionString = this.getString(); ///
@@ -331,7 +332,8 @@ export default define(class StatementSubstitution extends Substitution {
       const substitution = simpleSubstitution.unifyComplexSubstitution(complexSubstitution, context);
 
       if (substitution !== null) {
-        const simpleSubstitutionUnifies = complexSubstitution.unifySimpleSubstitution(substitution, context);
+        const simpleSubstitution = substitution,  ///
+              simpleSubstitutionUnifies = complexSubstitution.unifySimpleSubstitution(simpleSubstitution, context);
 
         if (simpleSubstitutionUnifies) {
           resolved = true;

package/src/element/substitution.js

@@ -165,6 +165,30 @@ export default class Substitution extends Element {
     return metavariableNode;
   }
 
+  getReplacementTerm() {
+    const replacementTerm = null;
+
+    return replacementTerm;
+  }
+
+  getReplacementFrame() {
+    const replacementFrame = null;
+
+    return replacementFrame;
+  }
+
+  getReplacementStatement() {
+    const replacementStatement = null;
+
+    return replacementStatement;
+  }
+
+  getReplacementReference() {
+    const replacementReference = null;
+
+    return replacementReference;
+  }
+
   isSimple() {
     const simple = true;
 

package/src/element/term.js

@@ -9,25 +9,34 @@ import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { variablesFromTerm } from "../utilities/equivalence";
 import { unifyTermIntrinsically } from "../process/unify";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { typeFromJSON, typeToTypeJSON, provisionalFromJSON, provisionalToProvisionalJSON } from "../utilities/json";
 
 const { filter } = arrayUtilities;
 
 export default define(class Term extends Element {
-  constructor(context, string, node, lineIndex, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, lineIndex, type, provisional) {
+    super(context, string, node, lineIndex, provisional);
 
     this.type = type;
+    this.provisional = provisional;
   }
 
   getType() {
     return this.type;
   }
 
+  isProvisional() {
+    return this.provisional;
+  }
+
   setType(type) {
     this.type = type;
   }
 
+  setProvisional(provisional) {
+    this.provisional = provisional;
+  }
+
   getTermNode() {
     const node = this.getNode(),
           termNode = node;  ///
@@ -49,6 +58,13 @@ export default define(class Term extends Element {
     return variableIdentifier;
   }
 
+  isEstablished() {
+    const provisional = this.isProvisional(),
+          established = !provisional;
+
+    return established;
+  }
+
   isEqualTo(term) {
     const termNode = term.getNode(),
           termNodeMatches = this.matchTermNode(termNode),
@@ -83,8 +99,6 @@ export default define(class Term extends Element {
     return singular;
   }
 
-  isProvisional() { return this.type.isProvisional(); }
-
   isInitiallyGrounded(context) {
     const term  = this, ///
           variables = variablesFromTerm(term, context),
@@ -110,7 +124,7 @@ export default define(class Term extends Element {
   }
 
   matchVariableNode(variableNode) {
-    let varialbeNodeMatches = false;
+    let variableNodeMatches = false;
 
     const singular = this.isSingular();
 
@@ -123,11 +137,11 @@ export default define(class Term extends Element {
             variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
 
       if (variableNodeAMatchesVariableNodeB) {
-        varialbeNodeMatches = true; ///
+        variableNodeMatches = true; ///
       }
     }
 
-    return varialbeNodeMatches;
+    return variableNodeMatches;
   }
 
   compareTerm(term) {
@@ -273,13 +287,16 @@ export default define(class Term extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
+          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
           string = this.getString(), ///
           lineIndex = this.getLineIndex(),
           type = typeJSON,  ///
+          provisional = provisionalJSON,  ///
           json = {
             string,
             lineIndex,
-            type
+            type,
+            provisional
           };
 
     return json;
@@ -292,11 +309,12 @@ export default define(class Term extends Element {
       const { string, lineIndex } = json,
             termNode = instantiateTerm(string, context),
             node = termNode,  ///
-            type = typeFromJSON(json, context);
+            type = typeFromJSON(json, context),
+            provisional = provisionalFromJSON(json, context);
 
       context = null;
 
-      const term = new Term(context, string, node, lineIndex, type);
+      const term = new Term(context, string, node, lineIndex, type, provisional);
 
       return term;
     }, context);

package/src/element/topLevelAssertion.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { enclose } from "../utilities/context";
-import { topLevelAssertionStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
+import { topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction } from "../utilities/string";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -65,6 +65,12 @@ export default class TopLevelAssertion extends Element {
     return supposition;
   }
 
+  isSatisfiable() {
+    const satisfiable = false;
+
+    return satisfiable;
+  }
+
   isHypothetical() {
     const hypothesesLength = this.hypotheses.length,
           hypothetical = (hypothesesLength > 0);
@@ -374,7 +380,7 @@ export default class TopLevelAssertion extends Element {
           suppositions = suppositionsFromJSON(json, context),
           signature = signatureFromJSON(json, context),
           hypotheses = hypothesesFromJSON(json, context),
-          topLevelAssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+          topLevelAssertionString = topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction),
           node = null,
           proof = null,
           string = topLevelAssertionString, ///

package/src/element/type.js

@@ -103,11 +103,11 @@ export default define(class Type extends Element {
     this.provisional = provisional;
   }
 
-  replaceSuperType(superType, index) {
-    const start = index,
-          deleteCount = 1;
+  isEstablished(includeSuperTypes = true) {
+    const provisional = this.isProvisional(includeSuperTypes),
+          established = !provisional;
 
-    this.superTypes.splice(start, deleteCount, superType);
+    return established;
   }
 
   isPrefixed() {

package/src/element/variable.js

@@ -7,29 +7,39 @@ import elements from "../elements";
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { variableFromTermNode, identifierFromVarialbeNode } from "../utilities/element";
+import { provisionallyStringFromProvisional } from "../utilities/string";
+import { variableFromTermNode, identifierFromVariableNode } from "../utilities/element";
+import { typeFromJSON, typeToTypeJSON, provisionalFromJSON, provisionalToProvisionalJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
-  constructor(context, string, node, lineIndex, type, identifier) {
+  constructor(context, string, node, lineIndex, type, identifier, provisional) {
     super(context, string, node, lineIndex);
 
     this.type = type;
     this.identifier = identifier;
+    this.provisional = provisional;
+  }
+
+  getType() {
+    return this.type;
   }
 
   getIdentifier() {
     return this.identifier;
   }
 
-  getType() {
-    return this.type;
+  isProvisional() {
+    return this.provisional;
   }
 
   setType(type) {
     this.type = type;
   }
 
+  setProvisional(provisional) {
+    this.provisional = provisional;
+  }
+
   getVariableNode() {
     const node = this.getNode(),
           variableNode = node;  //
@@ -39,6 +49,13 @@ export default define(class Variable extends Element {
 
   getTypeString() { return this.type.getString(); }
 
+  isEstablished() {
+    const provisional = this.isProvisional(),
+          established = !provisional;
+
+    return established;
+  }
+
   isIdentifierEqualTo(identifier) {
     const identifierEqualTo = (this.identifier === identifier);
 
@@ -83,12 +100,16 @@ export default define(class Variable extends Element {
     if (declaredVariable !== null) {
       const type = declaredVariable.getType(),
             typeString = type.getString(),
-            variableString = this.getString();  ///
+            provisional = declaredVariable.isProvisional(),
+            variableString = this.getString(),  ///
+            provisinallyString = provisionallyStringFromProvisional(provisional);
 
-      context.trace(`Setting the '${variableString}' variable's type to the '${typeString}' type.`);
+      context.trace(`Setting the '${variableString}' variable's type to the '${typeString}' type${provisinallyString}.`);
 
       this.type = type;
 
+      this.provisional = provisional;
+
       variable = this;
 
       validates = true;
@@ -112,74 +133,89 @@ export default define(class Variable extends Element {
 
     context.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
-    let variable,
-        derivedSubstitution;
+    const variable = this,  ///
+          termVariableUnifies = this.unifyTermVariable(term, generalContext, specificContext);
 
-    variable = this; ///
+    if (termVariableUnifies) {
+      termUnifies = true;
+    } else {
+      const variableNode = variable.getNode(),
+            derivedSubstitution = context.findDerivedSubstitutionByVariableNode(variableNode);
 
-    const variableNode = variable.getNode();
+      if (derivedSubstitution !== null) {
+        const derivedSubstitutionTermComparesToTerm = derivedSubstitution.compareTerm(term, context);
 
-    derivedSubstitution = context.findDerivedSubstitutionByVariableNode(variableNode);
+        if (derivedSubstitutionTermComparesToTerm) {
+          const derivedSubstitutionString = derivedSubstitution.getString();
 
-    if (derivedSubstitution !== null) {
-      const derivedSubstitutionComparesToTerm = derivedSubstitution.compareTerm(term, context);
+          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
 
-      if (derivedSubstitutionComparesToTerm) {
-        const derivedSubstitutionString = derivedSubstitution.getString();
+          termUnifies = true;
+        }
+      } else {
+        const { TermSubstitution } = elements;
 
-        context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
+        let termSubstitution;
 
-        termUnifies = true;
-      }
-    } else {
-      let context;
+        termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, generalContext, specificContext);
 
-      context = generalContext;  ///
+        termSubstitution = termSubstitution.validate(context);  ///
 
-      const variableNode = variable.getNode();
+        const derivedSubstitution = termSubstitution;  ///
 
-      variable = context.findVariableByVariableNode(variableNode);
+        context.addDerivedSubstitution(derivedSubstitution);
 
-      context = specificContext;  ///
+        termUnifies = true;
+      }
+    }
 
-      const termNode = term.getNode();
+    if (termUnifies) {
+      context.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
+    }
 
-      term = context.findTermByTermNode(termNode);
+    return termUnifies;
+  }
 
-      const termType = term.getType(),
-            variableType = variable.getType(),
-            termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
+  unifyTermVariable(term, generalContext, specificContext) {
+    let termVariableUnifies = false;
 
-      if (termTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = elements,
-              termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, generalContext, specificContext);
+    const context = specificContext,  ///
+          termString = term.getString(),
+          variableString = this.getString();  ///
 
-        termSubstitution.validate(context);
+    context.trace(`Unifying the '${termString}' term's variable with the '${variableString}' variable...`);
 
-        const derivedSubstitution = termSubstitution; ///
+    const generalContextFilePath = generalContext.getFilePath(),
+          specificContextFilePath = specificContext.getFilePath();
 
-        context.addDerivedSubstitution(derivedSubstitution);
+    if (generalContextFilePath === specificContextFilePath) {
+      const variableNode = this.getVariableNode(),  ///
+            variableNodeMatches = term.matchVariableNode(variableNode);
 
-        termUnifies = true;
+      if (variableNodeMatches) {
+        termVariableUnifies = true;
       }
     }
 
-    if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
+    if (termVariableUnifies) {
+      context.debug(`...unified the '${termString}' term's variable with the '${variableString}' variable.`);
     }
 
-    return termUnifies;
+    return termVariableUnifies;
   }
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          type = typeJSON,  ///
+          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
           string = this.getString(), ///
           lineIndex = this.getLineIndex(),
+          type = typeJSON,  ///
+          provisional = provisionalJSON,  ///
           json = {
             string,
             lineIndex,
-            type
+            type,
+            provisional
           };
 
     return json;
@@ -193,11 +229,12 @@ export default define(class Variable extends Element {
             variableNode = instantiateVariable(string, context),
             node = variableNode,  ///
             type = typeFromJSON(json, context),
-            identifier = identifierFromVarialbeNode(variableNode, context);
+            identifier = identifierFromVariableNode(variableNode, context),
+            provisional = provisionalFromJSON(json, context);
 
       context = null;
 
-      const variable = new Variable(context, string, node, lineIndex, type, identifier);
+      const variable = new Variable(context, string, node, lineIndex, type, identifier, provisional);
 
       return variable;
     }, context);

package/src/utilities/assignment.js

@@ -11,19 +11,45 @@ export function variableAssignmentFromTermAndType(term, type, context) {
 
   if (termSingular) {
     const termType = term.getType(),
+          termTypeEqualToType = termType.isEqualTo(type),
           termTypeSuperTypeOfType = termType.isSuperTypeOf(type);
 
-    if (termTypeSuperTypeOfType) {
-      const variableNode = term.getVariableNode(),
-            variable = variableFromVariableNode(variableNode, context);
+    if (false) {
+      ///
+    } else if (termTypeEqualToType) {
+      const termProvisional = term.isProvisional();
 
-      variable.setType(type);
+      if (termProvisional) {
+        const type = term.getType(),
+              variableNode = term.getVariableNode(),
+              variable = variableFromVariableNode(variableNode, context),
+              provisional = false;
 
-      variableAssignment = (context) => {
-        const declaredVariable = variable;  ///
+        variable.setType(type);
 
-        context.addDeclaredVariable(declaredVariable);
-      };
+        variable.setProvisional(provisional);
+
+        variableAssignment = (context) => {
+          const declaredVariable = variable;  ///
+
+          context.addDeclaredVariable(declaredVariable);
+        };
+      }
+    } else if (termTypeSuperTypeOfType) {
+      const termEstablished = term.isEstablished();
+
+      if (termEstablished) {
+        const variableNode = term.getVariableNode(),
+              variable = variableFromVariableNode(variableNode, context);
+
+        variable.setType(type);
+
+        variableAssignment = (context) => {
+          const declaredVariable = variable;  ///
+
+          context.addDeclaredVariable(declaredVariable);
+        };
+      }
     }
   }