occam-verify-cli 1.0.437 → 1.0.438

package/src/element/statement.js

@@ -3,7 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import verifyMixins from "../mixins/statement/verify";
+import validateMixins from "../mixins/statement/validate";
 
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
@@ -23,24 +23,32 @@ export default define(class Statement extends Element {
     const singular = this.isSingular();
 
     if (singular) {
-      metavariableName = this.node.getMetavariableName();
+      const node = this.getNode();
+
+      metavariableName = node.getMetavariableName();
     }
 
     return metavariableName;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
+
+    return singular;
+  }
 
   isTermContained(term, context) {
     let termContained;
 
-    const termString = term.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          termString = term.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, this.node);
+    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`, node);
 
     const termNode = term.getNode(),
-          statementNode = this.node,
+          statementNode = node, ///
           statementNodeTermNodes = statementNode.getTermNodes();
 
     termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
@@ -52,7 +60,7 @@ export default define(class Statement extends Element {
     });
 
     if (termContained) {
-      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, this.node);
+      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`, node);
     }
 
     return termContained;
@@ -61,13 +69,14 @@ export default define(class Statement extends Element {
   isFrameContained(frame, context) {
     let frameContained;
 
-    const frameString = frame.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          frameString = frame.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, this.node);
+    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`, node);
 
     const frameNode = frame.getNode(),
-          statementNode = this.node,
+          statementNode = node,
           statementNodeFrameNodes = statementNode.getFrameNodes();
 
     frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
@@ -79,7 +88,7 @@ export default define(class Statement extends Element {
     });
 
     if (frameContained) {
-      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, this.node);
+      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`, node);
     }
 
     return frameContained;
@@ -91,8 +100,9 @@ export default define(class Statement extends Element {
     const singular = this.isSingular();
 
     if (singular) {
-      const metavariableA = metavariable, ///
-            singularMetavariableNode = this.node.getSingularMetavariableNode(),
+      const node = this.getNode(),
+            metavariableA = metavariable, ///
+            singularMetavariableNode = node.getSingularMetavariableNode(),
             metavariableName = singularMetavariableNode.getMetavariableName();
 
       metavariable = context.findMetavariableByMetavariableName(metavariableName)
@@ -106,63 +116,64 @@ export default define(class Statement extends Element {
     return metavariableEqualToMetavariable;
   }
 
-  matchStatementNode(statementNode) { return this.node.match(statementNode); }
-
-  verify(assignments, stated, context) {
-    let verifies;
+  validate(assignments, stated, context) {
+    let validates;
 
-    const statementString = this.string;  ///
+    const node = this.getNode(),
+          statementString = this.getString();  ///
 
-    context.trace(`Verifying the '${statementString}' statement...`, this.node);
+    context.trace(`Validating the '${statementString}' statement...`, node);
 
-    verifies = verifyMixins.some((verifyMixin) => {
+    validates = validateMixins.some((validateMixin) => {
       const statement = this, ///
-            verifies = verifyMixin(statement, assignments, stated, context);
+            validates = validateMixin(statement, assignments, stated, context);
 
-      if (verifies) {
+      if (validates) {
         return true;
       }
     });
 
-    if (verifies) {
+    if (validates) {
       const statement = this; ///
 
       context.addStatement(statement);
 
-      context.debug(`...verified the '${statementString}' statement.`, this.node);
+      context.debug(`...validated the '${statementString}' statement.`, node);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, context) {
-    let verifiesGivenMetaType = false;
+  validateGivenMetaType(metaType, assignments, stated, context) {
+    let validatesGivenMetaType = false;
 
-    const metaTypeString = metaType.getString(),
-          statementString = this.string;  ///
+    const node = this.getNode(),
+          metaTypeString = metaType.getString(),
+          statementString = this.getString();  ///
 
-    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`, this.node);
+    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`, node);
 
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const verifies = this.verify(assignments, stated, context)
+      const validates = this.validate(assignments, stated, context)
 
-      verifiesGivenMetaType = verifies; ///
+      validatesGivenMetaType = validates; ///
     }
 
-    if (verifiesGivenMetaType) {
-      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`, this.node);
+    if (validatesGivenMetaType) {
+      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`, node);
     }
 
-    return verifiesGivenMetaType;
+    return validatesGivenMetaType;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnifies = false;
 
-    const context = specificContext,  ///
-          statementNode = this.node,
+    const node = this.getNode(),
+          context = specificContext,  ///
+          statementNode = node,
           subproofAssertionNode = statementNode.getSubproofAssertionNode(),
           assertionNode = subproofAssertionNode;  ///
 
@@ -219,11 +230,12 @@ export default define(class Statement extends Element {
     let unifiesIndependently = false;
 
     const context = specificContext,  ///
-          statementString = this.string;  ///
+          statementString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement independently...`);
 
-    const statementNode = this.node,
+    const node = this.getNode(),
+          statementNode = node, ///
           definedAssertionNode = statementNode.getDefinedAssertionNode(),
           containedAssertionNode = statementNode.getContainedAssertionNode();
 
@@ -260,7 +272,7 @@ export default define(class Statement extends Element {
   }
 
   toJSON() {
-    const string = this.string, ///
+    const string = this.getString(),
           json = {
             string
           };
@@ -273,8 +285,11 @@ export default define(class Statement extends Element {
   static fromJSON(json, context) {
     const { string } = json,
           statmentNode = instantiateStatement(string, context),
-          node = statmentNode,  ///,
-          statement = new Statement(string, node);
+          node = statmentNode;  ///,
+
+    context = null;
+
+    const statement = new Statement(context, string, node);
 
     return statement;
   }

package/src/element/step.js

@@ -67,8 +67,8 @@ export default define(class Step extends Element {
     return termAndPropertyRelationMatch;
   }
 
-  verify(substitutions, assignments, context) {
-    let verifies = false;
+  validate(substitutions, assignments, context) {
+    let validates = false;
 
     const temporaryContext = TemporaryContext.fromNothing(context);
 
@@ -76,11 +76,11 @@ export default define(class Step extends Element {
 
     const stepString = this.string; ///
 
-    context.trace(`Verifying the '${stepString}' step...`, this.node);
+    context.trace(`Validating the '${stepString}' step...`, this.node);
 
     if (this.statement !== null) {
       const stated = this.isStated(),
-            statementVerifies = this.statement.verify(assignments, stated, context);
+            statementVerifies = this.statement.validate(assignments, stated, context);
 
       if (statementVerifies) {
         const qualified = this.isQualified(),
@@ -89,34 +89,34 @@ export default define(class Step extends Element {
         if (false) {
           ///
         } else if (qualified) {
-          const referenceVerifies = this.reference.verify(context);
+          const referenceVerifies = this.reference.validate(context);
 
           if (referenceVerifies) {
-            verifies = true;
+            validates = true;
           }
         } else if (satisfied) {
           const stated = true,
                 assignments = null,
-                satisfiesAssertionVerifies = this.satisfiesAssertion.verify(assignments, stated, context);
+                satisfiesAssertionVerifies = this.satisfiesAssertion.validate(assignments, stated, context);
 
           if (satisfiesAssertionVerifies) {
-            verifies = true;
+            validates = true;
           }
         } else {
-          verifies = true;
+          validates = true;
         }
       }
     } else {
-      context.debug(`Cannot verify the '${stepString}' step because it is nonsense.`, this.node);
+      context.debug(`Cannot validate the '${stepString}' step because it is nonsense.`, this.node);
     }
 
-    if (verifies) {
+    if (validates) {
       this.context = context;
 
       context.debug(`...verified the '${stepString}' step.`, this.node);
     }
 
-    return verifies;
+    return validates;
   }
 
   unify(substitutions, context) {

package/src/element/subDerivation.js

@@ -32,9 +32,9 @@ export default define(class SubDerivation extends Element {
 
     verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
       const assignments = [],
-            stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+            stepOrSubproofValidates = stepOrSubproof.validate(substitutions, assignments, context);
 
-      if (stepOrSubproofVerifies) {
+      if (stepOrSubproofValidates) {
         const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
 
         if (stepOrSubproofUnifies) {

package/src/element.js

@@ -19,6 +19,18 @@ export default class Element {
     return this.node;
   }
 
+  setContext(context) {
+    this.context = context;
+  }
+
+  setString(string) {
+    this.string = string;
+  }
+
+  setNode(node) {
+    this.node = node;
+  }
+
   isEQualTo(element) {
     const elementNode = element.getNode(),
           matches = this.node.match(elementNode),

package/src/mixins/statement/validate.js

@@ -0,0 +1,295 @@
+"use strict";
+
+import elements from "../../elements";
+
+import { equalityFromStatement,
+         judgementFromStatement,
+         metavariableFromStatement,
+         typeAssertionFromStatement,
+         definedAssertionFromStatement,
+         propertyAssertionFromStatement,
+         subproofAssertionFromStatement,
+         containedAssertionFromStatement,
+         satisfiesAssertionFromStatement } from "../../utilities/statement";
+
+function validateAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+  let validatesAsMetavariableAndSubstitution = false;
+
+  const metavariable = metavariableFromStatement(statement, context);
+
+  if (metavariable !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a metavariable and substitution...`);
+
+    const metavariableValidates = metavariable.validate(context);
+
+    if (metavariableValidates) {
+      const { TermSubstitution, FrameSubstitution } = elements,
+            frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+            termSubstitution = TermSubstitution.fromStatement(statement, context),
+            substitution = (termSubstitution || frameSubstitution);
+
+      if (substitution !== null) {
+        const substitutionValidates = substitution.validate(context);
+
+        if (substitutionValidates) {
+          validatesAsMetavariableAndSubstitution = true;
+        }
+      } else {
+        validatesAsMetavariableAndSubstitution = true;
+      }
+    }
+
+    if (validatesAsMetavariableAndSubstitution) {
+      context.debug(`...validated the '${statementString}' statement as a metavariable and substitution.`);
+    }
+  }
+
+  return validatesAsMetavariableAndSubstitution;
+}
+
+function unifyWithBracketedCombinatorStatement(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const { BracketedCombinatorStatement } = elements,
+        bracketedCombinatorStatement = BracketedCombinatorStatement.fromNothing(),
+        unifiesWithBracketedCombinatorStatement = bracketedCombinatorStatement.unifyStatement(statement, assignments, stated, context);
+
+  return unifiesWithBracketedCombinatorStatement;
+}
+
+function unifyWithCombinators(statement, assignments, stated, context) {
+  stated = true;  ///
+
+  assignments = null; ///
+
+  const combinators = context.getCombinators(),
+        unifiesWithCombinators = combinators.some((combinator) => {
+          const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
+
+          if (unifiesWithCombinator) {
+            return true;
+          }
+        });
+
+  return unifiesWithCombinators;
+}
+
+function validateAsEquality(statement, assignments, stated, context) {
+  let validatesAsEquality = false;
+
+  const equality = equalityFromStatement(statement, context);
+
+  if (equality !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as an equality...`);
+
+    const equalityValidates = equality.validate(assignments, stated, context);
+
+    validatesAsEquality = equalityValidates; ///
+
+    if (validatesAsEquality) {
+      context.debug(`...validated the '${statementString}' statement as an equality.`);
+    }
+  }
+
+  return validatesAsEquality;
+}
+
+function validateAsJudgement(statement, assignments, stated, context) {
+  let validatesAsJudgement = false;
+
+  const judgement = judgementFromStatement(statement, context);
+
+  if (judgement !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a judgement...`);
+
+    const judgementValidates = judgement.validate(assignments, stated, context);
+
+    validatesAsJudgement = judgementValidates;  ///
+
+    if (validatesAsJudgement) {
+      context.debug(`...validated the '${statementString}' statement as a judgement.`);
+    }
+  }
+
+  return validatesAsJudgement;
+}
+
+function validateAsTypeAssertion(statement, assignments, stated, context) {
+  let validatesAsTypeAssertion = false;
+
+  const typeAssertion = typeAssertionFromStatement(statement, context);
+
+  if (typeAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a type assertion...`);
+
+    const typeAssertionValidates = typeAssertion.validate(assignments, stated, context);
+
+    validatesAsTypeAssertion = typeAssertionValidates; ///
+
+    if (validatesAsTypeAssertion) {
+      const assertion = typeAssertion;  ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a type assertion.`);
+    }
+  }
+
+  return validatesAsTypeAssertion;
+}
+
+function validateAsDefinedAssertion(statement, assignments, stated, context) {
+  let validatesAsDefinedAssertion = false;
+
+  const definedAssertion = definedAssertionFromStatement(statement, context);
+
+  if (definedAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a defined assertion...`);
+
+    const definedAssertionValidates = definedAssertion.validate(assignments, stated, context);
+
+    validatesAsDefinedAssertion = definedAssertionValidates; ///
+
+    if (validatesAsDefinedAssertion) {
+      const assertion = definedAssertion;  ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a defined assertion.`);
+    }
+  }
+
+  return validatesAsDefinedAssertion;
+}
+
+function validateAsPropertyAssertion(statement, assignments, stated, context) {
+  let validatesAsPropertyAssertion = false;
+
+  const propertyAssertion = propertyAssertionFromStatement(statement, context);
+
+  if (propertyAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a property assertion...`);
+
+    const propertyAssertionValidates = propertyAssertion.validate(assignments, stated, context);
+
+    validatesAsPropertyAssertion = propertyAssertionValidates; ///
+
+    if (validatesAsPropertyAssertion) {
+      const assertion = propertyAssertion; ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a property assertion.`);
+    }
+  }
+
+  return validatesAsPropertyAssertion;
+}
+
+function validateAsSubproofAssertion(statement, assignments, stated, context) {
+  let validatesAsSubproofAssertion = false;
+
+  const subproofAssertion = subproofAssertionFromStatement(statement, context);
+
+  if (subproofAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a subproof assertion...`);
+
+    const subproofAssertionValidates = subproofAssertion.validate(assignments, stated, context);
+
+    validatesAsSubproofAssertion = subproofAssertionValidates; ///
+
+    if (validatesAsSubproofAssertion) {
+      const assertion = subproofAssertion; ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a subproof assertion.`);
+    }
+  }
+
+  return validatesAsSubproofAssertion;
+}
+
+function validateAsContainedAssertion(statement, assignments, stated, context) {
+  let validatesAsContainedAssertion = false;
+
+  const containedAssertion = containedAssertionFromStatement(statement, context);
+
+  if (containedAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a contained assertion...`);
+
+    const containedAssertionValidates = containedAssertion.validate(assignments, stated, context);
+
+    validatesAsContainedAssertion = containedAssertionValidates; ///
+
+    if (validatesAsContainedAssertion) {
+      const assertion = containedAssertion; ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a contained assertion.`);
+    }
+  }
+
+  return validatesAsContainedAssertion;
+}
+
+function validateAsSatisfiesAssertion(statement, assignments, stated, context) {
+  let validatesAsSatisfiesAssertion = false;
+
+  const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
+
+  if (satisfiesAssertion !== null) {
+    const statementString = statement.getString();
+
+    context.trace(`Validating the '${statementString}' statement as a satisfies assertion...`);
+
+    const satisfiesAssertionValidates = satisfiesAssertion.validate(assignments, stated, context);
+
+    validatesAsSatisfiesAssertion = satisfiesAssertionValidates; ///
+
+    if (validatesAsSatisfiesAssertion) {
+      const assertion = satisfiesAssertion; ///
+
+      context.addAssertion(assertion);
+
+      context.debug(`...validated the '${statementString}' statement as a satisfies assertion.`);
+    }
+  }
+
+  return validatesAsSatisfiesAssertion;
+}
+
+const validateMixins = [
+  validateAsMetavariableAndSubstitution,
+  unifyWithBracketedCombinatorStatement,
+  unifyWithCombinators,
+  validateAsEquality,
+  validateAsJudgement,
+  validateAsTypeAssertion,
+  validateAsDefinedAssertion,
+  validateAsPropertyAssertion,
+  validateAsSubproofAssertion,
+  validateAsContainedAssertion,
+  validateAsSatisfiesAssertion
+];
+
+export default validateMixins;

package/src/utilities/element.js

@@ -40,8 +40,11 @@ export function termFromTermNode(termNode, context) {
   const { Term } = elements,
         node = termNode,  ///
         string = context.nodeAsString(node),
-        type = null,
-        term = new Term(context, string, node, type);
+        type = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, type);
 
   return term;
 }
@@ -67,7 +70,7 @@ export function ruleFromRuleNode(ruleNode, context) {
         ruleString = rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
         node = ruleNode,  ///
         string = ruleString,  ///
-        rule = new Rule(context, string, node, labels, premises, conclusion, proof);
+        rule = new Rule(context, string, node, proof, labels, premises, conclusion);
 
   return rule;
 }
@@ -278,8 +281,11 @@ export function deductionFromDeductionNode(deductionNode, context) {
 export function statementFromStatementNode(statementNode, context) {
   const { Statement } = elements,
         node = statementNode, ///
-        string = context.nodeAsString(node),
-        statement = new Statement(context, string, node);
+        string = context.nodeAsString(node);
+
+  context = null;
+
+  const statement = new Statement(context, string, node);
 
   return statement;
 }
@@ -1122,11 +1128,9 @@ export function termFromTermSubstitutionNode(termSubstitutionNode, context) {
 export function metavariableFromStatementNode(statementNode, context) {
   let metavariable = null;
 
-  const singularMetavariableNode = statementNode.getSingularMetavariableNode();
-
-  if (singularMetavariableNode !== null) {
-    const metavariableNode = singularMetavariableNode;  ///
+  const metavariableNode = statementNode.getMetavariableNode();
 
+  if (metavariableNode !== null) {
     metavariable = metavariableFromMetavariableNode(metavariableNode, context);
   }