occam-verify-cli 1.0.587 → 1.0.603

package/src/element/rule.js

@@ -3,8 +3,10 @@
 import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { scope } from "../utilities/context";
+import assignAssignments from "../process/assign";
+
 import { define } from "../elements";
+import { asyncScope } from "../utilities/context";
 import { labelsFromJSON,
          premisesFromJSON,
          conclusionFromJSON,
@@ -13,7 +15,7 @@ import { labelsFromJSON,
          conclusionToConclusionJSON } from "../utilities/json";
 
 const { reverse, extract } = arrayUtilities,
-      { asyncBackwardsEvery } = asynchronousUtilities;
+      { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default define(class Rule extends Element {
   constructor(context, string, node, proof, labels, premises, conclusion) {
@@ -54,7 +56,14 @@ export default define(class Rule extends Element {
   }
 
   verifyLabels() {
-    const labelsVerify = this.labels.every((label) => {
+    let labelsVerify;
+
+    const context = this.getContext(),
+          ruleString = this.getString();  ///
+
+    context.trace(`Verifying the '${ruleString}' rule's labels...`);
+
+    labelsVerify = this.labels.every((label) => {
       const nameOnly = true,
             labelVerifies = label.verify(nameOnly);
 
@@ -63,67 +72,144 @@ export default define(class Rule extends Element {
       }
     });
 
+    if (labelsVerify) {
+      context.trace(`...verified the '${ruleString}' rule's labels.`);
+    }
+
     return labelsVerify;
   }
 
-  verifyPremises(context) {
-    const premisesVerify = this.premises.every((premise) => {
-      const premiseVerifies = this.verifyPremise(premise, context);
+  unifyStatementWithConclusion(statement, context) {
+    let statementUnifiesWithConclusion = false;
 
-      if (premiseVerifies) {
-        return true;
-      }
-    });
+    const ruleString = this.getString(),
+          statementString = statement.getString(),
+          conclusionString = this.conclusion.getString();
 
-    return premisesVerify;
-  }
+    context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
 
-  verifyPremise(premise, context) {
-    const premiseVerifies = premise.verify(context);
+    const statementUnifies = this.conclusion.unifyStatement(statement, context);
+
+    if (statementUnifies) {
+      statementUnifiesWithConclusion = true;
+    }
+
+    if (statementUnifiesWithConclusion) {
+      context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion.`);
+    }
 
-    return premiseVerifies;
+    return statementUnifiesWithConclusion;
   }
 
-  verifyConclusion(context) {
-    const conclusionVerifies = this.conclusion.verify(context);
+  async verify() {
+    let verifies = false;
 
-    return conclusionVerifies;
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const ruleString = this.getString(); ///
+
+    context.trace(`Verifying the '${ruleString}' rule...`);
+
+    await asyncScope(async (context) => {
+      const labelsVerify = this.verifyLabels();
+
+      if (labelsVerify) {
+        const premisesVerify = await this.verifyPremises(context);
+
+        if (premisesVerify) {
+          const conclusionVerifies = await this.verifyConclusion(context);
+
+          if (conclusionVerifies) {
+            const proofVerifies = await this.verifyProof(context);
+
+            if (proofVerifies) {
+              const rule = this;  ///
+
+              context.addRule(rule);
+
+              verifies = true;
+            }
+          }
+        }
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${ruleString}' rule.`);
+    }
+
+    return verifies;
   }
 
-  verifyProof(context) {
+  async verifyProof(context) {
     let proofVerifies;
 
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const substitutions = [];
+      const ruleString = this.getString();  ///
 
-      proofVerifies = this.proof.verify(substitutions, this.conclusion, context);
+      context.trace(`Verifying the '${ruleString}' rule's proof...`);
+
+      const statement = this.conclusion.getStatement();
+
+      proofVerifies = this.proof.verify(statement, context);
+
+      if (proofVerifies) {
+        context.debug(`...verified the '${ruleString}' rule's proof.`);
+      }
     }
 
     return proofVerifies;
   }
 
-  unifyStatementWithConclusion(statement, context) {
-    let statementUnifiesWithConclusion = false;
+  async verifyPremises(context) {
+    let premisesVerify;
 
-    const ruleString = this.getString(),
-          statementString = statement.getString(),
-          conclusionString = this.conclusion.getString();
+    const ruleString = this.getString();  ///
 
-    context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
+    context.trace(`Verifying the '${ruleString}' rule's premises...`);
 
-    const statementUnifies = this.conclusion.unifyStatement(statement, context);
+    premisesVerify = await asyncForwardsEvery(this.premises, async (premise) => {
+      const assignments = [],
+            premiseVerifies = await premise.verify(assignments, context)
 
-    if (statementUnifies) {
-      statementUnifiesWithConclusion = true;
+      if (premiseVerifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const subproofOrProofAssertion = premise;  ////
+
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+
+          return true;
+        }
+      }
+    });
+
+    if (premisesVerify) {
+      context.debug(`...verified the '${ruleString}' rule's premises.`);
     }
 
-    if (statementUnifiesWithConclusion) {
-      context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion.`);
+    return premisesVerify;
+  }
+
+  async verifyConclusion(context) {
+    let conclusionVerifies;
+
+    const ruleString = this.getString();  ///
+
+    context.trace(`Verifying the '${ruleString}' rule's conclusion...`);
+
+    conclusionVerifies = await this.conclusion.verify(context);
+
+    if (conclusionVerifies) {
+      context.debug(`...verified the '${ruleString}' rule's conclusion.`);
     }
 
-    return statementUnifiesWithConclusion;
+    return conclusionVerifies;
   }
 
   async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
@@ -135,7 +221,15 @@ export default define(class Rule extends Element {
       const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const substitutionsResolved = context.areSubstitutionsResolved();
+        const specificContext = context;  ///
+
+        context = this.getContext();
+
+        const generalContext = context; ///
+
+        context = specificContext;  ///
+
+        const substitutionsResolved = context.areSubstitutionsResolved(generalContext, specificContext);
 
         if (substitutionsResolved) {
           statementAndSubproofOrProofAssertionsUnify = true;
@@ -170,6 +264,16 @@ export default define(class Rule extends Element {
         const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
+          const specificContext = context;  ///
+
+          context = this.getContext();
+
+          const generalContext = context; ///
+
+          context = specificContext;  ///
+
+          context.resolveSubstitutions(generalContext, specificContext);
+
           return true;
         }
       }) || null;
@@ -190,48 +294,6 @@ export default define(class Rule extends Element {
     return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const ruleString = this.getString(); ///
-
-    context.trace(`Verifying the '${ruleString}' rule...`);
-
-    scope((context) => {
-      const labelsVerify = this.verifyLabels();
-
-      if (labelsVerify) {
-        const premisesVerify = this.verifyPremises(context);
-
-        if (premisesVerify) {
-          const conclusionVerifies = this.verifyConclusion(context);
-
-          if (conclusionVerifies) {
-            const proofVerifies = this.verifyProof(context);
-
-            if (proofVerifies) {
-              verifies = true;
-            }
-          }
-        }
-      }
-    }, context);
-
-    if (verifies) {
-      const rule = this;  ///
-
-      context.addRule(rule);
-
-      context.debug(`...verified the '${ruleString}' rule.`);
-    }
-
-    return verifies;
-  }
-
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           premisesJSON = premisesToPremisesJSON(this.premises),

package/src/element/signature.js

@@ -68,6 +68,8 @@ export default define(class Signature extends Element {
                 //   const { TermSubstitution } = elements;
                 //
                 //   TermSubstitution.fromTermAndVariable(term, variable, context);
+
+                //  validates...
                 // });
 
                 return true;

package/src/element/statement.js

@@ -30,16 +30,50 @@ export default define(class Statement extends Element {
     return metavariableName;
   }
 
+  getStatementNode() {
+    const node = this.getNode(),
+          statementNode = node; ///
+
+    return statementNode;
+  }
+
+  matchStatementNode(statementNode) {
+    const statementNodeA = statementNode; ///
+
+    statementNode = this.getStatementNode();
+
+    const statementNodeB = statementNode, ///
+          statementNodeAAMatchesStatementBNodeB = statementNodeA.match(statementNodeB),
+          equalTo = statementNodeAAMatchesStatementBNodeB; ///
+
+    return equalTo;
+  }
+
+  isValid(context) {
+    const statementNode = this.getStatementNode(),
+          statementPresent = context.isStatementPresentByStatementNode(statementNode),
+          valid = statementPresent;  ///
+
+    return valid;
+  }
+
+  isEqualTo(statement) {
+    const statementNode = statement.getNode(),
+          statementNodeMatches = this.matchStatementNode(statementNode),
+          equalTo = statementNodeMatches;  ///
+
+    return equalTo;
+  }
+
   isTermContained(term, context) {
     let termContained;
 
-    const node = this.getNode(),
-          termString = term.getString(),
+    const termString = term.getString(),
           statementString = this.getString();  ///
 
     context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);
 
-    const statementNode = node, ///
+    const statementNode = this.getStatementNode(),
           statementNodeTermNodes = statementNode.getTermNodes();
 
     termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
@@ -65,8 +99,7 @@ export default define(class Statement extends Element {
 
     context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);
 
-    const node = this.getNode(),
-          statementNode = node, ///
+    const statementNode = this.getStatementNode(),
           statementNodeFrameNodes = statementNode.getFrameNodes();
 
     frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
@@ -84,37 +117,29 @@ export default define(class Statement extends Element {
     return frameContained;
   }
 
-  isMetavariableEqualToMetavariable(metavariable, context) {
-    let metavariableEqualToMetavariable;
+  compareMetavariable(metavariable) {
+    let metavaraibleComparseTo;
 
     const singular = this.isSingular();
 
     if (singular) {
-      const node = this.getNode(),
-            metavariableA = metavariable, ///
-            singularMetavariableNode = node.getSingularMetavariableNode(),
-            metavariableName = singularMetavariableNode.getMetavariableName();
+      let metavariableName;
 
-      metavariable = context.findMetavariableByMetavariableName(metavariableName)
+      const statementNode = this.getStatementNode(),
+            singularMetavariableNode = statementNode.getSingularMetavariableNode();
 
-      const metavariableB = metavariable,
-            equalTo = metavariableA.isEqualTo(metavariableB);
+      metavariableName = singularMetavariableNode.getMetavariableName();
 
-      metavariableEqualToMetavariable = equalTo;  ///
-    }
+      const metavariableNameA = metavariableName ///
 
-    return metavariableEqualToMetavariable;
-  }
+      metavariableName = metavariable.getName();
 
-  isEqualTo(statement) {
-    const statementA = this, ///
-          statementB = statement, ///
-          statementANode = statementA.getNode(),
-          statementBNode = statementB.getNode(),
-          statementANodeMatchesStatementBNode = statementANode.match(statementBNode),
-          equalTo = statementANodeMatchesStatementBNode; ///
+      const metavariableNameB = metavariableName; ///
 
-    return equalTo;
+      metavaraibleComparseTo = (metavariableNameA === metavariableNameB);
+    }
+
+    return metavaraibleComparseTo;
   }
 
   compareParameter(parameter) {
@@ -144,21 +169,29 @@ export default define(class Statement extends Element {
 
     context.trace(`Validating the '${statementString}' statement...`);
 
-    validates = validateStatements.some((validateStatement) => {
-      const statement = this, ///
-            statementValidates = validateStatement(statement, assignments, stated, context);
+    const valid = this.isValid(context);
 
-      if (statementValidates) {
-        return true;
-      }
-    });
+    if (valid) {
+      validates = true;
 
-    if (validates) {
-      const statement = this; ///
+      context.debug(`...the '${statementString}' statement is alrady valid.`);
+    } else {
+      validates = validateStatements.some((validateStatement) => {
+        const statement = this, ///
+              statementValidates = validateStatement(statement, assignments, stated, context);
 
-      context.addStatement(statement);
+        if (statementValidates) {
+          return true;
+        }
+      });
+
+      if (validates) {
+        const statement = this; ///
+
+        context.addStatement(statement);
 
-      context.debug(`...validated the '${statementString}' statement.`);
+        context.debug(`...validated the '${statementString}' statement.`);
+      }
     }
 
     return validates;
@@ -187,11 +220,10 @@ export default define(class Statement extends Element {
     return validatesGivenMetaType;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+  unifySubproof(subproof, generalContext, specificContext) {
     let subproofUnifies = false;
 
-    const node = this.getNode(),
-          statementNode = node, ///
+    const statementNode = this.getStatementNode(),
           subproofAssertionNode = statementNode.getSubproofAssertionNode(),
           assertionNode = subproofAssertionNode;  ///
 
@@ -211,7 +243,7 @@ export default define(class Statement extends Element {
       subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
         const generalStatement = subproofAssertionStatement,  ///
               specificStatement = subproofStatement,  ///
-              statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+              statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
 
         if (statementUnifies) {
           return true;
@@ -246,7 +278,7 @@ export default define(class Statement extends Element {
     return statementUnifies;
   }
 
-  unifyIndependently(substitutions, generalContext, specificContext) {
+  unifyIndependently(generalContext, specificContext) {
     let unifiesIndependently = false;
 
     const context = specificContext,  ///
@@ -254,8 +286,7 @@ export default define(class Statement extends Element {
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    const node = this.getNode(),
-          statementNode = node, ///
+    const statementNode = this.getStatementNode(),
           definedAssertionNode = statementNode.getDefinedAssertionNode(),
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
@@ -263,7 +294,7 @@ export default define(class Statement extends Element {
       const context = generalContext, ///
             assertionNode = (definedAssertionNode || containedAssertionNode),
             assertion = context.findAssertionByAssertionNode(assertionNode),
-            assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
+            assertionUnifiesIndependently = assertion.unifyIndependently(generalContext, specificContext);
 
       if (assertionUnifiesIndependently) {
         unifiesIndependently = true;

package/src/element/substitution/frame.js

@@ -38,6 +38,21 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementNode;
   }
 
+  getMetavariable(generalContext, specificContext) {
+    let metavariable = null;
+
+    const targetFrameNode = this.targetFrame.getNode(),
+          metavariableName = targetFrameNode.getMetavariableName();
+
+    if (metavariableName !== null) {
+      const context = generalContext; ///
+
+      metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    }
+
+    return metavariable;
+  }
+
   isTrivial() {
     const targetFrameEqualToReplacementFrame = this.targetFrame.isEqualTo(this.replacementFrame),
           trivial = targetFrameEqualToReplacementFrame; ///
@@ -59,38 +74,51 @@ export default define(class FrameSubstitution extends Substitution {
     return comparesToParameter;
   }
 
-  validate(context) {
+  validate(generalContext, specificContext) {
     let validates = false;
 
+    const context = this.getContext();
+
+    specificContext = context;  ///
+
     const frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
-    const targetFrameValidates = this.validateTargetFrame(context);
+    const valid = this.isValid(context);
 
-    if (targetFrameValidates) {
-      const replacementFrameValidates = this.validateReplacementFrame(context);
+    if (valid) {
+      validates = true;
+
+      context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
+    } else {
+      const targetFrameValidates = this.validateTargetFrame(generalContext, specificContext);
+
+      if (targetFrameValidates) {
+        const replacementFrameValidates = this.validateReplacementFrame(generalContext, specificContext);
 
-      if (replacementFrameValidates) {
-        validates = true;
+        if (replacementFrameValidates) {
+          validates = true;
+        }
       }
-    }
 
-    if (validates) {
-      const substititoin = this;  ///
+      if (validates) {
+        const substititoin = this;  ///
 
-      context.addSubstitution(substititoin);
+        context.addSubstitution(substititoin);
 
-      context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
+        context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
+      }
     }
 
     return validates;
   }
 
-  validateTargetFrame(context) {
+  validateTargetFrame(generalContext, specificContext) {
     let targetFrameValidates = false;
 
-    const targetFrameString = this.targetFrame.getString(),
+    const context = generalContext,  ///
+          targetFrameString = this.targetFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
@@ -113,10 +141,11 @@ export default define(class FrameSubstitution extends Substitution {
     return targetFrameValidates;
   }
 
-  validateReplacementFrame(context) {
+  validateReplacementFrame(generalContext, specificContext) {
     let replacementFrameValidates;
 
-    const replacementFrameString = this.replacementFrame.getString(),
+    const context = specificContext, ///
+          replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);