occam-verify-cli 1.0.635 → 1.0.638

package/src/element/reference.js

@@ -54,12 +54,12 @@ export default define(class Reference extends Element {
     return equalTo;
   }
 
-  isValid(context) {
+  findValidRefernece(context) {
     const metavariableNode = this.getMetavariableNode(),
-          referencePresent = context.isReferencePresentByMetavariableNode(metavariableNode),
-          valid = referencePresent;  ///
+          reference = context.findReferenceByMetavariableNode(metavariableNode),
+          validReference = reference;  ///
 
-    return valid;
+    return validReference;
   }
 
   isEqualTo(reference) {
@@ -111,38 +111,48 @@ export default define(class Reference extends Element {
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   validate(context) {
-    let validates = false;
+    let reference = null;
 
     const referenceString = this.getString(); ///
 
     context.trace(`Validating the '${referenceString}' reference...`);
 
-    if (!validates) {
-      const metavariableValidates = this.validateMetavariable(context);
+    const validRefernece = this.findValidRefernece(context);
 
-      if (metavariableValidates) {
-        validates = true;
+    if (validRefernece !== null) {
+      reference = validRefernece; ///
+
+      context.debug(`...the '${referenceString}' reference is alrady valid.`);
+    } else {
+      let validates = false;
+
+      if (!validates) {
+        const metavariableValidates = this.validateMetavariable(context);
+
+        if (metavariableValidates) {
+          validates = true;
+        }
       }
-    }
 
-    if (!validates) {
-      const reference = this, ///
-            labelPresent = context.isLabelPresentByReference(reference);
+      if (!validates) {
+        const reference = this, ///
+              labelPresent = context.isLabelPresentByReference(reference);
 
-      if (labelPresent) {
-        validates = true; ///
+        if (labelPresent) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const reference = this; ///
+      if (validates) {
+        const reference = this; ///
 
-      context.addReference(reference);
+        context.addReference(reference);
 
-      context.debug(`...validated the '${referenceString}' reference.`);
+        context.debug(`...validated the '${referenceString}' reference.`);
+      }
     }
 
-    return validates;
+    return reference;
   }
 
   validateMetavariable(context) {

package/src/element/rule.js

@@ -3,8 +3,6 @@
 import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import assignAssignments from "../process/assign";
-
 import { define } from "../elements";
 import { asyncScope } from "../utilities/context";
 import { labelsFromJSON,
@@ -180,14 +178,13 @@ export default define(class Rule extends Element {
     context.trace(`Verifying the '${ruleString}' rule's premises...`);
 
     premisesVerify = await asyncForwardsEvery(this.premises, async (premise) => {
-      const assignments = [],
-            premiseVerifies = await premise.verify(assignments, context)
+      const premiseVerifies = await premise.verify(context)
 
       if (premiseVerifies) {
-        assignAssignments(assignments, context);
-
         const subproofOrProofAssertion = premise;  ////
 
+        context.assignAssignments();
+
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
         return true;

package/src/element/signature.js

@@ -28,23 +28,34 @@ export default define(class Signature extends Element {
   }
 
   verify(context) {
-    let verifies;
+    let verifies = false;
 
     const signatureString = this.getString();  ///
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    verifies = this.terms.every((term) => {
-      const termValidates = term.validate(context, () => {
-        const validatesForwards = true;
+    const terms = [],
+          termsValidate = this.terms.every((term) => {
+            term = term.validate(context, () => { ///
+              const validatesForwards = true;
 
-        return validatesForwards;
-      });
+              return validatesForwards;
+            });
 
-      if (termValidates) {
-        return true;
-      }
-    });
+            const termValidates = (term !== null);
+
+            if (termValidates) {
+              terms.push(term);
+
+              return true;
+            }
+          });
+
+    if (termsValidate) {
+      this.terms = terms;
+
+      verifies = true;
+    }
 
     if (verifies) {
       context.debug(`...verified the '${signatureString}' signature.`);

package/src/element/statement.js

@@ -62,12 +62,12 @@ export default define(class Statement extends Element {
     return comparesToMetavariableName;
   }
 
-  isValid(context) {
+  findValidStatment(context) {
     const statementNode = this.getStatementNode(),
-          statementPresent = context.isStatementPresentByStatementNode(statementNode),
-          valid = statementPresent;  ///
+          statement = context.findStatementByStatementNode(statementNode),
+          validStatement = statement;  ///
 
-    return valid;
+    return validStatement;
   }
 
   isEqualTo(statement) {
@@ -172,23 +172,23 @@ export default define(class Statement extends Element {
     return comparesToMetavariableName;
   }
 
-  validate(assignments, stated, context) {
-    let validates;
+  validate(stated, context) {
+    let statement = null;
 
     const statementString = this.getString();  ///
 
     context.trace(`Validating the '${statementString}' statement...`);
 
-    const valid = this.isValid(context);
+    const validStatement = this.findValidStatment(context);
 
-    if (valid) {
-      validates = true;
+    if (validStatement !== null) {
+      statement = validStatement; ///
 
       context.debug(`...the '${statementString}' statement is alrady valid.`);
     } else {
-      validates = validateStatements.some((validateStatement) => {
+      const validates = validateStatements.some((validateStatement) => {
         const statement = this, ///
-              statementValidates = validateStatement(statement, assignments, stated, context);
+              statementValidates = validateStatement(statement, stated, context);
 
         if (statementValidates) {
           return true;
@@ -204,10 +204,10 @@ export default define(class Statement extends Element {
       }
     }
 
-    return validates;
+    return statement;
   }
 
-  validateGivenMetaType(metaType, assignments, stated, context) {
+  validateGivenMetaType(metaType, stated, context) {
     let validatesGivenMetaType = false;
 
     const metaTypeString = metaType.getString(),
@@ -218,7 +218,7 @@ export default define(class Statement extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const validates = this.validate(assignments, stated, context)
+      const validates = this.validate(stated, context)
 
       validatesGivenMetaType = validates; ///
     }

package/src/element/subDerivation.js

@@ -5,8 +5,6 @@ import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
 
-import assignAssignments from "../process/assign";
-
 const { last } = arrayUtilities,
       { asyncEvery } = asynchronousUtilities;
 
@@ -39,11 +37,10 @@ export default define(class SubDerivation extends Element {
     let verifies;
 
     verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
-      const assignments = [],
-            subproofOrProofAssertionVarifies = await subproofOrProofAssertion.verify(assignments, context);
+      const subproofOrProofAssertionVarifies = await subproofOrProofAssertion.verify(context);
 
       if (subproofOrProofAssertionVarifies) {
-        assignAssignments(assignments, context);
+        context.assignAssignments();
 
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 

package/src/element/subproof.js

@@ -54,14 +54,20 @@ export default define(class Subproof extends Element {
     return proofAssertion;
   }
 
-  async verify(assignments, context) {
+  async verify(context) {
     let verifies = false;
 
     await asyncScope(async () => {
-      const suppositionsVerify = asyncEvery(this.suppositions, async (supposition) => {
-        const suppositionVerifies = await supposition.verify(assignments, 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;
         }
       });

package/src/element/substitution/frame.js

@@ -71,7 +71,7 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let frameSubstitution = null;
 
     const context = this.getContext();
 
@@ -81,13 +81,15 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      frameSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
     } else {
+      let validates = false;
+
       const targetFrameValidates = this.validateTargetFrame(generalContext, specificContext);
 
       if (targetFrameValidates) {
@@ -101,13 +103,15 @@ export default define(class FrameSubstitution extends Substitution {
       if (validates) {
         const substitution = this;  ///
 
+        frameSubstitution = substitution; ///
+
         context.addSubstitution(substitution);
 
         context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
       }
     }
 
-    return validates;
+    return frameSubstitution;
   }
 
   validateTargetFrame(generalContext, specificContext) {
@@ -123,9 +127,13 @@ export default define(class FrameSubstitution extends Substitution {
 
     if (targetFrameSingular) {
       const stated = true,
-            assignments = null;
+            tragetFrame = this.targetFrame.validate(stated, context);
+
+      if (tragetFrame !== null) {
+        this.targetFrame = tragetFrame;
 
-      targetFrameValidates = this.targetFrame.validate(assignments, stated, context);
+        targetFrameValidates = true;
+      }
     } else {
       context.debug(`The '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame is not singular.`);
     }
@@ -147,9 +155,13 @@ export default define(class FrameSubstitution extends Substitution {
     context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
 
     const stated = true,
-          assignments = null;
+          replacementFrame = this.replacementFrame.validate(stated, context);
+
+    if (replacementFrame !== null) {
+      this.replacementFrame = replacementFrame;
 
-    replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
+      replacementFrameValidates = true;
+    }
 
     if (replacementFrameValidates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame.`);

package/src/element/substitution/reference.js

@@ -71,7 +71,7 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let referenceSubstitution = null;
 
     const context = this.getContext();
 
@@ -81,13 +81,15 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      referenceSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
     } else {
+      let validates = false;
+
       const targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
 
       if (targetReferenceValidates) {
@@ -101,13 +103,15 @@ export default define(class ReferenceSubstitution extends Substitution {
       if (validates) {
         const subsitution = this;  ///
 
+        referenceSubstitution = subsitution;  ///
+
         context.addSubstitution(subsitution);
 
         context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
       }
     }
 
-    return validates;
+    return referenceSubstitution;
   }
 
   validateTargetReference(generalContext, specificContext) {
@@ -122,7 +126,11 @@ export default define(class ReferenceSubstitution extends Substitution {
     const targetReferenceSingular = this.targetReference.isSingular();
 
     if (targetReferenceSingular) {
-      targetReferenceValidates = this.targetReference.validate(context);
+      const targetReference = this.targetReference.validate(context);
+
+      if (targetReference !== null) {
+        targetReferenceValidates = true;
+      }
     } else {
       context.debug(`The '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference is not singular.`);
     }
@@ -135,7 +143,7 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   validateReplacementReference(generalContext, specificContext) {
-    let replacementReferenceValidates;
+    let replacementReferenceValidates = false;
 
     const context = specificContext,  ///
           replacementReferenceString = this.replacementReference.getString(),
@@ -143,7 +151,11 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
 
-    replacementReferenceValidates = this.replacementReference.validate(context);
+    const replacementReference = this.replacementReference.validate(context);
+
+    if (replacementReference !== null) {
+      replacementReferenceValidates = true;
+    }
 
     if (replacementReferenceValidates) {
       context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference.`);

package/src/element/substitution/statement.js

@@ -107,7 +107,7 @@ export default define(class StatementSubstitution extends Substitution {
   compareMetavariable(metavariable) { return this.targetStatement.compareMetavariable(metavariable); }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let statementSubstitution = null;
 
     const context = this.getContext();
 
@@ -117,13 +117,15 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      statementSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
     } else {
+      let validates = false;
+
       const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
 
       if (targetStatementValidates) {
@@ -137,13 +139,15 @@ export default define(class StatementSubstitution extends Substitution {
       if (validates) {
         const substitution = this;  ///
 
+        statementSubstitution = substitution; ///
+
         context.addSubstitution(substitution);
 
         context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
       }
     }
 
-    return validates;
+    return statementSubstitution;
   }
 
   validateTargetStatement(generalContext, specificContext) {
@@ -159,9 +163,11 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (targetStatementSingular) {
       const stated = true,
-            assignments = null;
+            targetStatement = this.targetStatement.validate(stated, context);
 
-      targetStatementValidates = this.targetStatement.validate(assignments, stated, context);
+      if (targetStatement !== null) {
+        targetStatementValidates = true;
+      }
     } else {
       context.debug(`The '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement is not singular.`);
     }
@@ -183,9 +189,11 @@ export default define(class StatementSubstitution extends Substitution {
     context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
 
     const stated = true,
-          assignments = null;
+          replacementStatement = this.replacementStatement.validate(stated, context);
 
-    replacementStatementValidates = this.replacementStatement.validate(assignments, stated, context);
+    if (replacementStatement !== null) {
+      replacementStatementValidates = true;
+    }
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement.`);

package/src/element/substitution/term.js

@@ -74,7 +74,7 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let termSubstitution = null;
 
     const context = this.getContext();
 
@@ -84,13 +84,15 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      termSubstitution = validSubstitution; ///
 
       context.debug(`...the '${termSubstitutionString}' term substitution is alrady valid.`);
     } else {
+      let validates = false;
+
       const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
 
       if (targetTermValidates) {
@@ -104,13 +106,15 @@ export default define(class TermSubstitution extends Substitution {
       if (validates) {
         const substitution = this;  ///
 
+        termSubstitution = substitution;  ///
+
         context.addSubstitution(substitution);
 
         context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
       }
     }
 
-    return validates;
+    return termSubstitution;
   }
 
   validateTargetTerm(generalContext, specificContext) {
@@ -125,11 +129,17 @@ export default define(class TermSubstitution extends Substitution {
     const targetTermSingular = this.targetTerm.isSingular();
 
     if (targetTermSingular) {
-      targetTermValidates = this.targetTerm.validate(context, () => {
+      const targetTerm = this.targetTerm.validate(context, () => {
         const validatesForwards = true;
 
         return validatesForwards;
       });
+
+      if (targetTerm !== null) {
+        this.targetTerm = targetTerm;
+
+        targetTermValidates = true;
+      }
     } else {
       context.debug(`The '${termSubstitutionString}' term subtitution's '${targetTermString}' target term is not singular.`);
     }
@@ -142,7 +152,7 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   validateReplacementTerm(generalContext, specificContext) {
-    let replacementTermValidates;
+    let replacementTermValidates = false;
 
     const context = specificContext,  ///
           replacementTermString = this.replacementTerm.getString(),
@@ -150,12 +160,18 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
 
-    replacementTermValidates = this.replacementTerm.validate(context, () => {
+    const replacementTerm = this.replacementTerm.validate(context, () => {
       const validatesForwards = true;
 
       return validatesForwards;
     });
 
+    if (replacementTerm !== null) {
+      this.replacementTerm = replacementTerm;
+
+      replacementTermValidates = true;
+    }
+
     if (replacementTermValidates) {
       context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
     }

package/src/element/substitution.js

@@ -34,12 +34,12 @@ export default class Substitution extends Element {
     return equalTo;
   }
 
-  isValid(context) {
+  findValidSubstiution(context) {
     const substitutionNode = this.getSubstitutionNode(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode),
-          valid = substitutionPresent;  ///
+          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),
+          validSubstitution = substitution;  ///
 
-    return valid;
+    return validSubstitution;
   }
 
   isEqualTo(substitution) {