occam-verify-cli 1.0.727 → 1.0.730

package/src/context/scoped.js

@@ -8,13 +8,14 @@ import elements from "../elements";
 const { last } = arrayUtilities;
 
 class ScopedContext extends Context {
-  constructor(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions) {
+  constructor(context, variables, judgements, assignments, equivalences, substitutions, subproofOrProofAssertions) {
     super(context);
 
     this.variables = variables;
     this.judgements = judgements;
     this.assignments = assignments;
     this.equivalences = equivalences;
+    this.substitutions = substitutions;
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
@@ -68,6 +69,10 @@ class ScopedContext extends Context {
     return equivalences;
   }
 
+  getSubstitutions() {
+    return this.substitutions;
+  }
+
   getSubproofOrProofAssertions() {
     let subproofOrProofAssertions;
 
@@ -109,6 +114,20 @@ class ScopedContext extends Context {
     return lastProofAssertion;
   }
 
+  hasMetaLevelSubstitutions() {
+    let metaLevelSubstitutions;
+
+    if (this.substitutions !== null) {
+      metaLevelSubstitutions = true;
+    } else {
+      const context = this.getContext();
+
+      metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
+    }
+
+    return metaLevelSubstitutions;
+  }
+
   addEquality(equality) {
     const context = this, ///
           equalityString = equality.getString();
@@ -155,6 +174,39 @@ class ScopedContext extends Context {
     this.assignments.push(assignment);
   }
 
+  addSubstitution(substitution, scoped = true) {
+    if (this.substitutions === null) {
+      const context = this.getContext();
+
+      context.addSubstitution(substitution);
+
+      return;
+    }
+
+    const context = this, ///
+          substitutionA = substitution, ///
+          substitutionString = substitution.getString();
+
+    context.trace(`Adding the '${substitutionString}' substitution to the scoped context...`);
+
+    const substitutionB = this.substitutions.find((substitution) => {
+      const substitutionB = substitution, ///
+            substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+
+      if (substitutionAEqualToSubstitutionB) {
+        return true;
+      }
+    }) || null;
+
+    if (substitutionB !== null) {
+      context.debug(`The '${substitutionString}' substitution has already been added to the scoped context.`);
+    } else {
+      this.substitutions.push(substitution);
+
+      context.debug(`...added the '${substitutionString}' substitution to the scoped context.`);
+    }
+  }
+
   assignAssignments() {
     const context = this; ///
 
@@ -251,14 +303,14 @@ class ScopedContext extends Context {
     return comparesToTermAndPropertyRelation;
   }
 
-  static fromNothing(context) {
+  static fromSubstitutions(substitutions, context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
           assignments = [],
           equivalences = Equivalences.fromNothing(context),
           subproofOrProofAssertions = [],
-          scopedContext = new ScopedContext(context, variables, judgements, assignments, equivalences, subproofOrProofAssertions);
+          scopedContext = new ScopedContext(context, variables, judgements, assignments, equivalences, substitutions, subproofOrProofAssertions);
 
     return scopedContext;
   }

package/src/context.js

@@ -290,13 +290,6 @@ export default class Context extends ContextBase {
     return labelPresent;
   }
 
-  isMetavariablePresentByReference(reference) {
-    const context = this.getContext(),
-          metavariablePresent = context.isMetavariablePresentByReference(reference);
-
-    return metavariablePresent;
-  }
-
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
           termPresent = context.isTermPresentByTermNode(termNode);
@@ -381,6 +374,13 @@ export default class Context extends ContextBase {
     return procedurePresent;
   }
 
+  hasMetaLevelSubstitutions() {
+    const context = this.getContext(),
+          metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
+
+    return metaLevelSubstitutions;
+  }
+
   addTerm(term) {
     const context = this.getContext();
 
@@ -417,10 +417,10 @@ export default class Context extends ContextBase {
     context.addAssignment(assignment);
   }
 
-  addSubstitution(substitution) {
+  addSubstitution(substitution, metaLevel = false) {
     const context = this.getContext();
 
-    context.addSubstitution(substitution);
+    context.addSubstitution(substitution, metaLevel);
   }
 
   addSubproofOrProofAssertion(subproofOrProofAssertion) {

package/src/element/assumption.js

@@ -172,7 +172,8 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' stated assumption...`);
 
-    const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
+    const metavariable = this.reference.getMetavariable(),
+          metavariablePresent = context.isMetavariablePresent(metavariable, context);
 
     if (metavariablePresent) {
       validatesWhenStated = true;

package/src/element/declaration/metavariable.js

@@ -3,7 +3,6 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { verifyMetavariable } from "../../process/verify";
 
 export default define(class MetavariableDeclaration extends Declaration {
   constructor(context, string, node, metaType, metavariable) {

package/src/element/metavariable.js

@@ -161,8 +161,11 @@ export default define(class Metavariable extends Element {
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
-        const metavariableName = this.name, ///
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        let metavariable;
+
+        metavariable = this;  ///
+
+        metavariable = context.findMetavariable(metavariable, context);  ///
 
         if (metavariable !== null) {
           const metaType = metavariable.getMetaType();
@@ -240,9 +243,9 @@ export default define(class Metavariable extends Element {
 
       if (simpleSubstitution !== null) {
         const substitution = simpleSubstitution,  ///
-              substitutionFrameEqualToFrame = substitution.isFrameEqualToFrame(frame);
+              substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
-        if (substitutionFrameEqualToFrame) {
+        if (substitutionFrameComparesToFrame) {
           frameUnifies = true;
         }
       } else {
@@ -291,7 +294,7 @@ export default define(class Metavariable extends Element {
       const metavariableName = metavariable.getName(),
             substitutionPresent = (substitution !== null) ?
                                     context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) :
-                                      context.findSubstitutionByMetavariableName(metavariableName);
+                                      context.isSubstitutionPresentByMetavariableName(metavariableName);
 
       if (substitutionPresent) {
         substitution = (substitution !== null) ?
@@ -355,9 +358,9 @@ export default define(class Metavariable extends Element {
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
               substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
+              substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
-        if (substitutionReferenceEqualToReference) {
+        if (substitutionReferenceComparesToReference) {
           referenceUnifies = true;
         }
       } else {

package/src/element/proofAssertion/premise.js

@@ -165,7 +165,7 @@ export default define(class Premise extends ProofAssertion {
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
     const proofAssertionContext = proofAssertion.getContext(),
-          premiseContext = this.getContext(),
+          premiseContext = this.getContext(), ///
           generalContext = premiseContext, ///
           specificContext = proofAssertionContext,
           statementUnifies = liminally((specificContext) => {

package/src/element/proofAssertion/step.js

@@ -188,22 +188,19 @@ export default define(class Step extends ProofAssertion {
 
     const statement = this.getStatement(),
           reference = this.getReference(),
-          satisfiesAssertion = this.getSatisfiesAssertion(),
-          statementUnifies = await asyncLiminally(async (context) => {
-            const statementUnifies = await asyncSome(unifyStatements, async (unifyStatement) => {
-              const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
+          satisfiesAssertion = this.getSatisfiesAssertion();
 
-              if (statementUnifies) {
-                return true;
-              }
-            });
+    await asyncLiminally(async (context) => {
+      await asyncSome(unifyStatements, async (unifyStatement) => {
+        const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
 
-            return statementUnifies;
-          }, context);
+        if (statementUnifies) {
+          unifies = true;
 
-    if (statementUnifies) {
-      unifies = true;
-    }
+          return true;
+        }
+      });
+    }, context);
 
     if (unifies) {
       context.debug(`...unified the '${stepString}' step.`);

package/src/element/proofAssertion/supposition.js

@@ -192,7 +192,7 @@ export default define(class Supposition extends ProofAssertion {
           specificContext = proofAssertionContext,
           statementUnifies = liminally((specificContext) => {
             const statement = proofAssertion.getStatement(),
-              statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
             if (statementUnifies) {
               specificContext.commit(context);

package/src/element/reference.js

@@ -141,14 +141,7 @@ export default define(class Reference extends Element {
           const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
 
           if (metavariableMetaTypeEqualToReferenceMetaType) {
-            const reference = this, ///
-                  metavariablePresent = context.isMetavariablePresentByReference(reference);
-
-            if (metavariablePresent) {
-              validates = true;
-            } else {
-              context.debug(`There is no metavariable for the '${referenceString}' reference.`);
-            }
+            validates = true;
           } else {
             const metaTypeString = metaType.getString(),
                   metavariableString = this.metavariable.getString(),

package/src/element/rule.js

@@ -172,7 +172,7 @@ export default define(class Rule extends Element {
 
       const statement = this.conclusion.getStatement();
 
-      proofVerifies = this.proof.verify(statement, context);
+      proofVerifies = await this.proof.verify(statement, context);
 
       if (proofVerifies) {
         context.debug(`...verified the '${ruleString}' rule's proof.`);
@@ -232,14 +232,15 @@ export default define(class Rule extends Element {
   async verifyConclusion(context) {
     let conclusionVerifies;
 
-    const ruleString = this.getString();  ///
+    const ruleString = this.getString(),  ///
+          conclusionString = this.conclusion.getString();
 
-    context.trace(`Verifying the '${ruleString}' rule's conclusion...`);
+    context.trace(`Verifying the '${ruleString}' rule's '${conclusionString}' conclusion...`);
 
     conclusionVerifies = await this.conclusion.verify(context);
 
     if (conclusionVerifies) {
-      context.debug(`...verified the '${ruleString}' rule's conclusion.`);
+      context.debug(`...verified the '${ruleString}' rule's '${conclusionString}' conclusion.`);
     }
 
     return conclusionVerifies;

package/src/element/subproof.js

@@ -64,22 +64,10 @@ export default define(class Subproof extends Element {
     let verifies = false;
 
     await asyncScope(async (context) => {
-      const suppositionsVerify = await asyncEvery(this.suppositions, async (supposition) => {
-        const suppositionVerifies = await supposition.verify(context);
-
-        if (suppositionVerifies) {
-          const subproofOrProofAssertion = supposition;  ////
-
-          context.assignAssignments(context);
-
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-
-          return true;
-        }
-      });
+      const suppositionsVerify = await this.verifySuppositions(context);
 
       if (suppositionsVerify) {
-        const subDerivationVerifies = await this.subDerivation.verify(context);
+        const subDerivationVerifies = await this.verifySubDerivation(context);
 
         if (subDerivationVerifies) {
           verifies = true;
@@ -90,6 +78,40 @@ export default define(class Subproof extends Element {
     return verifies;
   }
 
+  async verifySupposition(supposition, context) {
+    const suppositionVerifies = await supposition.verify(context);
+
+    if (suppositionVerifies) {
+      const subproofOrProofAssertion = supposition;  ////
+
+      context.assignAssignments(context);
+
+      context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+    }
+
+    return suppositionVerifies;
+  }
+
+  async verifySuppositions(context) {
+    let suppositionsVerify;
+
+    suppositionsVerify = await asyncEvery(this.suppositions, async (supposition) => {
+      const suppositionVerifies = await this.verifySupposition(supposition, context);
+
+      if (suppositionVerifies) {
+        return true;
+      }
+    });
+
+    return suppositionsVerify;
+  }
+
+  async verifySubDerivation(context) {
+    const subDerivationVerifies = await this.subDerivation.verify(context);
+
+    return subDerivationVerifies;
+  }
+
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 

package/src/element/substitution/statement.js

@@ -259,59 +259,61 @@ export default define(class StatementSubstitution extends Substitution {
 
     const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-    context = this.getContext();
+    if (simpleSubstitution !== null) {
+      context = this.getContext();
 
-    const subtitution = liminally((context) => {
-      let substitution = null;
+      const subtitution = liminally((context) => {
+        let substitution = null;
 
-      const specificContext = context;  ///
+        const specificContext = context;  ///
 
-      context = simpleSubstitution.getContext();
+        context = simpleSubstitution.getContext();
 
-      const generalContext = context; ///
+        const generalContext = context; ///
 
-      context = specificContext;  ///
+        context = specificContext;  ///
 
-      const replacementStatementUnifies = simpleSubstitution.unifyReplacementStatement(this.replacementStatement, generalContext, specificContext);
+        const replacementStatementUnifies = simpleSubstitution.unifyReplacementStatement(this.replacementStatement, generalContext, specificContext);
 
-      if (replacementStatementUnifies) {
-        const nested = false,
-              soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
+        if (replacementStatementUnifies) {
+          const nested = false,
+                soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
 
-        substitution = soleNonTrivialSubstitution;  ///
-      }
+          substitution = soleNonTrivialSubstitution;  ///
+        }
 
-      return substitution;
-    }, context);
+        return substitution;
+      }, context);
 
-    if (subtitution !== null) {
-      liminally((specificContext) => {
-        const contexts = [];
+      if (subtitution !== null) {
+        liminally((specificContext) => {
+          const contexts = [];
 
-        context = simpleSubstitution.getContext();
+          context = simpleSubstitution.getContext();
 
-        contexts.push(context);
+          contexts.push(context);
 
-        context = this.getContext();
+          context = this.getContext();
 
-        contexts.push(context);
+          contexts.push(context);
 
-        context = specificContext;  ///
+          context = specificContext;  ///
 
-        synthetically((context) => {
-          const specificContext = context;  ///
+          synthetically((context) => {
+            const specificContext = context;  ///
 
-          context = this.substitution.getContext();
+            context = this.substitution.getContext();
 
-          const generalContext = context; ///
+            const generalContext = context; ///
 
-          this.unifySubstitution(subtitution, generalContext, specificContext);
-        }, contexts, context);
+            this.unifySubstitution(subtitution, generalContext, specificContext);
+          }, contexts, context);
 
-        specificContext.commit();
-      }, specificContext);
+          specificContext.commit();
+        }, specificContext);
 
-      this.resolved = true;
+        this.resolved = true;
+      }
     }
 
     if (this.resolved) {

package/src/element/substitution.js

@@ -96,42 +96,6 @@ export default class Substitution extends Element {
     return simple;
   }
 
-  isTermEqualToTerm(term) {
-    const termEqualToTerm = false;
-
-    return termEqualToTerm;
-  }
-
-  isFrameEqualToFrame(frame) {
-    const frameEqualToFrame = false;
-
-    return frameEqualToFrame;
-  }
-
-  isStatementEqualToStatement(statement) {
-    const statementEqualToStatement = false;
-
-    return statementEqualToStatement;
-  }
-
-  isReferenceEqualToReference(reference) {
-    const referenceEqualToReference = false;
-
-    return referenceEqualToReference;
-  }
-
-  compareTerm(term, context) {
-    const comparesToTerm = false;
-
-    return comparesToTerm;
-  }
-
-  compareStatement(statement) {
-    const comparesToStatement = false;
-
-    return comparesToStatement;
-  }
-
   compareParameter(parameter) {
     const comparesToParameter = false;
 

package/src/element/topLevelAssertion.js

@@ -232,7 +232,7 @@ export default class TopLevelAssertion extends Element {
 
       const statement = this.deduction.getStatement();
 
-      proofVerifies = this.proof.verify(statement, context);
+      proofVerifies = await this.proof.verify(statement, context);
 
       if (proofVerifies) {
         context.debug(`...verified the '${topLevelAssertionString}' top level assertion's proof.`);
@@ -245,14 +245,15 @@ export default class TopLevelAssertion extends Element {
   async verifyDeduction(context) {
     let deductionVerifies;
 
-    const topLevelAssertionString = this.getString(); ///
+    const deductionString = this.deduction.getString(),
+          topLevelAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's deduction...`);
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
 
     deductionVerifies = await this.deduction.verify(context);
 
     if (deductionVerifies) {
-      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's deduction.`);
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
     }
 
     return deductionVerifies;

package/src/element/topLevelMetaAssertion.js

@@ -81,7 +81,7 @@ export default class TopLevelMetaAssertion extends Element {
           }
         }
       }
-    }, context);
+    }, this.substitutions, context);
 
     if (verifies) {
       context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
@@ -111,20 +111,16 @@ export default class TopLevelMetaAssertion extends Element {
   async verifyProof(context) {
     let proofVerifies;
 
-    if (this.proof === null) {
-      proofVerifies = true;
-    } else {
-      const topLevelMetaAssertionString = this.getString();  ///
+    const topLevelMetaAssertionString = this.getString();  ///
 
-      context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's proof...`);
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's proof...`);
 
-      const statement = this.deduction.getStatement();
+    const statement = this.deduction.getStatement();
 
-      proofVerifies = this.proof.verify(statement, context);
+    proofVerifies = await this.proof.verify(statement, context);
 
-      if (proofVerifies) {
-        context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's proof.`);
-      }
+    if (proofVerifies) {
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's proof.`);
     }
 
     return proofVerifies;
@@ -133,14 +129,15 @@ export default class TopLevelMetaAssertion extends Element {
   async verifyDeduction(context) {
     let deductionVerifies;
 
-    const topLevelMetaAssertionString = this.getString(); ///
+    const deductionString = this.deduction.getString(),
+          topLevelMetaAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's deduction...`);
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's '${deductionString}' deduction...`);
 
     deductionVerifies = await this.deduction.verify(context);
 
     if (deductionVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's deduction.`);
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's '${deductionString}' deduction.`);
     }
 
     return deductionVerifies;

package/src/utilities/context.js

@@ -38,8 +38,14 @@ export function synthetically(innerFunction, contexts, context) {
   return innerFunction(context);
 }
 
-export async function asyncScope(innerFunction, context) {
-  const scopedContext = ScopedContext.fromNothing(context);
+export async function asyncScope(innerFunction, substitutions, context) {
+  if (context === undefined) {
+    context = substitutions;  ///
+
+    substitutions = null;
+  }
+
+  const scopedContext = ScopedContext.fromSubstitutions(substitutions, context);
 
   context = scopedContext;  ///
 

package/src/utilities/element.js

@@ -529,7 +529,7 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
         topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         node = metatheoremNode, ///
         string = topLevelMetaAssertionString, ///
-        substitutions = null,
+        substitutions = substitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, substitutions);
 
   return metatheorem;
@@ -676,6 +676,12 @@ export function subproofAssertionFromSubproofAssertionNode(subproofAssertionNode
   return subproofAssertion;
 }
 
+export function substitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const substitutions = [];
+
+  return substitutions;
+}
+
 export function containedAssertionFromContainedAssertionNode(containedAssertionNode, context) {
   const { ContainedAssertion } = elements,
         node = containedAssertionNode,  ///

package/src/utilities/json.js

@@ -641,7 +641,7 @@ export function suppositionsFromJSON(json, context) {
 }
 
 export function substitutionsFromJSON(json, context) {
-  let { substitutions = [] } = json;  ///
+  let { substitutions } = json;  ///
 
   const { StatementSubstitution } = elements,
         substitutionsJSON = substitutions,  ///

package/src/utilities/statement.js

@@ -2,7 +2,6 @@
 
 import { equalityFromStatementNode,
          judgementFromStatementNode,
-         metavariableFromStatementNode,
          typeAssertionFromStatementNode,
          definedAssertionFromStatementNode,
          propertyAssertionFromStatementNode,