occam-verify-cli 1.0.457 → 1.0.473

package/src/element/frame.js

@@ -7,6 +7,7 @@ import elements from "../elements";
 
 import { define } from "../elements";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 const { first } = arrayUtilities;
 
@@ -52,18 +53,18 @@ export default define(class Frame extends Element {
   }
 
   getMetavariableName() {
-    let metavariableName = null;
-
-    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;
+  }
 
   isMetavariableEqualToMetavariable(metavariable, context) {
     let metavariableEqualToMetavariable;
@@ -71,8 +72,9 @@ export default define(class Frame 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)
@@ -86,6 +88,26 @@ export default define(class Frame 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;
+  }
+
   compareSubstitution(substitution, context) {
     let comparesToSubstitution = false;
 
@@ -178,10 +200,10 @@ export default define(class Frame extends Element {
 
     const singular = this.isSingular();
 
-    if (!singular) {
-      context.trace(`The '${frameString}' stated frame must be singular.`);
-    } else {
+    if (singular) {
       validatesWhenStated = true;
+    } else {
+      context.trace(`The '${frameString}' stated frame must be singular.`);
     }
 
     if (validatesWhenStated) {
@@ -208,20 +230,25 @@ export default define(class Frame extends Element {
   }
 
   validateAssumptions(assignments, stated, context) {
-    let assumptionsValidate = true;  ///
+    let assumptionsValidate;
 
-    const length = this.getLength();
+    const frameString = this.getString(), ///
+          assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-    if (length > 0) {
-      stated = true;  ///
+    context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
 
-      assignments = null; ///
+    stated = true;  ///
 
-      assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionVerifies = assumption.validate(assignments, stated, context);
+    assignments = null; ///
 
-        return assumptionVerifies;
-      });
+    assumptionsValidate = this.assumptions.every((assumption) => {
+      const assumptionVerifies = assumption.validate(assignments, stated, context);
+
+      return assumptionVerifies;
+    });
+
+    if (assumptionsValidate) {
+      context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
     }
 
     return assumptionsValidate;
@@ -233,7 +260,7 @@ export default define(class Frame extends Element {
     const frameString = this.getString(),  ///
           metaTypeString = metaType.getString();
 
-    context.trace(`Validatin the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
+    context.trace(`Validating the '${frameString}' frame given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 

package/src/element/hypothesis.js

@@ -20,7 +20,7 @@ export default define(class Hypothesis extends Element {
   verify(context) {
     let verifies = false;
 
-    const hypothesisString = this.string; ///
+    const hypothesisString = this.getString(); ///
 
     context.trace(`Verifying the '${hypothesisString}' hypothesis...`, this.node);
 

package/src/element/judgement.js

@@ -22,14 +22,19 @@ export default define(class Judgement extends Element {
     return this.assumption;
   }
 
-  isSingular() { return this.node.isSingular(); }
+  isSingular() {
+    const node = this.getNode(),
+          singular = node.isSingular();
+
+    return singular;
+  }
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
   validate(assignments, stated, context) {
     let validates = false;
 
-    const judgementString = this.string;  ///
+    const judgementString = this.getString();  ///
 
     context.trace(`Validating the '${judgementString}' judgement...`);
 
@@ -70,7 +75,7 @@ export default define(class Judgement extends Element {
   validateWhenStated(assignments, context) {
     let validatesWhenStated;
 
-    const judgementString = this.string;  ///
+    const judgementString = this.getString();  ///
 
     context.trace(`Validating the '${judgementString}' stated judgement...`);
 
@@ -86,7 +91,7 @@ export default define(class Judgement extends Element {
   validateWhenDerived(context) {
     let validatesWhenDerived = false;
 
-    const judgementString = this.string;  ///
+    const judgementString = this.getString();  ///
 
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 

package/src/element/metaType.js

@@ -3,7 +3,6 @@
 import Element from "../element";
 
 import { define } from "../elements";
-import { findMetaTypeFromTypeName } from "../metaTypes";
 
 export default define(class MetaType extends Element {
   constructor(context, string, node, name) {

package/src/element/metavariable.js

@@ -5,9 +5,9 @@ import elements from "../elements";
 
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
-import { instantiateMetavariable } from "../process/instantiate";
-import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
-import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
+import { synthetically } from "../utilities/context";
+import { typeToTypeJSON } from "../utilities/json";
+import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
 
 export default define(class Metavariable extends Element {
@@ -45,6 +45,8 @@ export default define(class Metavariable extends Element {
     return nameEqualTo;
   }
 
+  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
+
   compareMetavariableName(metavariableName) {
     const nameMetavariableName = (this.name === metavariableName),
           comparesToMetavariableName = nameMetavariableName;  ///
@@ -52,8 +54,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
-
   validate(context) {
     let validates = false;
 
@@ -105,10 +105,11 @@ export default define(class Metavariable extends Element {
   unifyFrame(frame, substitutions, generalContext, specificContext) {
     let frameUnifies = false;
 
-    const frameString = frame.getString(),
+    const context = specificContext,  ///
+          frameString = frame.getString(),
           metavariableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
     const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, substitutions, generalContext, specificContext);
 
@@ -127,20 +128,20 @@ export default define(class Metavariable extends Element {
           frameUnifies = true;
         }
       } else {
-        const { FrameSubstitution } = elements,
-              context = specificContext,  ///
-              metavariable = this,  ///
-              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
-              substitution = frameSubstitution;  ///
+        const metavariable = this;  ///
 
-        substitutions.addSubstitution(substitution, context);
+        synthetically((context) => {
+          const { FrameSubstitution } = elements;
+
+          FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
+        }, generalContext, specificContext);
 
         frameUnifies = true;
       }
     }
 
     if (frameUnifies) {
-      specificContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
     }
 
     return frameUnifies;
@@ -149,13 +150,14 @@ export default define(class Metavariable extends Element {
   unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnifies = false;
 
-    const statementString = statement.getString(),
+    const context = specificContext,  ///
+          statementString = statement.getString(),
           metavariableString = this.getString(), ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementMetavariableUnifies = this.unifyStatementMetavariable(statement, substitutions, generalContext, specificContext);
 
@@ -175,22 +177,23 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
       } else {
-        const { StatementSubstitution } = elements,
-              metavariable = this,
-              statementSubstitution = (substitution !== null ) ?
-                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
-                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
+        const metavariable = this;  ///
+
+        synthetically((context) => {
+          const { StatementSubstitution } = elements;
 
-        substitution = statementSubstitution;  ///
+          (substitution !== null) ?
+            StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+              StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
-        substitutions.addSubstitution(substitution, context);
+        }, generalContext, specificContext);
 
         statementUnifies = true;
       }
     }
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
+      context.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnifies;
@@ -199,42 +202,43 @@ export default define(class Metavariable extends Element {
   unifyReference(reference, substitutions, generalContext, specificContext) {
     let referenceUnifies = false;
 
-    const referenceString = reference.getString(),
+    const context = specificContext,  ///
+          referenceString = reference.getString(),
           metavariableString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
     const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const context = specificContext,  ///
-            metavariable = this, ///
+      const metavariable = this, ///
             simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
 
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
               substitution = simpleSubstitution,  ///
-              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference, context);
+              substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
         if (substitutionReferenceEqualToReference) {
           referenceUnifies = true;
         }
       } else {
-        const { ReferenceSubstitution } = elements,
-              metavariable = this,
-              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution;  ///
+        const metavariable = this;  ///
+
+        synthetically((context) => {
+          const { ReferenceSubstitution } = elements;
 
-        substitutions.addSubstitution(substitution, context);
+          ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
+        }, generalContext, specificContext);
 
         referenceUnifies = true;
       }
     }
 
     if (referenceUnifies) {
-      specificContext.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${referenceString}' reference with the '${metavariableString}' metavariable.`);
     }
 
     return referenceUnifies;
@@ -243,19 +247,25 @@ export default define(class Metavariable extends Element {
   unifyMetavariable(metavariable, context) {
     let metavariableUnifies;
 
-    const generalContext = context, ///
-          specificContext = context,  ///
-          generalMetavariable = this, ///
+    const specificContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
+
+    const generalMetavariable = this, ///
           specificMetavariable = metavariable,  ///
           generalMetavariableString = generalMetavariable.getString(),
           specificMetavariableString = specificMetavariable.getString();
 
-    specificContext.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable...`);
+    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable...`);
 
     metavariableUnifies = unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     if (metavariableUnifies) {
-      specificContext.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable.`);
+      context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable.`);
     }
 
     return metavariableUnifies;
@@ -269,8 +279,8 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariable = this,
-            metavariableString = this.getString(), ///
+      const metavariable = this,  ///
+            metavariableString = metavariable.getString(),
             frameMetavariableEqualToMetvariable = frame.isMetavariableEqualToMetavariable(metavariable, context);
 
       if (frameMetavariableEqualToMetvariable) {
@@ -350,7 +360,7 @@ export default define(class Metavariable extends Element {
 
     if (generalContextFilePath === specificContextFilePath) {
       const metavariable = this,  ///
-            metavariableString = this.getString(), ///
+            metavariableString = metavariable.getString(),
             referenceMetavariableEqualToMetvariable = reference.isMetavariableEqualToMetavariable(metavariable);
 
       if (referenceMetavariableEqualToMetvariable) {
@@ -394,15 +404,6 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          metavariableNode = instantiateMetavariable(string, context),
-          metavariableName = metavariableNode.getMetavariableName(),
-          name = metavariableName,  ///
-          node = metavariableNode,  ///
-          type = typeFromJSON(json, context),
-          metaType = metaTypeFromJSON(json, context),
-          metavariable = new Metavariable(context, string, node, name, type, metaType);
-
-    return metavariable;
+    ///
   }
 });

package/src/element/parameter.js

@@ -5,16 +5,21 @@ import Element from "../element";
 import { define } from "../elements";
 
 export default define(class Parameter extends Element {
-  constructor(context, string, node, name) {
-    super(context, string, node);
+  constructor(context, string, node, name, identifier) {
+    super(context, string, node, identifier);
 
     this.name = name;
+    this.identifier = identifier;
   }
   
   getName() {
     return this.name;
   }
 
+  getIdentifier() {
+    return this.identifier;
+  }
+
   findReplacementNode(substitutions) {
     let replacementNode = null;
 
@@ -25,7 +30,7 @@ export default define(class Parameter extends Element {
             if (substitutionComparesToParamter) {
               return true;
             }
-          });
+          }) || null;
 
     if (substitution !== null) {
       replacementNode = substitution.getReplacementNode();
@@ -46,10 +51,10 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const { name } = json,
+    const { name, identifier } = json,
           string = null,
           node = null,
-          parameter = new Parameter(context, string, node, name);
+          parameter = new Parameter(context, string, node, name, identifier);
 
     return parameter;
   }

package/src/element/procedureCall.js

@@ -10,6 +10,7 @@ import { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJ
 export default define(class ProcedureCall extends Element {
   constructor(context, string, node, parameters, procedureReference) {
     super(context, string, node);
+
     this.parameters = parameters;
     this.procedureReference = procedureReference;
   }
@@ -24,23 +25,24 @@ export default define(class ProcedureCall extends Element {
 
   getName() { return this.procedureReference.getName(); }
 
-  findNodes(substitutions) {
-    const nodes = this.parameters.map((parameter) => {
-      const replacementNode = parameter.findReplacementNode(substitutions),
-            node = replacementNode;  ///
+  findNodes(context) {
+    const substitutions = context.getSubstitutions(),
+          nodes = this.parameters.map((parameter) => {
+            const replacementNode = parameter.findReplacementNode(substitutions),
+                  node = replacementNode;  ///
 
-      return node;
-    });
+            return node;
+          });
 
     return nodes;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(context) {
+    let validates = false;
 
-    const procedureCallString = this.string; ///
+    const procedureCallString = this.getString(); ///
 
-    context.trace(`Verifying the '${procedureCallString}' procedure call...`, this.node);
+    context.trace(`Validating the '${procedureCallString}' procedure call...`);
 
     const name = this.getName(),
           procedure = context.findProcedureByName(name);
@@ -49,30 +51,30 @@ export default define(class ProcedureCall extends Element {
       const procedureBoolean = procedure.isBoolean();
 
       if (procedureBoolean) {
-        verifies = true;
+        validates = true;
       } else {
-        context.trace(`The '${procedureCallString}' procedure is not boolean.`, this.node);
+        context.trace(`The '${procedureCallString}' procedure is not boolean.`);
       }
     } else {
-      context.trace(`The '${procedureCallString}' procedure is not present.`, this.node);
+      context.trace(`The '${procedureCallString}' procedure is not present.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${procedureCallString}' procedure call.`, this.node);
+    if (validates) {
+      context.debug(`...validated the '${procedureCallString}' procedure call.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const procedureCallString = this.string; ///
+    const procedureCallString = this.getString(); ///
 
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
     const name = this.getName(),
-          nodes = this.findNodes(substitutions),
+          nodes = this.findNodes(context),
           procedure = context.findProcedureByName(name),
           expressions = Expressions.fromNodes(nodes, context);
 

package/src/element/proof.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import ScopedContext from "../context/scoped";
 
+import { scope } from "../utilities/context";
 import { define } from "../elements";
 
 export default define(class Proof extends Element {
@@ -26,28 +26,26 @@ export default define(class Proof extends Element {
     return statement;
   }
 
-  verify(substitutions, conclusion, context) {
+  verify(conclusion, context) {
     let verifies = false;
 
-    const scopedContext = ScopedContext.fromNothing(context); ///
+    scope((context) => {
+      const derivationVerifies = this.derivation.verify(context);
 
-    context = scopedContext; ///
+      if (derivationVerifies) {
+        const lastProofAssertion = context.getLastProofAssertion();
 
-    const derivationVerifies = this.derivation.verify(substitutions, context);
+        if (lastProofAssertion !== null) {
+          const statement = this.getStatement(),
+                conclusionStatement = conclusion.getStatement(),
+                conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
 
-    if (derivationVerifies) {
-      const lastProofAssertion = context.getLastProofAssertion();
-
-      if (lastProofAssertion !== null) {
-        const statement = this.getStatement(),
-              conclusionStatement = conclusion.getStatement(),
-              conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
-
-        if (conclusionStatementEqualToStatement) {
-          verifies = true;
+          if (conclusionStatementEqualToStatement) {
+            verifies = true;
+          }
         }
       }
-    }
+    }, context);
 
     return verifies;
   }