occam-verify-cli 0.0.1035 → 0.0.1037

package/src/metavariable.js

@@ -3,6 +3,7 @@
 import shim from "./shim";
 import Argument from "./argument";
 import LocalContext from "./context/local";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableNameFromMetavariableNode } from "./utilities/name";
@@ -10,16 +11,22 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable");
+      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
 export default class Metavariable {
-  constructor(string, node, name, metaType) {
+  constructor(fileContext, string, node, name, metaType) {
+    this.fileContext = fileContext;
     this.string = string;
     this.node = node;
     this.name = name;
     this.metaType = metaType;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   getString() {
     return this.string;
   }
@@ -105,6 +112,48 @@ export default class Metavariable {
     return verifiedAtTopLevel;
   }
 
+  unifyStatement(statement, substitutions, localContext) {
+    let statementUnified = false;
+
+    const statementString = statement.getString(),
+          metavariableString = this.string;
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
+          substitution = simpleSubstitution;  ///
+
+    if (substitution !== null) {
+      const statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnified = true;
+      }
+    } else {
+      const metavariable = this, ///
+            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+
+      if (metavariable === statementMetavariable) {
+        statementUnified = true;
+      } else {
+        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+              substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnified = true;
+      }
+    }
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+    }
+
+    return statementUnified;
+  }
+
   toJSON() {
     const metaTypeJSON = (this.metaType !== null) ?
                             this.metaType.toJSON() :
@@ -129,7 +178,7 @@ export default class Metavariable {
           node = metavariableNode,  ///
           name = metavariableName,  ///
           metaType = metaTypeFromJSON(json, fileContext),
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -140,7 +189,7 @@ export default class Metavariable {
           name = metavariableName,  ///
           string = fileContext.nodeAsString(node),
           metaType = null,
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -156,7 +205,7 @@ export default class Metavariable {
           node = metavariableNode,  ///
           name = metavariableName,  ///
           metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
-          metavariable = new Metavariable(string, node, name, metaType);
+          metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
   }
@@ -173,4 +222,18 @@ function metaTypeFromJSON(json, fileContext) {
   }
 
   return metaType;
-}
+}
+
+function statementMetavariableFromStatementNode(statementNode, localContext) {
+  let statementMetavariable = null;
+
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+
+  if (statementMetavariableNode !== null) {
+    const statementMetavariableName = variableNameFromMetavariableNode(statementMetavariableNode);
+
+    statementMetavariable = localContext.findMetavariableByMetavariableName(statementMetavariableName);
+  }
+
+  return statementMetavariable;
+}

package/src/mixins/statement/verify.js

@@ -8,11 +8,11 @@ import verifyJudgement from "../../verify/judgement";
 import verifyDeclaration from "../../verify/declaration";
 import metavariableUnifier from "../../unifier/metavariable";
 import verifyDefinedAssertion from "../../verify/assertion/defined";
-import verifySubproofAssertion from "../../verify/assertion/subproof";
 import verifyContainedAssertion from "../../verify/assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 import { metavariableNameFromMetavariableNode } from "../../utilities/name";
+import SubproofAssertion from "../../assertion/subproof";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
@@ -198,7 +198,8 @@ function verifyAsSubproofAssertion(statement, assignments, stated, localContext)
 
     localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext);
+    const subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext),
+          subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
     verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 

package/src/premise.js

@@ -12,9 +12,8 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
 export default class Premise {
-  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
+  constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
-    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -22,10 +21,6 @@ export default class Premise {
     return this.fileContext;
   }
 
-  getSubproofAssertion() {
-    return this.subproofAssertion;
-  }
-
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -34,6 +29,30 @@ export default class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -85,27 +104,6 @@ export default class Premise {
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
-
-    if (this.subproofAssertion !== null) {
-      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   verify(localContext) {
     let verified = false;
 
@@ -143,33 +141,22 @@ export default class Premise {
 
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-      subproofAssertionJSON = (this.subproofAssertion !== null) ?
-        this.subproofAssertion.toJSON() :
-        null,
-      unqualifiedStatement = unqualifiedStatementJSON,  ///
-      subproofAssertion = subproofAssertionJSON,  ///
-      json = {
-        unqualifiedStatement,
-        subproofAssertion
-      };
+          unqualifiedStatement = unqualifiedStatementJSON,  ///
+          json = {
+            unqualifiedStatement
+          };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { subproofAssertion, unqualifiedStatement } = json;
+    let { unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    json = subproofAssertion; ///
-
-    subproofAssertion = (json !== null) ?
-                          SubproofAssertion.fromJSON(json, fileContext) :
-                            null;
-
-    const premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
+    const premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise;
   }
@@ -177,8 +164,7 @@ export default class Premise {
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          premise = new Premise(fileContext, subproofAssertion, unqualifiedStatement);
+          premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise
   }

package/src/substitution/statementForMetavariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
@@ -53,11 +54,18 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB) {
+  static fromStatementAndMetavariable(statement, metavariable, localContext) {
+    let statementNode = statement.getNode();
+
     statementNode = stripBracketsFromStatement(statementNode); ///
 
-    const substitution = null,
-          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext); ///
+
+    const string = stringFromStatementAndMetavariable(statement, metavariable),
+          substitution = null,
+          metavariableNode = metavariable.getNode(),
           statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
@@ -74,6 +82,15 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
+
+  return string;
+}
+
+
 function substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB) {
   let substitution = null;
 

package/src/substitution/termForVariable.js

@@ -90,7 +90,7 @@ export default class TermForVariableSubstitution extends Substitution {
 
     const { Term } = shim;
 
-    term = Term.fromTermNode(termNode, localContext)
+    term = Term.fromTermNode(termNode, localContext); ///
 
     const string = stringFromTermAndVariable(term, variable),
           variableNode = variable.getNode(),

package/src/supposition.js

@@ -12,9 +12,8 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
-  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
+  constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
-    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -22,10 +21,6 @@ export default class Supposition {
     return this.fileContext;
   }
 
-  getSubproofAssertion() {
-    return this.subproofAssertion;
-  }
-
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -34,6 +29,65 @@ export default class Supposition {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
+  verify(localContext) {
+    let verified = false;
+
+    const suppositionString = this.getString(); ///
+
+    if (this.unqualifiedStatement !== null) {
+      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
+
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const { ProofStep } = shim,
+                proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
+
+          localContext.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        localContext.debug(`...verified the '${suppositionString}' supposition.`);
+      }
+    } else {
+      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -85,91 +139,24 @@ export default class Supposition {
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
-
-    if (this.subproofAssertion !== null) {
-      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
-  verify(localContext) {
-    let verified = false;
-
-    const suppositionString = this.getString(); ///
-
-    if (this.unqualifiedStatement !== null) {
-      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
-
-      const stated = true,
-            assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        if (assignmentsAssigned) {
-          const { ProofStep } = shim,
-                proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
-
-          localContext.addProofStep(proofStep);
-
-          verified = true;
-        }
-      }
-
-      if (verified) {
-        localContext.debug(`...verified the '${suppositionString}' supposition.`);
-      }
-    } else {
-      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-          subproofAssertionJSON = (this.subproofAssertion !== null) ?
-                                     this.subproofAssertion.toJSON() :
-                                       null,
           unqualifiedStatement = unqualifiedStatementJSON,  ///
-          subproofAssertion = subproofAssertionJSON,  ///
           json = {
-            unqualifiedStatement,
-            subproofAssertion
+            unqualifiedStatement
           };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { subproofAssertion, unqualifiedStatement } = json;
+    let { unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    json = subproofAssertion; ///
-
-    subproofAssertion = (json !== null) ?
-                          SubproofAssertion.fromJSON(json, fileContext) :
-                            null;
-
-    const supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
+    const supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }
@@ -177,8 +164,7 @@ export default class Supposition {
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition
   }

package/src/unifier/metaLevel.js

@@ -3,11 +3,10 @@
 import shim from "../shim";
 import Unifier from "../unifier";
 import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
-import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
-import { variableNameFromVariableNode } from "../utilities/name";
+import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       frameNodeQuery = nodeQuery("/frame!"),
@@ -49,9 +48,16 @@ class MetaLevelUnifier extends Unifier {
                   statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA);
 
             if (statementSubstitutionNodeA === null) {
-              const metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB);
-
-              statementUnifiedWithStatement = metavariableUnifiedWithStatement; ///
+              const { Statement } = shim,
+                    metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+                    metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
+                    statementB = Statement.fromStatementNode(statementNodeB, localContextB),
+                    localContext = localContextB, ///
+                    metavariable = metavariableA, ///
+                    statement = statementB, ///
+                    statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
+
+              statementUnifiedWithStatement = statementUnified; ///
             } else {
               const substitutionNodeA = statementSubstitutionNodeA, ///
                     metavariableUnifiedWithStatementGivenSubstitution = unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);

package/src/unifier/statementWithCombinator.js

@@ -5,7 +5,6 @@ import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
-import local from "../context/local";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),

package/src/variable.js

@@ -8,19 +8,25 @@ import { nodeQuery } from "./utilities/query";
 import { objectType } from "./type";
 import { variableNameFromVariableNode} from "./utilities/name";
 import { variableNodeFromVariableString } from "./utilities/node";
+import local from "./context/local";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable"),
       termVariableNodeQuery = nodeQuery("/term/variable");
 
 export default class Variable {
-  constructor(string, node, name, type) {
+  constructor(localContext, string, node, name, type) {
+    this.localContext = localContext; ///
     this.string = string;
     this.node = node;
     this.name = name;
     this.type = type;
   }
 
+  getLocalContext() {
+    return this.localContext;
+  }
+
   getString() {
     return this.string;
   }
@@ -195,10 +201,11 @@ export default class Variable {
           variableString = string,  ///
           variableNode = variableNodeFromVariableString(variableString, lexer, parser),
           variableName = variableNameFromVariableNode(variableNode),
+          localContext = LocalContext.fromFileContext(fileContext),
           node = variableNode,
           name = variableName,  ///
           type = typeFromJSON(json, fileContext),
-          variable = new Variable(string, node, name, type);
+          variable = new Variable(localContext, string, node, name, type);
 
     return variable;
   }
@@ -213,7 +220,7 @@ export default class Variable {
             name = variableName,  ///
             type = null;
 
-      variable = new Variable(string, node, name, type);
+      variable = new Variable(localContext, string, node, name, type);
     }
 
     return variable;
@@ -224,7 +231,7 @@ export default class Variable {
           variableName = variableNameFromVariableNode(variableNode),
           string = localContext.nodeAsString(node),
           name = variableName,  ///
-          variable = new Variable(string, node, name, type);
+          variable = new Variable(localContext, string, node, name, type);
 
     return variable;
   }
@@ -240,7 +247,7 @@ export default class Variable {
           node = variableNode,  ///
           name = variableName,  ///
           type = Type.fromTypeNode(typeNode, localContext),
-          variable = new Variable(string, node, name, type);
+          variable = new Variable(localContext, string, node, name, type);
 
     return variable;
   }