occam-verify-cli 0.0.1250 → 0.0.1252

package/src/dom/consequent.js

@@ -19,24 +19,6 @@ export default domAssigned(class Consequent {
     return this.statement;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
-
-    const consequent = this,  ///
-          statementString = statement.getString(),
-          consequentString = consequent.getString();
-
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
-
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
-    }
-
-    return statementUnified;
-  }
-
   verify(context) {
     let verified = false;
 
@@ -61,6 +43,24 @@ export default domAssigned(class Consequent {
     return verified;
   }
 
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const consequent = this,  ///
+          statementString = statement.getString(),
+          consequentString = consequent.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
+    }
+
+    return statementUnified;
+  }
+
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///

package/src/dom/metavariable.js

@@ -113,6 +113,126 @@ export default domAssigned(class Metavariable {
     return substitutionMatched;
   }
 
+  verify(context) {
+    let verified;
+
+    const metavariableString = this.string; ///
+
+    context.trace(`Verifying the '${metavariableString}' metavariable...`);
+
+    const metavariable = this, ///
+          generalContext = context,  ///
+          specificContext = context,  ///
+          metavariablePresent = generalContext.isMetavariablePresent(metavariable, generalContext, specificContext);
+
+    verified = metavariablePresent; ///
+
+    if (verified) {
+      context.debug(`...verified the '${metavariableString}' metavariable.`);
+    }
+
+    return verified;
+  }
+
+  verifyType(fileContext) {
+    let typeVerified;
+
+    if (this.type === null) {
+      typeVerified = true;
+    } else {
+      if (this.type === objectType) {
+        typeVerified = true;
+      } else {
+        const typeName = this.type.getName();
+
+        fileContext.trace(`Verifying the '${typeName}' type...`);
+
+        const type = fileContext.findTypeByTypeName(typeName);
+
+        if (type === null) {
+          fileContext.debug(`The '${typeName}' type is missing.`);
+        } else {
+          this.type = type; ///
+
+          typeVerified = true;
+        }
+
+        if (typeVerified) {
+          fileContext.debug(`...verified the '${typeName}' type.`);
+        }
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyWhenDeclared(fileContext) {
+    let verifiedWhenDeclared = false;
+
+    const metavariableString = this.string; ///
+
+    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
+
+    const metavariableNode = this.node, ///
+          termNode = termNodeQuery(metavariableNode);
+
+    if (termNode !== null) {
+      fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
+    } else {
+      const metavariableName = this.name, ///
+        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+      if (metavariablePresent) {
+        fileContext.debug(`The '${metavariableName}' metavariable has already been declared.`);
+      } else {
+        const variableName = this.name, ///
+          variablePresent = fileContext.isVariablePresentByVariableName(variableName);
+
+        if (variablePresent) {
+          fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
+        } else {
+          const typeVerified = this.verifyType(fileContext);
+
+          verifiedWhenDeclared = typeVerified;
+        }
+      }
+    }
+
+    if (verifiedWhenDeclared) {
+      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
+    }
+
+    return verifiedWhenDeclared;
+  }
+
+  verifyGivenMetaType(metaType, context) {
+    let verifiedGivenMetaType = false;
+
+    const metavariableString = this.string,  ///
+          metaTypeString = metaType.getString();
+
+    context.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
+
+    let metavariable = this;  ///
+
+    const specificContext = context,  ///
+          generalContext = context; ///
+
+    metavariable = generalContext.findMetavariable(metavariable, generalContext, specificContext);
+
+    if (metavariable !== null) {
+      const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
+
+      verifiedGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
+    }
+
+    if (verifiedGivenMetaType) {
+      context.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+    }
+
+    return verifiedGivenMetaType;
+  }
+
   unifyFrame(frame, substitutions, generalContext, specificContext) {
     let frameUnified = false;
 
@@ -374,126 +494,6 @@ export default domAssigned(class Metavariable {
     return statementMetavariableUnified;
   }
 
-  verify(context) {
-    let verified;
-
-    const metavariableString = this.string; ///
-
-    context.trace(`Verifying the '${metavariableString}' metavariable...`);
-
-    const metavariable = this, ///
-          generalContext = context,  ///
-          specificContext = context,  ///
-          metavariablePresent = generalContext.isMetavariablePresent(metavariable, generalContext, specificContext);
-
-    verified = metavariablePresent; ///
-
-    if (verified) {
-      context.debug(`...verified the '${metavariableString}' metavariable.`);
-    }
-
-    return verified;
-  }
-
-  verifyType(fileContext) {
-    let typeVerified;
-
-    if (this.type === null) {
-      typeVerified = true;
-    } else {
-      if (this.type === objectType) {
-        typeVerified = true;
-      } else {
-        const typeName = this.type.getName();
-
-        fileContext.trace(`Verifying the '${typeName}' type...`);
-
-        const type = fileContext.findTypeByTypeName(typeName);
-
-        if (type === null) {
-          fileContext.debug(`The '${typeName}' type is missing.`);
-        } else {
-          this.type = type; ///
-
-          typeVerified = true;
-        }
-
-        if (typeVerified) {
-          fileContext.debug(`...verified the '${typeName}' type.`);
-        }
-      }
-    }
-
-    return typeVerified;
-  }
-
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared = false;
-
-    const metavariableString = this.string; ///
-
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
-
-    const metavariableNode = this.node, ///
-          termNode = termNodeQuery(metavariableNode);
-
-    if (termNode !== null) {
-      fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
-    } else {
-      const metavariableName = this.name, ///
-            metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
-
-      if (metavariablePresent) {
-        fileContext.debug(`The '${metavariableName}' metavariable has already been declared.`);
-      } else {
-        const variableName = this.name, ///
-              variablePresent = fileContext.isVariablePresentByVariableName(variableName);
-
-        if (variablePresent) {
-          fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
-        } else {
-          const typeVerified = this.verifyType(fileContext);
-
-          verifiedWhenDeclared = typeVerified;
-        }
-      }
-    }
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
-  verifyGivenMetaType(metaType, context) {
-    let verifiedGivenMetaType = false;
-
-    const metavariableString = this.string,  ///
-          metaTypeString = metaType.getString();
-
-    context.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
-
-    let metavariable = this;  ///
-
-    const specificContext = context,  ///
-          generalContext = context; ///
-
-    metavariable = generalContext.findMetavariable(metavariable, generalContext, specificContext);
-
-    if (metavariable !== null) {
-      const metavariableMetaTypeEqualToMetaType = metavariable.isMetaTypeEqualTo(metaType);
-
-      verifiedGivenMetaType = metavariableMetaTypeEqualToMetaType;  ///
-    }
-
-    if (verifiedGivenMetaType) {
-      context.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
-    }
-
-    return verifiedGivenMetaType;
-  }
-
   toJSON() {
     const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           typeJSON = typeToTypeJSON(this.type),

package/src/dom/premise.js

@@ -26,6 +26,52 @@ export default domAssigned(class Premise {
     return this.procedureCall;
   }
 
+  verify(context) {
+    let verified = false;
+
+    const premiseString = this.string; ///
+
+    context.trace(`Verifying the '${premiseString}' premise...`);
+
+    if (false) {
+      ///
+    } else if (this.statement !== null) {
+      const stated = true,
+            assignments = [],
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const { ProofStep } = dom,
+                proofStep = ProofStep.fromStatement(this.statement, context),
+                proofStepSubproof = proofStep;  ///
+
+          context.addProofStepSubproof(proofStepSubproof);
+
+          verified = true;
+        }
+      }
+    } else if (this.procedureCall !== null) {
+      const stated = true,
+            assignments = null,
+            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
+
+      if (procedureCallVerified) {
+        verified = true;
+      }
+    } else {
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
+    }
+
+    if (verified) {
+      context.debug(`...verified the '${premiseString}' premise.`);
+    }
+
+    return verified;
+  }
+
   unifyIndependently(substitutions, context) {
     let unifiedIndependently;
 
@@ -139,52 +185,6 @@ export default domAssigned(class Premise {
     return statementUnified;
   }
 
-  verify(context) {
-    let verified = false;
-
-    const premiseString = this.string; ///
-
-    context.trace(`Verifying the '${premiseString}' premise...`);
-
-    if (false) {
-      ///
-    } else if (this.statement !== null) {
-      const stated = true,
-            assignments = [],
-            statementVerified = this.statement.verify(assignments, stated, context);
-
-      if (statementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
-
-        if (assignmentsAssigned) {
-          const { ProofStep } = dom,
-                proofStep = ProofStep.fromStatement(this.statement, context),
-                proofStepSubproof = proofStep;  ///
-
-          context.addProofStepSubproof(proofStepSubproof);
-
-          verified = true;
-        }
-      }
-    } else if (this.procedureCall !== null) {
-      const stated = true,
-            assignments = null,
-            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
-
-      if (procedureCallVerified) {
-        verified = true;
-      }
-    } else {
-      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
-    }
-
-    if (verified) {
-      context.debug(`...verified the '${premiseString}' premise.`);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),

package/src/dom/reference.js

@@ -219,6 +219,16 @@ export default domAssigned(class Reference {
     return reference;
   }
 
+  static fromMetavariableNode(metavariableNode, fileContext) {
+    const { Metavariable } = dom,
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
+          reference = new Reference(metavariable);
+
+    return reference;
+  }
+
   static fromProcedureCallNode(procedureCallNode, fileContext) {
     let reference = null;
 

package/src/dom/supposition.js

@@ -26,6 +26,52 @@ export default domAssigned(class Supposition {
     return this.procedureCall;
   }
 
+  verify(context) {
+    let verified = false;
+
+    const suppositionString = this.string; ///
+
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
+
+    if (false) {
+      ///
+    } else if (this.statement !== null) {
+      const stated = true,
+            assignments = [],
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const { ProofStep } = dom,
+                proofStep = ProofStep.fromStatement(this.statement, context),
+                proofStepSubproof = proofStep;  ///
+
+          context.addProofStepSubproof(proofStepSubproof);
+
+          verified = true;
+        }
+      }
+    } else if (this.procedureCall !== null) {
+      const stated = true,
+            assignments = null,
+            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
+
+      if (procedureCallVerified) {
+        verified = true;
+      }
+    } else {
+      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
+    }
+
+    if (verified) {
+      context.debug(`...verified the '${suppositionString}' supposition.`);
+    }
+
+    return verified;
+  }
+
   unifyIndependently(substitutions, context) {
     let unifiedIndependently;
 
@@ -139,52 +185,6 @@ export default domAssigned(class Supposition {
     return statementUnified;
   }
 
-  verify(context) {
-    let verified = false;
-
-    const suppositionString = this.string; ///
-
-    context.trace(`Verifying the '${suppositionString}' supposition...`);
-
-    if (false) {
-      ///
-    } else if (this.statement !== null) {
-      const stated = true,
-            assignments = [],
-            statementVerified = this.statement.verify(assignments, stated, context);
-
-      if (statementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
-
-        if (assignmentsAssigned) {
-          const { ProofStep } = dom,
-                proofStep = ProofStep.fromStatement(this.statement, context),
-                proofStepSubproof = proofStep;  ///
-
-          context.addProofStepSubproof(proofStepSubproof);
-
-          verified = true;
-        }
-      }
-    } else if (this.procedureCall !== null) {
-      const stated = true,
-            assignments = null,
-            procedureCallVerified = this.procedureCall.verify(assignments, stated, context);
-
-      if (procedureCallVerified) {
-        verified = true;
-      }
-    } else {
-      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
-    }
-
-    if (verified) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),

package/src/unifier/metaLevel.js

@@ -9,12 +9,11 @@ import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term"),
       frameNodeQuery = nodeQuery("/frame"),
-      referenceNodeQuery = nodeQuery("/reference"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
   unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
@@ -69,24 +68,27 @@ class MetaLevelUnifier extends Unifier {
       }
     },
     {
-      generalNodeQuery: referenceMetavariableNodeQuery,
-      specificNodeQuery: referenceNodeQuery,
-      unify: (generalReferenceMetavariableNode, specificReferenceNode, substitutions, generalContext, specificContext) => {
+      generalNodeQuery: declarationMetavariableNodeQuery,
+      specificNodeQuery: declarationMetavariableNodeQuery,
+      unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
         let referenceUnified;
 
-        const { Reference, Metavariable } = dom,
-              referenceNode = specificReferenceNode, ///
-              metavariableNode = generalReferenceMetavariableNode;  ///
+        const { Reference, Metavariable } = dom;
 
-        let context;
+        let context,
+            metavariableNode;
 
         context = generalContext; ///
 
+        metavariableNode = generalDeclarationMetavariableNode;  ///
+
         const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
 
         context = specificContext;  ///
 
-        const reference = Reference.fromReferenceNode(referenceNode, context);
+        metavariableNode = specificDeclarationMetavariableNode; ///
+
+        const reference = Reference.fromMetavariableNode(metavariableNode, context);
 
         referenceUnified = metavariable.unifyReference(reference, substitutions, generalContext, specificContext);