occam-verify-cli 1.0.587 → 1.0.602

package/src/element/assertion.js

@@ -6,4 +6,39 @@ export default class Assertion extends Element {
   constructor(context, string, node) {
     super(context, string, node);
   }
+
+  getAssertionNode() {
+    const node = this.getNode(),
+          assertionNode = node; ///
+
+    return assertionNode;
+  }
+
+  matchAssertionNode(assertionNode) {
+    const assertionNodeA = assertionNode; ///
+
+    assertionNode = this.getAssertionNode();
+
+    const assertionNodeB = assertionNode, ///
+          assertionNodeAAMatchesAssertionBNodeB = assertionNodeA.match(assertionNodeB),
+          equalTo = assertionNodeAAMatchesAssertionBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const assertionNode = this.getAssertionNode(),
+          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode),
+          valid = assertionPresent;  ///
+
+    return valid;
+  }
+
+  isEqualTo(assertion) {
+    const assertionNode = assertion.getNode(),
+      assertionNodeMatches = this.matchAssertionNode(assertionNode),
+      equalTo = assertionNodeMatches;  ///
+
+    return equalTo;
+  }
 }

package/src/element/assumption.js

@@ -33,11 +33,11 @@ export default define(class Assumption extends Element {
     context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
 
     const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(),
+          metavariable = substitution.getMetavariable(generalContext, specificContext),
           statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualToMetavariable(metavariable);
+          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariable(metavariable);
 
-    if (statementEqualToStatement && referenceMetavariableEqualToMetavariable) {
+    if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
       comparesToSubstituion = true;
     }
 
@@ -86,7 +86,7 @@ export default define(class Assumption extends Element {
   validateReference(assignments, stated, context) {
     let referenceValidates;
 
-    const assumptionString = this.getString(),
+    const assumptionString = this.getString(),  ///
           referenceString = this.reference.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
@@ -103,7 +103,7 @@ export default define(class Assumption extends Element {
   validateStatement(assignments, stated, context) {
     let statementValidates;
 
-    const assumptionString = this.getString(),
+    const assumptionString = this.getString(),  ///
           statementString = this.statement.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);

package/src/element/conclusion.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { attempt } from "../utilities/context";
-import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
@@ -101,9 +101,7 @@ export  default define(class Conclusion extends Element {
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    const terms = termsFromJSON(json, context),
-          frames = framesFromJSON(json, context),
-          statement = statementFromJSON(json, context),
+    const statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString();
 

package/src/element/deduction.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { attempt } from "../utilities/context";
-import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, statement) {
@@ -126,9 +126,7 @@ export default define(class Deduction extends Element {
   static name = "Deduction";
 
   static fromJSON(json, context) {
-    const terms = termsFromJSON(json, context),
-          frames = framesFromJSON(json, context),
-          statement = statementFromJSON(json, context),
+    const statement = statementFromJSON(json, context),
           string = statement.getString();
 
     const deduction = new Deduction(context, string, statement);

package/src/element/frame.js

@@ -30,47 +30,71 @@ export default define(class Frame extends Element {
     return metavariableName;
   }
 
-  isSingular() {
+  getFrameNode() {
     const node = this.getNode(),
-          frameNode = node, ///
-          singular = frameNode.isSingular();
+          frameNode = node; ///
 
-    return singular;
+    return frameNode;
   }
 
-  isMetavariableEqualToMetavariable(metavariable, context) {
-    let metavariableEqualToMetavariable;
+  compareMetavariable(metavariable) {
+    let metavaraibleComparseTo = false;
 
     const singular = this.isSingular();
 
     if (singular) {
-      const node = this.getNode(),
-            metavariableA = metavariable, ///
-            singularMetavariableNode = node.getSingularMetavariableNode(),
-            metavariableName = singularMetavariableNode.getMetavariableName();
+      let metavariableName;
 
-      metavariable = context.findMetavariableByMetavariableName(metavariableName)
+      metavariableName = this.metavariable.getName();
 
-      const metavariableB = metavariable,
-            equalTo = metavariableA.isEqualTo(metavariableB);
+      const metavariableNameA = metavariableName ///
 
-      metavariableEqualToMetavariable = equalTo;  ///
+      metavariableName = metavariable.getName();
+
+      const metavariableNameB = metavariableName; ///
+
+      metavaraibleComparseTo = (metavariableNameA === metavariableNameB);
     }
 
-    return metavariableEqualToMetavariable;
+    return metavaraibleComparseTo;
+  }
+
+  matchFrameNode(frameNode) {
+    const frameNodeA = frameNode; ///
+
+    frameNode = this.getFrameNode();
+
+    const frameNodeB = frameNode, ///
+          frameNodeAAMatchesFrameBNodeB = frameNodeA.match(frameNodeB),
+          equalTo = frameNodeAAMatchesFrameBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const frameNode = this.getFrameNode(),
+          framePresent = context.isFramePresentByFrameNode(frameNode),
+          valid = framePresent;  ///
+
+    return valid;
   }
 
   isEqualTo(frame) {
-    const frameA = this, ///
-          frameB = frame, ///
-          frameANode = frameA.getNode(),
-          frameBNode = frameB.getNode(),
-          frameANodeMatchesFrameBNode = frameANode.match(frameBNode),
-          equalTo = frameANodeMatchesFrameBNode; ///
+    const frameNode = frame.getNode(),
+          frameNodeMatches = this.matchFrameNode(frameNode),
+          equalTo = frameNodeMatches;  ///
 
     return equalTo;
   }
 
+  isSingular() {
+    const node = this.getNode(),
+          frameNode = node, ///
+          singular = frameNode.isSingular();
+
+    return singular;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -124,7 +148,7 @@ export default define(class Frame extends Element {
 
     context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
 
-    comparesToSubstitutions = substitutions.everySubstitution((substitution) => {
+    comparesToSubstitutions = substitutions.every((substitution) => {
       const compaaresToSubstitution = this.compareSubstitution(substitution, context);
 
       if (compaaresToSubstitution) {
@@ -146,30 +170,38 @@ export default define(class Frame extends Element {
 
     context.trace(`Validating the '${frameString}' frame...`);
 
-    const assumptionsValidate = this.validateAssumptions(assignments, stated, context),
-          metavariablevalidates = this.validateMetavariable(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (assumptionsValidate && metavariablevalidates) {
-      let validatesWhenStated = false,
-          validatesWhenDerived = false;
+    if (valid) {
+      validates = true;
 
-      if (stated) {
-        validatesWhenStated = this.validateWhenStated(assignments, context);
-      } else {
-        validatesWhenDerived = this.validateWhenDerived(context);
-      }
+      context.debug(`...the '${frameString}' frame is already valid.`);
+    } else {
+      const assumptionsValidate = this.validateAssumptions(assignments, stated, context),
+            metavariablevalidates = this.validateMetavariable(assignments, stated, context);
+
+      if (assumptionsValidate && metavariablevalidates) {
+        let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+        if (stated) {
+          validatesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          validatesWhenDerived = this.validateWhenDerived(context);
+        }
 
-      if (validatesWhenStated || validatesWhenDerived) {
-        validates = true;
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const frame = this; ///
+      if (validates) {
+        const frame = this; ///
 
-      context.addFrame(frame);
+        context.addFrame(frame);
 
-      context.debug(`...validated the '${frameString}' frame.`);
+        context.debug(`...validated the '${frameString}' frame.`);
+      }
     }
 
     return validates;

package/src/element/judgement.js

@@ -31,6 +31,8 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
+  compareMetavariable(metavariable) { return this.frame.compareMetavariable(metavariable); }
+
   validate(assignments, stated, context) {
     let validates = false;
 

package/src/element/label.js

@@ -20,14 +20,14 @@ export default define(class Label extends Element {
 
   getMetavariableNode() { return this.metavariable.getNode(); }
 
-  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
+  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
   compareReference(reference) {
     const metavariable = reference.getMetavariable(),
-          metavariableEqualToMetavariable = this.isMetavariableEqualToMetavariable(metavariable),
-          comparesToReference = metavariableEqualToMetavariable; ///
+          metavariableComparesToMetavariable = this.compareMetavariable(metavariable),
+          comparesToReference = metavariableComparesToMetavariable; ///
 
     return comparesToReference;
   }

package/src/element/metavariable.js

@@ -9,6 +9,7 @@ import { EMPTY_STRING } from "../constants";
 import { typeToTypeJSON } from "../utilities/json";
 import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
+import {get} from "necessary/lib/utilities/ajax";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, type, metaType) {
@@ -39,10 +40,11 @@ export default define(class Metavariable extends Element {
     this.metaType = metaType;
   }
 
-  isNameEqualTo(name) {
-    const nameEqualTo = (name === this.name);
+  compare(metavariable) {
+    const name = metavariable.getName(),
+          comparesToMetavariable = (this.name === name);
 
-    return nameEqualTo;
+    return comparesToMetavariable;
   }
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
@@ -129,11 +131,15 @@ export default define(class Metavariable extends Element {
       } else {
         const { FrameSubstitution } = elements,
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
-              substitution = frameSubstitution; ///
+              framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
 
-        context.addSubstitution(substitution);
+        if (framesubstitutionValidates) {
+          const substitution = frameSubstitution; ///
+
+          context.addSubstitution(substitution);
 
-        frameUnifies = true;
+          frameUnifies = true;
+        }
       }
     }
 
@@ -154,6 +160,8 @@ export default define(class Metavariable extends Element {
                                   substitution.getString() :
                                     EMPTY_STRING;
 
+
+
     context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const metavariable = this, ///
@@ -162,11 +170,10 @@ export default define(class Metavariable extends Element {
     if (statementMetavariableUnifies) {
       statementUnifies = true;
     } else {
-      const context = specificContext,  ///
-            substitutionPresent = context.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
+      const substitutionPresent = context.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
 
       if (substitutionPresent) {
-        substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
+        substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution, generalContet, specificContext); ///
 
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
@@ -179,11 +186,23 @@ export default define(class Metavariable extends Element {
                                         StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
                                           StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
-        substitution = statementSubstitution; ///
+        if (substitution !== null) {
+          const context = generalContext; ///
 
-        context.addSubstitution(substitution);
+          substitution = statementSubstitution.getSubstitution();
+
+          substitution.setContext(context);
+        }
+
+        const statementSubstitutionValidates = statementSubstitution.validate(generalContext, specificContext);
 
-        statementUnifies = true;
+        if (statementSubstitutionValidates) {
+          const substitution = statementSubstitution; ///
+
+          context.addSubstitution(substitution);
+
+          statementUnifies = true;
+        }
       }
     }
 
@@ -194,7 +213,7 @@ export default define(class Metavariable extends Element {
     return statementUnifies;
   }
 
-  unifyReference(reference, substitutions, generalContext, specificContext) {
+  unifyReference(reference, generalContext, specificContext) {
     let referenceUnifies = false;
 
     const context = specificContext,  ///
@@ -204,15 +223,15 @@ export default define(class Metavariable extends Element {
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
     const metavariable = this, ///
-          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
+          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariable(metavariable);
 
       if (simpleSubstitutionPresent) {
-        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
+        const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable),
               substitution = simpleSubstitution,  ///
               substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
@@ -268,15 +287,19 @@ export default define(class Metavariable extends Element {
     let frameMetavariableUnifies = false;
 
     const context = specificContext,  ///
-          generalContextFilePath = generalContext.getFilePath(),
+          frameString = frame.getString(),
+          metavariableString = this.getString();  ///
+
+    context.trace(`Unifying the '${frameString}' frame's metavariable with the '${metavariableString}' metavariable...`);
+
+    const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = metavariable.getString(),
-            frameMetavariableEqualToMetvariable = frame.isMetavariableEqualToMetavariable(metavariable, context);
+            frameMetavariableComparesToMetvariable = frame.compareMetavariable(metavariable);
 
-      if (frameMetavariableEqualToMetvariable) {
+      if (frameMetavariableComparesToMetvariable) {
         frameMetavariableUnifies = true;
       } else {
         const frameSingular = frame.isSingular();
@@ -284,99 +307,95 @@ export default define(class Metavariable extends Element {
         if (frameSingular) {
           const frameMetavariableName = frame.getMetavariableName(),
                 frameMetavariable = context.findMetavariableByMetavariableName(frameMetavariableName),
-                frameMetavariableString = frameMetavariable.getString();
-
-          context.trace(`Unifying the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
-
-          const generalMetavariable = this, ///
+                generalMetavariable = this, ///
                 specificMetavariable = frameMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
           frameMetavariableUnifies = metavariableUnifiesIntrinsically; ///
-
-          if (frameMetavariableUnifies) {
-            context.debug(`...unified the frame's '${frameMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
-          }
         }
       }
     }
 
+    if (frameMetavariableUnifies) {
+      context.debug(`...unified the '${frameString}' frame's metavariable with the '${metavariableString}' metavariable.`);
+    }
+
     return frameMetavariableUnifies;
   }
 
-  unifyStatementMetavariable(statement, generalContext, specificContext) {
-    let statementMetavariableUnifies = false;
+  unifyReferenceMetavariable(reference, generalContext, specificContext) {
+    let referenceMetavariableUnifies = false;
 
     const context = specificContext,  ///
-          generalContextFilePath = generalContext.getFilePath(),
+          referenceString = reference.getString(),
+          metavariableString = this.getString();
+
+    context.trace(`Unifying the '${referenceString}' reference's metavariable with the '${metavariableString}' metavariable...`);
+
+    const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = metavariable.getString(),
-            statementMetavariableEqualToMetvariable = statement.isMetavariableEqualToMetavariable(metavariable, context);
+            referenceMetavariableComparesToMetvariable = reference.compareMetavariable(metavariable);
 
-      if (statementMetavariableEqualToMetvariable) {
-        statementMetavariableUnifies = true;
+      if (referenceMetavariableComparesToMetvariable) {
+        referenceMetavariableUnifies = true;
       } else {
-        const statementSingular = statement.isSingular();
-
-        if (statementSingular) {
-          const statementMetavariableName = statement.getMetavariableName(),
-                statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
-                statementMetavariableString = statementMetavariable.getString();
-
-          context.trace(`Unifying the statement's ${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
-
-          const generalMetavariable = this, ///
-                specificMetavariable = statementMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
-
-          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+        const referenceMetavariable = reference.getMetavariable(),
+              generalMetavariable = this, ///
+              specificMetavariable = referenceMetavariable, ///
+              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
-          if (statementMetavariableUnifies) {
-            context.debug(`...unified the statement's '${statementMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
-          }
-        }
+        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
       }
     }
 
-    return statementMetavariableUnifies;
+    if (referenceMetavariableUnifies) {
+      context.trace(`...unified the '${referenceString}' reference's metavariable with the '${metavariableString}' metavariable.`);
+    }
+
+    return referenceMetavariableUnifies;
   }
 
-  unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext) {
-    let referenceMetavariableUnifies = false;
+  unifyStatementMetavariable(statement, generalContext, specificContext) {
+    let statementMetavariableUnifies = false;
 
     const context = specificContext,  ///
-          generalContextFilePath = generalContext.getFilePath(),
+          statementString = statement.getString(),
+          metavariableString = this.getString();  ///
+
+    context.trace(`Unifying the '${statementString}' statement's metavariable with the '${metavariableString}' metavariable...`);
+
+    const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = metavariable.getString(),
-            referenceMetavariableEqualToMetvariable = reference.isMetavariableEqualToMetavariable(metavariable);
+            statementMetavariableComparesToMetvariable = statement.compareMetavariable(metavariable);
 
-      if (referenceMetavariableEqualToMetvariable) {
-        referenceMetavariableUnifies = true;
+      if (statementMetavariableComparesToMetvariable) {
+        statementMetavariableUnifies = true;
       } else {
-        const referenceMetavariable = reference.getMetavariable(),
-              referenceMetavariableString = referenceMetavariable.getString();
-
-        context.trace(`Unifying the reference's ${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable...`);
-
-        const generalMetavariable = this, ///
-              specificMetavariable = referenceMetavariable, ///
-              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+        const statementSingular = statement.isSingular();
 
-        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+        if (statementSingular) {
+          const statementMetavariableName = statement.getMetavariableName(),
+                statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
+                generalMetavariable = this, ///
+                specificMetavariable = statementMetavariable, ///
+                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
-        if (referenceMetavariableUnifies) {
-          context.debug(`...unified the reference's '${referenceMetavariableString}' metavariable with the '${metavariableString}' metavariable.`);
+          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
         }
       }
     }
 
-    return referenceMetavariableUnifies;
+    if (statementMetavariableUnifies) {
+      context.debug(`...unified the '${statementString}' statement's metavariable with the '${metavariableString}' metavariable.`);
+    }
+
+    return statementMetavariableUnifies;
   }
 
   toJSON() {

package/src/element/procedureCall.js

@@ -78,7 +78,7 @@ export default define(class ProcedureCall extends Element {
           terms = termsFromPrimitives(primitives),
           procedure = context.findProcedureByName(name);
 
-    // try {
+    try {
       const term = await procedure.call(terms, context),
             boolean = term.isBoolean();
 
@@ -91,11 +91,11 @@ export default define(class ProcedureCall extends Element {
           unifiesIndependently = true;
         }
       }
-    // } catch (exception) {
-    //   const message = exception.getMessage();
-    //
-    //   context.info(message);
-    // }
+    } catch (exception) {
+      const message = exception.getMessage();
+
+      context.info(message);
+    }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${procedureCallString}' procedure call independently.`);

package/src/element/proof.js

@@ -26,21 +26,21 @@ export default define(class Proof extends Element {
     return statement;
   }
 
-  async verify(conclusion, context) {
+  async verify(statement, context) {
     let verifies = false;
 
-    asyncScope(async (context) => {
+    await asyncScope(async (context) => {
       const derivationVerifies = await this.derivation.verify(context);
 
       if (derivationVerifies) {
         const lastProofAssertion = context.getLastProofAssertion();
 
         if (lastProofAssertion !== null) {
-          const statement = this.getStatement(),
-                conclusionStatement = conclusion.getStatement(),
-                conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
+          const proof = this, ///
+                proofStatement = proof.getStatement(),
+                proofStatementEqualToStatement = proofStatement.isEqualTo(statement);
 
-          if (conclusionStatementEqualToStatement) {
+          if (proofStatementEqualToStatement) {
             verifies = true;
           }
         }