occam-verify-cli 1.0.587 → 1.0.602

package/src/element/topLevelAssertion.js

@@ -4,7 +4,9 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 import { asynchronousUtilities } from "occam-languages";
 
-import { asyncScope, asyncAttempt } from "../utilities/context";
+import assignAssignments from "../process/assign";
+
+import { asyncScope } from "../utilities/context";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -16,8 +18,8 @@ import { labelsFromJSON,
          hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { asyncEvery } = asynchronousUtilities,
-      { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
+const { extract, reverse, correlate } = arrayUtilities,
+      { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
@@ -123,7 +125,14 @@ export default class TopLevelAssertion extends Element {
   }
 
   verifyLabels() {
-    const labelsVerify = this.labels.every((label) => {
+    let labelsVerify;
+
+    const context = this.getContext(),
+          topLevelAssertionString = this.getString();
+
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's labels...`);
+
+    labelsVerify = this.labels.every((label) => {
       const nameOnly = true,
             labelVerifies = label.verify(nameOnly);
 
@@ -132,13 +141,42 @@ export default class TopLevelAssertion extends Element {
       }
     });
 
+    if (labelsVerify) {
+      context.trace(`...verified the '${topLevelAssertionString}' top level assertion's labels.`);
+    }
+
     return labelsVerify;
   }
 
+  unifyStatementWithDeduction(statement, context) {
+    let statementUnifiesWithDeduction = false;
+
+    const statementString = statement.getString(),
+          deductionString = this.deduction.getString(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
+
+    const statementUnifies = this.deduction.unifyStatement(statement, context);
+
+    if (statementUnifies) {
+      statementUnifiesWithDeduction = true;
+    }
+
+    if (statementUnifiesWithDeduction) {
+      context.debug(`...unified the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
+    }
+
+    return statementUnifiesWithDeduction;
+  }
+
   async verify() {
     let verifies = false;
 
-    const context = this.getContext();
+    const context = this.getContext(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion...`);
 
     await asyncScope(async (context) => {
       const labelsVerify = this.verifyLabels();
@@ -160,72 +198,103 @@ export default class TopLevelAssertion extends Element {
       }
     }, context);
 
+    if (verifies) {
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion.`);
+    }
+
     return verifies;
   }
 
-  async verifySuppositions(context) {
-    const suppositionsVerify = await asyncEvery(this.suppositions, async (supposition) => {
-      const suppositionVerifies = await this.verifySupposition(supposition, context);
+  async verifyProof(context) {
+    let proofVerifies;
 
-      if (suppositionVerifies) {
-        return true;
-      }
-    });
+    if (this.proof === null) {
+      proofVerifies = true;
+    } else {
+      const topLevelAssertionString = this.getString();  ///
 
-    return suppositionsVerify;
-  }
+      context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's proof...`);
+
+      const statement = this.deduction.getStatement();
 
-  async verifySupposition(supposition, context) {
-    const suppositionVerifies = await supposition.verify(context);
+      proofVerifies = this.proof.verify(statement, context);
 
-    return suppositionVerifies;
+      if (proofVerifies) {
+        context.debug(`...verified the '${topLevelAssertionString}' top level assertion's proof.`);
+      }
+    }
+
+    return proofVerifies;
   }
 
   async verifyDeduction(context) {
-    const deductionVerifies = await this.deduction.verify(context);
+    let deductionVerifies;
 
-    return deductionVerifies;
-  }
+    const topLevelAssertionString = this.getString(); ///
 
-  async verifyProof(context) {
-    let proofVerifies = true; ///
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's deduction...`);
 
-    if (this.proof !== null) {
-      proofVerifies = await asyncAttempt(async (context) => {
-        const proofVerifies = await this.proof.verify(this.deduction, context);
+    deductionVerifies = await this.deduction.verify(context);
 
-        return proofVerifies;
-      }, context);
+    if (deductionVerifies) {
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's deduction.`);
     }
 
-    return proofVerifies;
+    return deductionVerifies;
   }
 
-  unifyStatementWithDeduction(statement, substitutions, context) {
-    let statementUnifiesWithDeduction = false;
+  async verifySuppositions(context) {
+    let suppositionsVerify;
 
-    const statementUnifies = this.deduction.unifyStatement(statement, substitutions, context);  ///
+    const topLevelAssertionString = this.getString();  ///
 
-    if (statementUnifies) {
-      statementUnifiesWithDeduction = true;
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's suppositions...`);
+
+    suppositionsVerify = await asyncForwardsEvery(this.suppositions, async (supposition) => {
+      const assignments = [],
+            suppositionVerifies = await supposition.verify(assignments, context)
+
+      if (suppositionVerifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const subproofOrProofAssertion = supposition;  ////
+
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+
+          return true;
+        }
+      }
+    });
+
+    if (suppositionsVerify) {
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's suppositions.`);
     }
 
-    return statementUnifiesWithDeduction;
+    return suppositionsVerify;
   }
 
-  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context) {
+  async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
     let statementAndSubproofOrProofAssertionsUnify = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
 
     if (correlatesToHypotheses) {
-      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
+      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
 
       if (statementUnifiesWithDeduction) {
-        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, substitutions, context);
+        const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
+
+        if (subproofOrProofAssertionsUnifiesWithSuppositions) {
+          const specificContext = context;  ///
+
+          context = this.getContext();
 
-        if (subproofOrProofAssertionsUnifyWithSuppositions) {
-          const substitutionsResolved = substitutions.areResolved();
+          const generalContext = context; ///
+
+          context = specificContext;  ///
+
+          const substitutionsResolved = context.areSubstitutionsResolved(generalContext, specificContext);
 
           if (substitutionsResolved) {
             statementAndSubproofOrProofAssertionsUnify = true;
@@ -237,14 +306,24 @@ export default class TopLevelAssertion extends Element {
     return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
+  async unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
     if (!subproofOrProofAssertionsUnifiesWithSupposition) {
       const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
+        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
+          const specificContext = context;  ///
+
+          context = this.getContext();
+
+          const generalContext = context; ///
+
+          context = specificContext;  ///
+
+          context.resolveSubstitutions(generalContext, specificContext);
+
           return true;
         }
       }) || null;
@@ -255,8 +334,7 @@ export default class TopLevelAssertion extends Element {
     }
 
     if (!subproofOrProofAssertionsUnifiesWithSupposition) {
-      const context = specificContext,  ///
-            suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
+      const suppositionUnifiesIndependently = await supposition.unifyIndependently(context);
 
       if (suppositionUnifiesIndependently) {
         subproofOrProofAssertionsUnifiesWithSupposition = true;
@@ -266,18 +344,20 @@ export default class TopLevelAssertion extends Element {
     return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
-  unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
+  async unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context) {
+    let subproofOrProofAssertionsUnifiesWithSuppositions;
+
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const subproofOrProofAssertionsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
+    subproofOrProofAssertionsUnifiesWithSuppositions = asyncBackwardsEvery(this.suppositions, async (supposition) => {
+      const stepUnifiesWithSupposition = await this.unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context);
 
-      if (subproofOrProofAssertionsUnifiesWithSupposition) {
+      if (stepUnifiesWithSupposition) {
         return true;
       }
     });
 
-    return subproofOrProofAssertionsUnifyWithSuppositions;
+    return subproofOrProofAssertionsUnifiesWithSuppositions;
   }
 
   toJSON() {

package/src/element/topLevelMetaAssertion.js

@@ -2,7 +2,9 @@
 
 import { Element } from "occam-languages";
 
-import { scope } from "../utilities/context";
+import assignAssignments from "../process/assign";
+
+import { asyncScope } from "../utilities/context";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -53,22 +55,44 @@ export default class TopLevelMetaAssertion extends Element {
     return comparesToReference;
   }
 
-  verify() {
+  verifyLabel() {
+    let labelVerifies;
+
+    const context = this.getContext(),
+          topLevelMetaAssertionString = this.getString(); ///
+
+    context.trace(`Verifiesing the '${topLevelMetaAssertionString}' top level meta assertion's label...`);
+
+    const nameOnly = true;
+
+    labelVerifies = this.label.verify(nameOnly);
+
+    if (labelVerifies) {
+      context.trace(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's label.`);
+    }
+
+    return labelVerifies;
+  }
+
+  async verify() {
     let verifies = false;
 
-    const context = this.getContext();
+    const context = this.getContext(),
+          topLevelMetaAssertionString = this.getString(); ///
+
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion...`);
 
-    scope((context) => {
+    await asyncScope(async (context) => {
       const labelVerifies = this.verifyLabel();
 
       if (labelVerifies) {
-        const suppositionsVerify = this.verifySuppositions(context);
+        const suppositionsVerify = await this.verifySuppositions(context);
 
         if (suppositionsVerify) {
-          const deductionVerifies = this.verifyDeduction(context);
+          const deductionVerifies = await this.verifyDeduction(context);
 
           if (deductionVerifies) {
-            const proofVerifies = this.verifyProof(context);
+            const proofVerifies = await this.verifyProof(context);
 
             if (proofVerifies) {
               verifies = true;
@@ -78,50 +102,80 @@ export default class TopLevelMetaAssertion extends Element {
       }
     }, context);
 
+    if (verifies) {
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
+    }
+
     return verifies;
   }
 
-  verifyLabel() {
-    const nameOnly = false,
-          labelVerifies = this.label.verify(nameOnly);
+  async verifyProof(context) {
+    let proofVerifies;
 
-    return labelVerifies;
-  }
+    if (this.proof === null) {
+      proofVerifies = true;
+    } else {
+      const topLevelMetaAssertionString = this.getString();  ///
 
-  verifySuppositions(context) {
-    const suppositionsVerify = this.suppositions.every((supposition) => {
-      const suppositionVerifies = this.verifySupposition(supposition, context);
+      context.trace(`Verifying the '${topLevelMetaAssertionString}' top meta level assertion's proof...`);
 
-      if (suppositionVerifies) {
-        return true;
+      const statement = this.deduction.getStatement();
+
+      proofVerifies = this.proof.verify(statement, context);
+
+      if (proofVerifies) {
+        context.debug(`...verified the '${topLevelMetaAssertionString}' top meta level assertion's proof.`);
       }
-    });
+    }
 
-    return suppositionsVerify;
+    return proofVerifies;
   }
 
-  verifySupposition(supposition, context) {
-    const suppositionVerifies = supposition.verify(context);
+  async verifyDeduction(context) {
+    let deductionVerifies;
 
-    return suppositionVerifies;
-  }
+    const topLevelMetaAssertionString = this.getString(); ///
+
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's deduction...`);
 
-  verifyDeduction(context) {
-    const deductionVerifies = this.deduction.verify(context);
+    deductionVerifies = await this.deduction.verify(context);
+
+    if (deductionVerifies) {
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's deduction.`);
+    }
 
     return deductionVerifies;
   }
 
-  verifyProof(context) {
-    let proofVerifies;
+  async verifySuppositions(context) {
+    let suppositionsVerify;
 
-    if (this.proof === null) {
-      proofVerifies = true;
-    } else {
-      proofVerifies = this.proof.verify(this.substitutions, this.deduction, context);
+    const topLevelMetaAssertionString = this.getString();  ///
+
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's suppositions...`);
+
+    suppositionsVerify = await asyncForwardsEvery(this.suppositions, async (supposition) => {
+      const assignments = [],
+            suppositionVerifies = await supposition.verify(assignments, context)
+
+      if (suppositionVerifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const subproofOrProofAssertion = supposition;  ////
+
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+
+          return true;
+        }
+      }
+    });
+
+    if (suppositionsVerify) {
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's suppositions.`);
     }
 
-    return proofVerifies;
+    return suppositionsVerify;
   }
 
   toJSON() {

package/src/element/variable.js

@@ -38,6 +38,13 @@ export default define(class Variable extends Element {
     return identifierEqualTo;
   }
 
+  compare(variable) {
+    const variableIdentifier = variable.getIdentifier(),
+          comparesTo = (this.identifier === variableIdentifier);
+
+    return comparesTo;
+  }
+
   compareParamter(parameter) {
     const identifier = parameter.getIdentifier(),
           identifierEqualTo = this.isIdentifierEqualTo(identifier),
@@ -120,7 +127,7 @@ export default define(class Variable extends Element {
 
     variable = this; ///
 
-    substitution = substitutions.findSubstitutionByVariable(variable);
+    substitution = substitutions.findSubstitutionByVariable(variable, generalContext, specificContext);
 
     if (substitution !== null) {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);
@@ -149,13 +156,16 @@ export default define(class Variable extends Element {
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
         const { TermSubstitution } = elements,
-              termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, context);
+              termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, context),
+              termSubstitutionValidates = termSubstitution.validate(generalContext, specificContext);
 
-        substitution = termSubstitution;  ///
+        if (termSubstitutionValidates) {
+          substitution = termSubstitution;  ///
 
-        context.addSubstitution(substitution);
+          context.addSubstitution(substitution);
 
-        termUnifies = true;
+          termUnifies = true;
+        }
       }
     }
 

package/src/node/substitution/statement.js

@@ -5,6 +5,39 @@ import SubstitutionNode from "../../node/substitution";
 import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class StatementSubstitutionNode extends SubstitutionNode {
+  isResolved() {
+    let resolved = true;
+
+    const substitutionNode = this.getSubstitutionNode();
+
+    if (substitutionNode !== null) {
+      resolved = false;
+    }
+
+    return resolved;
+  }
+
+  getSubstitutionNode() {
+    const targetStatementNode = this.getTargetStatementNode(),
+      substitutionNode = targetStatementNode.getSubstitutionNode();
+
+    return substitutionNode;
+  }
+
+  getTermSubstitutionNode() {
+    const targetStatementNode = this.getTargetStatementNode(),
+          termSubstitutionNode = targetStatementNode.getTermSubstitutionNode();
+
+    return termSubstitutionNode;
+  }
+
+  getFrameSubstitutionNode() {
+    const targetStatementNode = this.getTargetStatementNode(),
+          frameSubstitutionNode = targetStatementNode.getFrameSubstitutionNode();
+
+    return frameSubstitutionNode;
+  }
+
   getTargetStatementNode() {
     const lastStatementNode = this.getLastStatementNode(),
           targetStatementNode = lastStatementNode; ///

package/src/process/unify.js

@@ -67,11 +67,9 @@ class MetaLevelPass extends ZipPass {
 
         statementNode = metavariableNodeParentNode; ///
 
-        const frameSubstitutionNode = statementNode.getFrameSubstitutionNode(),
-              termSubstitutionNode = statementNode.getTermSubstitutionNode(),
-              substitutionNode = (frameSubstitutionNode || termSubstitutionNode),
+        const substitutionNode = statementNode.getSubstitutionNode(),
               substitution = (substitutionNode !== null) ?
-                               context.findSubstitutionBySubstitutionNode(substitutionNode) :
+                               context.findSubstitutionBySubstitutionNode(substitutionNode, generalContext, specificContext) :
                                  null;
 
         context = specificContext; ///
@@ -354,14 +352,14 @@ export function unifyStatement(generalStatement, specificStatement, generalConte
   return statementUnifies;
 }
 
-export function unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext) {
+export function unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext) {
   let substitutionUnifies = false;
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
         specificSubstitutionNode = specificSubstitution.getNode(),
         generalNode = generalSubstitutionNode, ///
         specificNode = specificSubstitutionNode,  ///
-        success = metaLevelPass.run(generalNode, specificNode, substitutions, generalContext, specificContext);
+        success = metaLevelPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = true;
@@ -399,14 +397,14 @@ export function unifyTermWithConstructor(term, constructor, generalContext, spec
   return termUnifiesWithConstructor;
 }
 
-export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
+export function unifyStatementIntrinsically(generalStatement, specificStatement, generalContext, specificContext) {
   let statementUnifiesIntrinsically = false;
 
   const generalStatementNode = generalStatement.getNode(),
         specificStatementNode = specificStatement.getNode(),
         generalNode = generalStatementNode, ///
         specificNode = specificStatementNode, ///
-        success = intrinsicLevelPass.run(generalNode, specificNode, substitutions, generalContext, specificContext);
+        success = intrinsicLevelPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     statementUnifiesIntrinsically = true;

package/src/utilities/context.js

@@ -4,6 +4,7 @@ import ScopedContext from "../context/scoped";
 import LiminalContext from "../context/liminal";
 import LiteralContext from "../context/literal";
 import EphemeralContext from "../context/ephemeral";
+import SyntheticContext from "../context/synthetic";
 
 export function scope(innerFunction, context) {
   const scopedContext = ScopedContext.fromNothing(context);
@@ -37,6 +38,14 @@ export function literally(innerFunction, context) {
   return innerFunction(context);
 }
 
+export function synthetically(innerFunction, contexts, context) {
+  const syntheticContext = SyntheticContext.fromContexts(contexts, context);
+
+  context = syntheticContext;  ///
+
+  return innerFunction(context);
+}
+
 export async function asyncScope(innerFunction, context) {
   const scopedContext = ScopedContext.fromNothing(context);
 
@@ -61,11 +70,3 @@ export async function asyncLiminally(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export async function asyncLiterally(innerFunction, context) {
-  const literalContext = LiteralContext.fromNothing(context);
-
-  context = literalContext;  ///
-
-  return await innerFunction(context);
-}
-