occam-verify-cli 1.0.448 → 1.0.472

package/src/element/statement.js

@@ -7,7 +7,6 @@ import Element from "../element";
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
-import { instantiateStatement } from "../process/instantiate";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const { match, backwardsSome } = arrayUtilities;
@@ -17,20 +16,6 @@ export default define(class Statement extends Element {
     super(context, string, node);
   }
 
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const node = this.getNode();
-
-      metavariableName = node.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
   isSingular() {
     const node = this.getNode(),
           singular = node.isSingular();
@@ -38,6 +23,13 @@ export default define(class Statement extends Element {
     return singular;
   }
 
+  getMetavariableName() {
+    const node = this.getNode(),
+          metavariableName = node.getMetavariableName();
+
+    return metavariableName;
+  }
+
   isTermContained(term, context) {
     let termContained;
 
@@ -45,7 +37,7 @@ export default define(class Statement extends Element {
           termString = term.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, node);
+    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);
 
     const statementNode = node, ///
           statementNodeTermNodes = statementNode.getTermNodes();
@@ -59,7 +51,7 @@ export default define(class Statement extends Element {
     });
 
     if (termContained) {
-      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, node);
+      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`);
     }
 
     return termContained;
@@ -68,13 +60,13 @@ export default define(class Statement extends Element {
   isFrameContained(frame, context) {
     let frameContained;
 
-    const node = this.getNode(),
-          frameString = frame.getString(),
+    const frameString = frame.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, node);
+    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);
 
-    const statementNode = node,
+    const node = this.getNode(),
+          statementNode = node, ///
           statementNodeFrameNodes = statementNode.getFrameNodes();
 
     frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
@@ -86,7 +78,7 @@ export default define(class Statement extends Element {
     });
 
     if (frameContained) {
-      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, node);
+      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`);
     }
 
     return frameContained;
@@ -114,13 +106,32 @@ export default define(class Statement extends Element {
     return metavariableEqualToMetavariable;
   }
 
+  compareParameter(parameter) {
+    let comparesToParamter = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const parameterName = parameter.getName();
+
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
+
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
+      }
+    }
+
+    return comparesToParamter;
+  }
+
   validate(assignments, stated, context) {
     let validates;
 
-    const node = this.getNode(),
-          statementString = this.getString();  ///
+    const statementString = this.getString();  ///
 
-    context.trace(`Validating the '${statementString}' statement...`, node);
+    context.trace(`Validating the '${statementString}' statement...`);
 
     validates = validateStatements.some((validateStatement) => {
       const statement = this, ///
@@ -136,7 +147,7 @@ export default define(class Statement extends Element {
 
       context.addStatement(statement);
 
-      context.debug(`...validated the '${statementString}' statement.`, node);
+      context.debug(`...validated the '${statementString}' statement.`);
     }
 
     return validates;
@@ -145,11 +156,10 @@ export default define(class Statement extends Element {
   validateGivenMetaType(metaType, assignments, stated, context) {
     let validatesGivenMetaType = false;
 
-    const node = this.getNode(),
-          metaTypeString = metaType.getString(),
+    const metaTypeString = metaType.getString(),
           statementString = this.getString();  ///
 
-    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`, node);
+    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
@@ -160,7 +170,7 @@ export default define(class Statement extends Element {
     }
 
     if (validatesGivenMetaType) {
-      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`, node);
+      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
     return validatesGivenMetaType;
@@ -170,13 +180,13 @@ export default define(class Statement extends Element {
     let subproofUnifies = false;
 
     const node = this.getNode(),
-          context = specificContext,  ///
-          statementNode = node,
+          statementNode = node, ///
           subproofAssertionNode = statementNode.getSubproofAssertionNode(),
           assertionNode = subproofAssertionNode;  ///
 
     if (assertionNode !== null) {
-      const assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+      const context = generalContext, ///
+            assertion = context.findAssertionByAssertionNode(assertionNode),
             subproofAssertion = assertion;  ///
 
       const subproofString = subproof.getString(),
@@ -208,17 +218,18 @@ export default define(class Statement extends Element {
   unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnifies;
 
-    const generalStatement = this,  ///
+    const context = specificContext,  ///
+          generalStatement = this,  ///
           specificStatement = statement, ///
           generalStatementString = generalStatement.getString(),
           specificStatementString = specificStatement.getString();
 
-    specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
+    context.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
     statementUnifies = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
+      context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
     }
 
     return statementUnifies;
@@ -238,8 +249,9 @@ export default define(class Statement extends Element {
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
     if ((definedAssertionNode !== null) || (containedAssertionNode !== null)) {
-      const assertionNode = (definedAssertionNode || containedAssertionNode),
-            assertion = generalContext.findAssertionByAssertionNode(assertionNode),
+      const context = generalContext, ///
+            assertionNode = (definedAssertionNode || containedAssertionNode),
+            assertion = context.findAssertionByAssertionNode(assertionNode),
             assertionUnifiesIndependently = assertion.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (assertionUnifiesIndependently) {
@@ -270,7 +282,7 @@ export default define(class Statement extends Element {
   }
 
   toJSON() {
-    const string = this.getString(),
+    const string = this.getString(),  ///
           json = {
             string
           };
@@ -281,14 +293,6 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          statmentNode = instantiateStatement(string, context),
-          node = statmentNode;  ///,
-
-    context = null;
-
-    const statement = new Statement(context, string, node);
-
-    return statement;
+    ///
   }
 });

package/src/element/subproof.js

@@ -2,8 +2,8 @@
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
 
+import { scope } from "../utilities/context";
 import { define } from "../elements";
 
 export default define(class Subproof extends Element {
@@ -49,25 +49,23 @@ export default define(class Subproof extends Element {
   verify(substitutions, assignments, context) {
     let verifies = false;
 
-    const localContext = LocalContext.fromNothing(context);  ///
+    scope(() => {
+      const suppositionsVerify = this.suppositions.every((supposition) => {
+        const suppositionVerifies = supposition.verify(context);
 
-    context = localContext; ///
-
-    const suppositionsVerify = this.suppositions.every((supposition) => {
-      const suppositionVerifies = supposition.verify(context);
-
-      if (suppositionVerifies) {
-        return true;
-      }
-    });
+        if (suppositionVerifies) {
+          return true;
+        }
+      });
 
-    if (suppositionsVerify) {
-      const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
+      if (suppositionsVerify) {
+        const subDerivationVerifies = this.subDerivation.verify(substitutions, context);
 
-      if (subDerivationVerifies) {
-        verifies = true;
+        if (subDerivationVerifies) {
+          verifies = true;
+        }
       }
-    }
+    }, context);
 
     return verifies;
   }
@@ -81,7 +79,7 @@ export default define(class Subproof extends Element {
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 
-    const subproofString = this.string, ///
+    const subproofString = this.getString(), ///
           satisfiesAssertionString = satisfiesAssertion.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
@@ -95,7 +93,7 @@ export default define(class Subproof extends Element {
       if (axiomSatisfiable) {
         const { Substitutions } = elements,
               subproof = this,  ///
-              substitutions = Substitutions.fromNothing(),
+              substitutions = Substitutions.fromNothing(context),
               statementUnifies = axiom.unifySubproof(subproof, substitutions, context);
 
         if (statementUnifies) {

package/src/element/substitution/frame.js

@@ -3,77 +3,134 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
-import { frameSubstitutionFromFrameSubstitutionNode, frameSubstitutionFromStatementNode } from "../../utilities/element";
+import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
+import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
 export default define(class FrameSubstitution extends Substitution {
-  constructor(context, string, node, frame, metavariable) {
+  constructor(context, string, node, targetFrame, replacementFrame) {
     super(context, string, node);
 
-    this.frame = frame;
-    this.metavariable = metavariable;
+    this.targetFrame = targetFrame;
+    this.replacementFrame = replacementFrame;
   }
 
-  getFrame() {
-    return this.frame;
+  getTargetFrame() {
+    return this.targetFrame;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReplacementFrame() {
+    return this.replacementFrame;
+  }
+
+  getTargetNode() {
+    const targetFrameNode = this.targetFrame.getNode(),
+          tergetNode = targetFrameNode; ///
+
+    return tergetNode;
   }
 
   getReplacementNode() {
-    const frameNode = this.frame.getNode(),
-          replacementNode = frameNode; ///
+    const replacementFrameNode = this.replacementFrame.getNode(),
+          replacementNode = replacementFrameNode; ///
 
     return replacementNode;
   }
 
-  isFrameEqualToFrame(frame) { return this.frame.isEqualTo(frame); }
+  isTrivial() {
+    const targetFrameEqualToReplacementFrame = this.targetFrame.isEqualTo(this.replacementFrame),
+          trivial = targetFrameEqualToReplacementFrame; ///
+
+    return trivial;
+  }
 
-  isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
+  compareFrame(frame, context) {
+    const frameEqualToReplacementFrame = this.replacementFrame.isEqualTo(frame),
+          comparedToFrame = frameEqualToReplacementFrame; ///
 
-  verify(context) {
-    let verifies = false;
+    return comparedToFrame;
+  }
+
+  compareParameter(parameter) {
+    const targetFrameComparesToParameter = this.targetFrame.compareParameter(parameter),
+          comparesToParameter = targetFrameComparesToParameter;  ///
+
+    return comparesToParameter;
+  }
 
-    const frameSubstitutionString = this.string;  ///
+  validate(context) {
+    let validates = false;
 
-    context.trace(`Verifiying the '${frameSubstitutionString}' frame substitution...`);
+    const frameSubstitutionString = this.getString();  ///
 
-    const frameSingular = this.frame.isSingular();
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution...`);
 
-    if (frameSingular) {
-      if (this.metavariable !== null) {
-        const metavariablePresent = context.isMetavariablePresent(this.metavariable);
+    const targetFrameValidates = this.validateTargetFrame(context);
 
-        if (metavariablePresent) {
-          const frameMetavariable = this.frame.getMetavariable(),
-                frameMetavariablePresent = context.isMetavariablePresent(frameMetavariable);
+    if (targetFrameValidates) {
+      const replacementFrameValidates = this.validateReplacementFrame(context);
 
-          if (frameMetavariablePresent) {
-            verifies = true;
-          } else {
-            context.debug(`The '${frameSubstitutionString}' frame substitution's general frame's metavariable is not present.`);
-          }
-        } else {
-          context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame's metavariable is not present.`);
-        }
-      } else {
-        context.debug(`The '${frameSubstitutionString}' frame substitution's general frame is not singular.`);
+      if (replacementFrameValidates) {
+        validates = true;
       }
-    } else {
-      context.debug(`The '${frameSubstitutionString}' frame substitution's specific frame is not singular.`);
     }
 
-    if (verifies) {
+    if (validates) {
       const substititoin = this;  ///
 
       context.addSubstitution(substititoin);
 
-      context.debug(`...verified the '${frameSubstitutionString}' frame substitution.`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
     }
 
-    return verifies;
+    return validates;
+  }
+
+  validateTargetFrame(context) {
+    let targetFrameValidates = false;
+
+    const targetFrameString = this.targetFrame.getString(),
+          frameSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+
+    const targetFrameSingular = this.targetFrame.isSingular();
+
+    if (targetFrameSingular) {
+      const stated = true,
+            assignments = null;
+
+      targetFrameValidates = this.targetFrame.validate(assignments, stated, context);
+    } else {
+      context.debug(`The '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame is not singular.`);
+    }
+
+    if (targetFrameValidates) {
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${targetFrameString}' target frame...`);
+    }
+
+    return targetFrameValidates;
+  }
+
+  validateReplacementFrame(context) {
+    let replacementFrameValidates;
+
+    const replacementFrameString = this.replacementFrame.getString(),
+          frameSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+
+    const stated = true,
+          assignments = null;
+
+    replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
+
+    if (replacementFrameValidates) {
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+    }
+
+    return replacementFrameValidates;
   }
 
   static name = "FrameSubstitution";
@@ -86,18 +143,15 @@ export default define(class FrameSubstitution extends Substitution {
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    const string = stringFromFrameAndMetavariable(frame, metavariable),
-          frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-          frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
+    return literally((context) => {
+      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+            string = frameSubstitutionString,  ///
+            frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+            frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
-    return frameSubstitution;
+      frameSubstitution.validate(context);
+
+      return frameSubstitution;
+    }, context);
   }
 });
-
-function stringFromFrameAndMetavariable(frame, metavariable) {
-  const frameString = frame.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${frameString} for [${metavariableString}]]`;
-
-  return string;
-}

package/src/element/substitution/reference.js

@@ -3,42 +3,142 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
+import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
 export default define(class ReferenceSubstitution extends Substitution {
-  constructor(context, string, node, reference, metavariable) {
+  constructor(context, string, node, targetReference, replacementReference) {
     super(context, string, node);
 
-    this.reference = reference;
-    this.metavariable = metavariable;
+    this.targetReference = targetReference;
+    this.replacementReference = replacementReference;
   }
 
-  getReference() {
-    return this.reference;
+  getTargetReference() {
+    return this.targetReference;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getReplacementReference() {
+    return this.replacementReference;
   }
 
-  isReferenceEqualToReference(reference) { return this.reference.isEqualTo(reference); }
+  getTargetNode() {
+    const targetReferenceNode = this.targetReference.getNode(),
+          tergetNode = targetReferenceNode; ///
+
+    return tergetNode;
+  }
+
+  getReplacementNode() {
+    const replacementReferenceNode = this.replacementReference.getNode(),
+          replacementNode = replacementReferenceNode; ///
+
+    return replacementNode;
+  }
+
+  isTrivial() {
+    const targetReferenceEqualToReplacementReference = this.targetReference.isEqualTo(this.replacementReference),
+          trivial = targetReferenceEqualToReplacementReference; ///
+
+    return trivial;
+  }
+
+  compareReference(reference, context) {
+    const referenceEqualToReplacementReference = this.replacementReference.isEqualTo(reference),
+          comparedToReference = referenceEqualToReplacementReference; ///
+
+    return comparedToReference;
+  }
+
+  compareParameter(parameter) {
+    const targetReferenceComparesToParameter = this.targetReference.compareParameter(parameter),
+          comparesToParameter = targetReferenceComparesToParameter;  ///
+
+    return comparesToParameter;
+  }
+
+  validate(context) {
+    let validates = false;
+
+    const referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution...`);
+
+    const targetReferenceValidates = this.validateTargetReference(context);
+
+    if (targetReferenceValidates) {
+      const replacementReferenceValidates = this.validateReplacementReference(context);
+
+      if (replacementReferenceValidates) {
+        validates = true;
+      }
+    }
+
+    if (validates) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
+    }
+
+    return validates;
+  }
+
+  validateTargetReference(context) {
+    let targetReferenceValidates = false;
+
+    const targetReferenceString = this.targetReference.getString(),
+          referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+
+    const targetReferenceSingular = this.targetReference.isSingular();
+
+    if (targetReferenceSingular) {
+      targetReferenceValidates = this.targetReference.validate(context);
+    } else {
+      context.debug(`The '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference is not singular.`);
+    }
+
+    if (targetReferenceValidates) {
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
+    }
+
+    return targetReferenceValidates;
+  }
+
+  validateReplacementReference(context) {
+    let replacementReferenceValidates;
+
+    const replacementReferenceString = this.replacementReference.getString(),
+          referenceSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+
+    replacementReferenceValidates = this.replacementReference.validate(context);
+
+    if (replacementReferenceValidates) {
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+    }
+
+    return replacementReferenceValidates;
+  }
 
   static name = "ReferenceSubstitution";
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
-    const string = stringFromReferenceAndMetavariable(reference, metavariable),
-          referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-          referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    return literally((context) => {
+      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+            string = referenceSubstitutionString,  ///
+            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
+            referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+
+      referenceSubstitution.validate(context);
 
-    return referenceSubstitution;
+      return referenceSubstitution;
+    }, context);
   }
 });
-
-function stringFromReferenceAndMetavariable(reference, metavariable) {
-  const referenceString = reference.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${referenceString} for ${metavariableString}]`;
-
-  return string;
-}