occam-verify-cli 0.0.1002 → 0.0.1005

package/src/proofStep.js

@@ -1,45 +1,115 @@
 "use strict";
 
-import unifyStatementWithStatementGivenEquivalences from "./unify/statementWithSttaemetnGivenEquivalences";
+import shim from "./shim";
+import Subproof from "./subproof";
+import QualifiedStatement from "./statement/qualified";
+import UnqualifiedStatement from "./statement/unqualified";
 
-export default class ProofStep {
-  constructor(subproofNode, statementNode) {
-    this.subproofNode = subproofNode;
-    this.statementNode = statementNode;
+import { nodeQuery } from "./utilities/query";
+
+const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
+      qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
+      unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement");
+
+class ProofStep {
+  constructor(subproof, qualifiedStatement, unqualifiedStatement) {
+    this.subproof = subproof;
+    this.qualifiedStatement = qualifiedStatement;
+    this.unqualifiedStatement = unqualifiedStatement;
   }
 
-  getSubproofNode() {
-    return this.subproofNode;
+  getSubproof() {
+    return this.subproof;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getQualifiedStatement() {
+    return this.qualifiedStatement;
   }
 
-  unifyStatement(statementNodeB, equivalences, localContextA, localContextB) {
-    let statementUnified = false;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
+  }
 
-    if (this.statementNode !== null) {
-      const statementNodeA = this.statementNode,  ///
-            statementUnifiedWithStatement = unifyStatementWithStatementGivenEquivalences(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+  getStatement() {
+    let statement = null;
+
+    if (this.qualifiedStatement !== null) {
+      statement = this.qualifiedStatement.getStatement();
+    }
 
-      statementUnified = statementUnifiedWithStatement;  ///
+    if (this.unqualifiedStatement !== null) {
+      statement = this.unqualifiedStatement.getStatement();
     }
 
-    return statementUnified;
+    return statement;
   }
 
-  static fromSubproofNode(subproofNode) {
-    const statementNode = null,
-          proofStep = new ProofStep(subproofNode, statementNode);
+  // unifyStatement(statementB, equivalences, localContextA, localContextB) {
+  //   let statementUnified = false;
+  //
+  //   if (this.statement !== null) {
+  //     const statementA = this.statement,  ///
+  //           statementUnifiedWithStatement = unifyStatementWithStatementGivenEquivalences(statementA, statementB, equivalences, localContextA, localContextB);
+  //
+  //     statementUnified = statementUnifiedWithStatement;  ///
+  //   }
+  //
+  //   return statementUnified;
+  // }
+
+  verify(substitutions, localContext) {
+    let verified = false;
+
+    if (false) {
+      ///
+    } else if (this.subproof !== null) {
+      const subproofVerified = this.subproof.verify(substitutions, localContext);
+
+      verified = subproofVerified;  ///
+    } else if (this.qualifiedStatement !== null) {
+      const qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, localContext);
+
+      verified = qualifiedStatementVerified;  ///
+    } else if (this.unqualifiedStatement !== null) {
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(stated, assignments, localContext);
+
+      verified = unqualifiedStatementVerified;  ///
+    }
+
+    if (verified) {
+      const proofStep = this; ///
+
+      localContext.addProofStep(proofStep);
+    }
+
+    return verified;
+  }
+
+  static fromProofStepNode(proofStepNode, fileContext) {
+    const subproofNode = subproofNodeQuery(proofStepNode),
+          qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
+          subproof = Subproof.fromSubproofNode(subproofNode, fileContext),
+          qualifiedStatement = QualifiedStatement.fromQualifiedStatementNode(qualifiedStatementNode, fileContext),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
 
     return proofStep;
   }
 
-  static fromStatementNode(statementNode) {
-    const subproofNode = null,
-          proofStep = new ProofStep(subproofNode, statementNode);
+  static fromUnqualifiedStatement(unqualifiedStatement) {
+    const subproof = null,
+          qualifiedStatement = null,
+          proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
 
     return proofStep;
   }
 }
+
+Object.assign(shim, {
+  ProofStep
+});
+
+export default ProofStep;

package/src/reference.js

@@ -1,30 +1,76 @@
 "use strict";
 
-import { nodeAsString } from "./utilities/string";
+import Metavariable from "./metavariable";
+
+import { nodeQuery } from "./utilities/query";
+
+const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
 export default class Reference {
-  constructor(metavariableNode) {
-    this.metavariableNode = metavariableNode;
+  constructor(metavariable) {
+    this.metavariable = metavariable;
   }
 
+  getMetavariable() {
+    return this.metavariable;
+  }
+
+  getString() { return this.metavariable.getString(); }
+
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
   getMetavariableNode() {
-    return this.metavariableNode;
+    const metavariableNode = this.metavariable.getNode();
+
+    return metavariableNode;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+  verify(fileContext) {
+    let verified;
+
+    const referenceString = this.getString(); ///
+
+    fileContext.trace(`Verifying the '${referenceString}' reference...`);
+
+    verified = true;
 
-    return metavariableNodeMatches;
+    if (verified) {
+      fileContext.debug(`...verified the '${referenceString}' reference.`);
+    }
+
+    return verified;
   }
 
-  asString(tokens) {
-    const string = nodeAsString(this.metavariableNode, tokens);
+  toJSON() {
+    const metavariableJSON = this.metavariable.toJSON(),
+          metavariable = metavariableJSON,  ///
+          string = this.string,
+          json = {
+            string,
+            metavariable
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json;
+
+    let { metavariable } = json;
 
-    return string;
+    json = metavariable;  ///
+
+    metavariable = Metavariable.fromJSON(json, fileContext);
+
+    const reference = new Reference(string, metavariable);
+
+    return reference;
   }
 
-  static fromMetavariableNode(metavariableNode) {
-    const reference = new Reference(metavariableNode);
+  static fromReferenceNode(referenceNode, fileContext) {
+    const metavariableNode = metavariableNodeQuery(referenceNode),
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, fileContext),
+          reference = new Reference(metavariable);
 
     return reference;
   }

package/src/rule.js

@@ -1,16 +1,31 @@
 "use strict";
 
+import Label from "./label";
+import Proof from "./proof";
+import Premise from "./premise";
+import Conclusion from "./conclusion";
+import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
-import resolveSubstitutions from "./resolve/substitutions";
-import unifyPremisesWithProofSteps from "./unify/premisesWithProofSteps";
-import unifyConclusionWithStatement from "./unify/conclusionWithStatement";
+
+import { reverse, correlate } from "./utilities/array";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+
+const proofNodeQuery = nodeQuery("/rule/proof"),
+      labelNodesQuery = nodesQuery("/rule/label"),
+      premiseNodesQuery = nodesQuery("/rule/premise"),
+      conclusionNodeQuery = nodeQuery("/rule/conclusion");
 
 export default class Rule {
-  constructor(labels, premises, conclusion, fileContext) {
+  constructor(fileContext, labels, premises, conclusion, proof) {
+    this.fileContext = fileContext;
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
-    this.fileContext = fileContext;
+    this.proof = proof;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
   getLabels() {
@@ -25,50 +40,204 @@ export default class Rule {
     return this.conclusion;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getProof() {
+    return this.proof;
   }
 
-  unifyStatement(statementNode, localContext) {
-    let statementUnified = false;
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+
+      if (metavariableNodeMatches) {
+        return true;
+      }
+    });
 
-    const substitutions = Substitutions.fromNothing(),
-          proofSteps = localContext.getProofSteps(),
-          premisesA = this.premises,
-          proofStepsB = proofSteps, ///
-          fileContextA = this.fileContext,  ///
-          localContextB = localContext, ///
-          premisesUnified = unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
+    return metavariableNodeMatches;
+  }
 
-    if (premisesUnified) {
-      const conclusionA = this.conclusion,  ///
-            conclusionUnified = unifyConclusionWithStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
+  unifyStatement(statement, localContext) {
+    let statementUnified = false;
 
-      if (conclusionUnified) {
-        const substitutionsResolved = resolveSubstitutions(substitutions, fileContextA, localContextB);
+    const proofSteps = localContext.getProofSteps(),
+          substitutions = Substitutions.fromNothing(),
+          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
-        statementUnified = substitutionsResolved; ///
-      }
+    if (proofStepsUnified) {
+      statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);
     }
 
     return statementUnified;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
-      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
+  unifyProofSteps(proofSteps, substitutions, localContext) {
+    let proofStepsUnified;
 
-      if (metavariableNodeMatches) {
+    let premises = this.premises;
+
+    premises = reverse(premises); ///
+
+    proofSteps = reverse(proofSteps); ///
+
+    proofStepsUnified = correlate(premises, proofSteps, (premise, proofStep) => {
+      const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+
+      if (proofStepUnified) {
         return true;
       }
     });
 
-    return metavariableNodeMatches;
+    return proofStepsUnified;
+  }
+
+  verify(fileContext) {
+    let verified = false;
+
+    const labelsString = labelsStringFromLabels(this.labels);
+
+    fileContext.trace(`Verifying the '${labelsString}' rule...`);
+
+    const labelsVerified = this.labels.every((label) => {
+      const labelVVerified = label.verify(fileContext);
+
+      if (labelVVerified) {
+        return true;
+      }
+    });
+
+    if (labelsVerified) {
+      const localContext = LocalContext.fromFileContext(fileContext),
+            premisesVerified = this.premises.every((premise) => {
+              const premiseVerified = premise.verify(localContext);
+
+              if (premiseVerified) {
+                return true;
+              }
+            });
+
+      if (premisesVerified) {
+        const conclusionVerified = this.conclusion.verify(localContext);
+
+        if (conclusionVerified) {
+          let proofVerified = true; ///
+
+          if (this.proof !== null) {
+            const substitutions = Substitutions.fromNothing();
+
+            proofVerified = this.proof.verify(substitutions, this.conclusion, localContext);
+          }
+
+          if (proofVerified) {
+            const rule = this;  ///
+
+            fileContext.addRule(rule);
+
+            verified = true;
+          }
+        }
+      }
+    }
+
+    if (verified) {
+      fileContext.debug(`...verified the '${labelsString}' rule.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          premisesJSON = this.premises.map((premise) => {
+            const premiseJSON = premise.toJSON();
+
+            return premiseJSON;
+          }),
+          conclusionJSON = this.conclusion.toJSON(),
+          labels = labelsJSON,  ///
+          premises = premisesJSON,  ///
+          conclusion = conclusionJSON,  ///
+          json = {
+            labels,
+            premises,
+            conclusion
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let rule;
+
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSON(json, fileContext);
+
+      return label;
+    });
+
+    let { premises } = json;
+
+    const premisesJSON = premises;  ///
+
+    premises = premisesJSON.map((premiseJSON) => {
+      const json = premiseJSON, ///
+            premise = Premise.fromJSON(json, fileContext);
+
+      return premise;
+    });
+
+    let { conclusion } = json;
+
+    const conclusionJSON = conclusion;  ///
+
+    json = conclusionJSON;  ///
+
+    conclusion = Conclusion.fromJSON(json, fileContext);
+
+    const proof = null;
+
+    rule = new Rule(fileContext, labels, premises, conclusion, proof);
+
+    return rule;
   }
 
-  static fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext) {
-    const rule = new Rule(labels, premises, conclusion, fileContext);
+  static fromRuleNode(ruleNode, fileContext) {
+    const proofNode = proofNodeQuery(ruleNode),
+          labelNodes = labelNodesQuery(ruleNode),
+          premiseNodes = premiseNodesQuery(ruleNode),
+          conclusionNode = conclusionNodeQuery(ruleNode),
+          labels = labelNodes.map((labelNode) => {
+            const label = Label.fromLabelNode(labelNode, fileContext);
+
+            return label;
+          }),
+          premises = premiseNodes.map((premiseNode) => {
+            const premise = Premise.fromPremiseNode(premiseNode, fileContext);
+
+            return premise;
+          }),
+          conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext),
+          proof = Proof.fromProofNode(proofNode, fileContext),
+          rule = new Rule(fileContext, labels, premises, conclusion, proof);
 
     return rule;
   }
 }
+
+function labelsStringFromLabels(labels) {
+  const labelsString = labels.map((label) => {
+          const labelString = label.getString();
+
+          return labelString;
+        });
+
+  return labelsString;
+}

package/src/ruleNames.js

@@ -1,4 +1,4 @@
 "use strict";
 
 export const TERM_RULE_NAME = "term";
-export const STATEMENT_RULE_NAME = "statement";
+export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";

package/src/statement/qualified.js

@@ -0,0 +1,104 @@
+"use strict";
+
+import Statement from "../statement";
+import Reference from "../reference";
+import unifyMixins from "../mixins/statement/qualified/unify";
+import LocalContext from "../context/local";
+
+import { trim } from "../utilities/string";
+import { nodeQuery } from "../utilities/query";
+import { assignAssignments } from "../utilities/assignments";
+
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement"),
+      referenceNodeQuery = nodeQuery("/qualifiedStatement/reference");
+
+export default class QualifiedStatement {
+  constructor(string, statement, reference) {
+    this.string = string;
+    this.statement = statement;
+    this.reference = reference;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  getMetavariableNode() { return this.reference.getMetavariableNode(); }
+
+  verify(substitutions, localContext) {
+    let verified;
+
+    const qualifiedStatementString = trim(this.string); ///
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`);
+
+    const stated = true,
+          assignments = [],
+          statementVerified = this.statement.verify(assignments, stated, localContext);
+
+    if (statementVerified) {
+      const unified = this.unify(substitutions, localContext);
+
+      if (unified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        verified = assignmentsAssigned; ///
+      }
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`);
+    }
+
+    return verified;
+  }
+
+  unify(substitutions, localContext) {
+    let unified;
+
+    const qualifiedStatement = this,  ///
+          qualifiedStatementString = trim(this.string); ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
+
+    unified = unifyMixins.some((unifyMixin) => {
+      const unified = unifyMixin(qualifiedStatement, substitutions, localContext);
+
+      return unified;
+    });
+
+    if (unified) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
+    }
+
+    return unified;
+  }
+
+  static fromQualifiedStatementNode(qualifiedStatementNode, fileContext) {
+    let qualifiedStatement = null;
+
+    if (qualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            referenceNode = referenceNodeQuery(qualifiedStatementNode),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statement = (statementNode !== null) ?
+                          Statement.fromStatementNode(statementNode, localContext) :
+                            null,
+            reference = Reference.fromReferenceNode(referenceNode, fileContext),
+            node = qualifiedStatementNode,  ///
+            string = fileContext.nodeAsString(node);
+
+        qualifiedStatement = new QualifiedStatement(string, statement, reference);
+    }
+
+    return qualifiedStatement;
+  }
+}

package/src/statement/unqualified.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import Statement from "../statement";
+import LocalContext from "../context/local";
+
+import { trim } from "../utilities/string";
+import { nodeQuery } from "../utilities/query";
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
+
+export default class UnqualifiedStatement {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    const unqualifiedStatementString = trim(this.string); ///
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
+
+    const statementVerified = this.statement.verify(assignments, stated, localContext);
+
+    verified = statementVerified; ///
+
+    if (verified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
+    }
+
+    return verified;
+  }
+
+  static fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext) {
+    let unqualifiedStatement = null;
+
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            localContext = LocalContext.fromFileContext(fileContext),
+            statement = (statementNode !== null) ?
+                          Statement.fromStatementNode(statementNode, localContext) :
+                            null,
+            node = unqualifiedStatementNode,  ///
+            string = fileContext.nodeAsString(node);
+
+      unqualifiedStatement = new UnqualifiedStatement(string, statement);
+    }
+
+    return unqualifiedStatement;
+  }
+}