occam-verify-cli 0.0.1111 → 0.0.1114

package/src/dom/premise.js

@@ -0,0 +1,173 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { assignAssignments } from "../utilities/assignments";
+import { subproofAssertionFromStatement } from "../utilities/verification";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default domAssigned(class Premise {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  unifyIndependently(substitutions, generalContext, specificContext) {
+    let unifiedIndependently;
+
+    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+
+    unifiedIndependently = statementResolvedIndependently;  ///
+
+    return unifiedIndependently;
+  }
+
+  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
+    let proofStepUnified = false;
+
+    const subproof = proofStep.getSubproof(),
+          statement = proofStep.getStatement();
+
+    substitutions.snapshot();
+
+    if (subproof !== null) {
+      const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+
+      proofStepUnified = subproofUnified; ///
+    }
+
+    if (statement !== null) {
+      const statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      proofStepUnified = statementUnified;  ///
+    }
+
+    if (proofStepUnified) {
+      substitutions.resolve(generalContext, specificContext);
+    }
+
+    const context = specificContext;  ///
+
+    proofStepUnified ?
+      substitutions.continue() :
+        substitutions.rollback(context);
+
+    return proofStepUnified;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const premise = this, ///
+          premiseString = premise.getString(),
+          statementString = statement.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const context = generalContext,
+          subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+    }
+
+    if (subproofUnified) {
+      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
+  verify(context) {
+    let verified = false;
+
+    const premiseString = this.string; ///
+
+    if (this.statement !== null) {
+      context.trace(`Verifying the '${premiseString}' premise...`);
+
+      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);
+
+          context.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        context.debug(`...verified the '${premiseString}' premise.`);
+      }
+    } else {
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static name = "Premise";
+
+  static fromJSON(json, fileContext) {
+    const statement = statementFromJSON(json, fileContext),
+          string = statement.getString(),
+          premise = new Premise(string, statement);
+
+    return premise;
+  }
+
+  static fromPremiseNode(premiseNode, fileContext) {
+    const { Statement } = dom,
+          statement = Statement.fromPremiseNode(premiseNode, fileContext),
+          statementString = statement.getString(),
+          string = statementString, ///
+          premise = new Premise(string, statement);
+
+    return premise
+  }
+});

package/src/{proof.js → dom/proof.js}

@@ -1,13 +1,14 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import { nodeQuery } from "./utilities/query";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation");
 
-class Proof {
+export default domAssigned(class Proof {
   constructor(derivation) {
     this.derivation = derivation;
   }
@@ -52,11 +53,13 @@ class Proof {
     return verified;
   }
 
+  static name = "Proof";
+
   static fromProofNode(proofNode, fileContext) {
     let proof = null;
 
     if (proofNode !== null) {
-      const { Derivation } = shim,
+      const { Derivation } = dom,
             derivationNode = derivationNodeQuery(proofNode),
             derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
 
@@ -65,10 +68,4 @@ class Proof {
 
     return proof;
   }
-}
-
-Object.assign(shim, {
-  Proof
 });
-
-export default Proof;

package/src/dom/proofStep.js

@@ -0,0 +1,173 @@
+"use strict";
+
+import dom from "../dom";
+import unifyMixins from "../mixins/proofStep/unify";
+import Substitutions from "../substitutions";
+
+import { domAssigned } from "../dom";
+import { assignAssignments } from "../utilities/assignments";
+
+export default domAssigned(class ProofStep {
+  constructor(string, subproof, statement, reference) {
+    this.string = string;
+    this.subproof = subproof;
+    this.statement = statement;
+    this.reference = reference;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getSubproof() {
+    return this.subproof;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  getReference() {
+    return this.reference;
+  }
+
+  isQualified() {
+    const qualified = (this.reference !== null);
+
+    return qualified;
+  }
+
+  unify(substitutions, context) {
+    let unified;
+
+    if (this.subproof !== null) {
+      unified = true; ///
+    }
+
+    if (this.statement !== null) {
+      const proofStepString = this.string;  ///
+
+      context.trace(`Unifying the '${proofStepString}' proof step...`);
+
+      unified = unifyMixins.some((unifyMixin) => {
+        const unified = unifyMixin(this.statement, this.reference, substitutions, context);
+
+        if (unified) {
+          return true;
+        }
+      });
+
+      if (unified) {
+        context.debug(`...unified the '${proofStepString}' proof step.`);
+      }
+    }
+
+    return unified;
+  }
+
+  unifyStatement(statement, context) {
+    let statementUnified;
+
+    const specificContext = context, ///
+          generalContext = context, ///
+          substitutions = Substitutions.fromNothing();
+
+    if (this.subproof !== null) {
+      const subproofUnified = statement.unifySubproof(this.subproof, substitutions, generalContext, specificContext);
+
+      statementUnified = subproofUnified; ///
+    }
+
+    if (this.statement !== null) {
+      statementUnified = statement.unifyStatement(this.statement, substitutions, generalContext, specificContext);
+    }
+
+    if (statementUnified) {
+      const equivalences = context.getEquivalences(),
+            substitutionsUnified = equivalences.unifySubstitutions(substitutions);
+
+      statementUnified = substitutionsUnified;  ///
+    }
+
+    return statementUnified;
+  }
+
+  verifyAndUnify(substitutions, context) {
+    let verifiedAndUnified = false;
+
+    const assignments = [],
+          verified = this.verify(substitutions, assignments, context);
+
+    if (verified) {
+      const unified = this.unify(substitutions, context);
+
+      if (unified) {
+        const proofStep = this; ///
+
+        assignAssignments(assignments, context);
+
+        context.addProofStep(proofStep);
+      }
+
+      verifiedAndUnified = unified; ///
+    }
+
+    return verifiedAndUnified;
+  }
+
+  verify(substitutions, assignments, context) {
+    let verified = false;
+
+    if (false) {
+      ///
+    } else if (this.subproof !== null) {
+      const subproofVerified = this.subproof.verify(substitutions, context);
+
+      verified = subproofVerified;  ///
+    } else if (this.statement !== null) {
+      const qualified = this.isQualified(),
+            stated = qualified, ///
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        if (this.reference === null) {
+          verified = true;
+        } else {
+          const referenceVerified = this.reference.verify(context);
+
+          verified = referenceVerified; ///
+        }
+      }
+    } else {
+      const proofStepString = this.string;
+
+      context.debug(`Cannot verify the '${proofStepString}' proof step because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  static name = "ProofStep";
+
+  static fromStatement(statement, context) {
+    const statementString = statement.getString(),
+          string = statementString, ///
+          subproof = null,
+          reference = null,
+          proofStep = new ProofStep(string, subproof, statement, reference);
+
+    return proofStep;
+  }
+
+  static fromProofStepNode(proofStepNode, fileContext) {
+    const { Subproof, Statement, Reference } = dom,
+          node = proofStepNode, ///
+          string = fileContext.nodeAsString(node),
+          subproof = Subproof.fromProofStepNode(proofStepNode, fileContext),
+          statement = Statement.fromProofStepNode(proofStepNode, fileContext),
+          reference = Reference.fromProofStepNode(proofStepNode, fileContext),
+          proofStep = new ProofStep(string, subproof, statement, reference);
+
+    return proofStep;
+  }
+});

package/src/{reference.js → dom/reference.js}

@@ -1,16 +1,17 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import { nodeQuery } from "./utilities/query";
-import { referenceMetaType } from "./metaType";
-import { unifyLabelWithReference } from "./utilities/unification";
-import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { referenceMetaType } from "../dom/metaType";
+import { unifyLabelWithReference } from "../utilities/unification";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-const metavariableNodeQuery = nodeQuery("//reference/metavariable");
+const referenceNodeQuery = nodeQuery("/proofStep|lastProofStep/reference");
 
-export default class Reference {
+export default domAssigned(class Reference {
   constructor(metavariable) {
     this.metavariable = metavariable;
   }
@@ -40,7 +41,7 @@ export default class Reference {
   unifyLabel(label, substitutions, generalContext, specificContext) {
     let labelUnified;
 
-    const reference = this,
+    const reference = this, ///
           labelString = label.getString(),
           referenceString = reference.getString();
 
@@ -65,10 +66,18 @@ export default class Reference {
     context.trace(`Verifying the '${referenceString}' reference...`);
 
     if (!verified) {
-      const metaType = referenceMetaType, ///
-            metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
+      const metavariableVerified = this.verifyMetavariable(context);
 
-      verified = metavariableVerifiedGivenMetaType; ///
+      verified = metavariableVerified; ///
+    }
+
+    if (!verified) {
+      const reference = this, ///
+            rulePresent = context.isRulePresentByReference(reference),
+            metaLemmasMetaTheoremsPresent = context.areMetaLemmasMetaTheoremsPresentByReference(reference),
+            axiomLemmaTheoremConjecturePresent = context.isAxiomLemmaTheoremConjecturePresentByReference(reference);
+
+      verified = (rulePresent || metaLemmasMetaTheoremsPresent || axiomLemmaTheoremConjecturePresent);
     }
 
     if (verified) {
@@ -78,6 +87,17 @@ export default class Reference {
     return verified;
   }
 
+  verifyMetavariable(context) {
+    let metavariableVerified;
+
+    const metaType = referenceMetaType, ///
+          metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
+
+    metavariableVerified = metavariableVerifiedGivenMetaType; ///
+
+    return metavariableVerified;
+  }
+
   toJSON() {
     const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///
@@ -90,6 +110,8 @@ export default class Reference {
     return json;
   }
 
+  static name = "Reference";
+
   static fromJSON(json, fileContext) {
     const metavariable = metavariableFromJSON(json, fileContext),
           reference = new Reference(string, metavariable);
@@ -97,14 +119,20 @@ export default class Reference {
     return reference;
   }
 
-  static fromReferenceNode(referenceNode, fileContext) {
-    const { Metavariable } = shim,
-          metavariableNode = metavariableNodeQuery(referenceNode),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
-          reference = new Reference(metavariable);
+  static fromProofStepNode(proofStepNode, fileContext) {
+    let reference = null;
+
+    const referenceNode = referenceNodeQuery(proofStepNode);
+
+    if (referenceNode !== null) {
+      const { Metavariable } = dom,
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext, ///
+            metavariable = Metavariable.fromReferenceNode(referenceNode, context);
+
+      reference = new Reference(metavariable);
+    }
 
     return reference;
   }
-}
+});

package/src/{rule.js → dom/rule.js}

@@ -2,26 +2,28 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 
+import { domAssigned } from "../dom";
 import { stringFromLabels } from "./topLevelAssertion";
-import { nodeQuery, nodesQuery } from "./utilities/query";
+import { nodeQuery, nodesQuery } from "../utilities/query";
 import { labelsFromJSON,
          premisesFromJSON,
          conclusionFromJSON,
          labelsToLabelsJSON,
          premisesToPremisesJSON,
-         conclusionToConclusionJSON } from "./utilities/json";
+         conclusionToConclusionJSON } from "../utilities/json";
 
-const { extract, reverse, backwardsEvery } = arrayUtilities;
+const { reverse, extract, backwardsEvery } = arrayUtilities;
 
 const proofNodeQuery = nodeQuery("/rule/proof"),
       labelNodesQuery = nodesQuery("/rule/label"),
       premiseNodesQuery = nodesQuery("/rule/premise"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion");
 
-class Rule {
+export default domAssigned(class Rule {
   constructor(fileContext, string, labels, premises, conclusion, proof) {
     this.fileContext = fileContext;
     this.string = string;
@@ -76,8 +78,7 @@ class Rule {
           generalContext = localContext, ///
           specificContext = context; ///
 
-    const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           statementUnifiedWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithConclusion) {
@@ -167,8 +168,7 @@ class Rule {
           let proofVerified = true; ///
 
           if (this.proof !== null) {
-            const { Substitutions } = shim,
-                  substitutions = Substitutions.fromNothing();
+            const substitutions = Substitutions.fromNothing();
 
             proofVerified = this.proof.verify(substitutions, this.conclusion, context);
           }
@@ -220,6 +220,8 @@ class Rule {
     return json;
   }
 
+  static name = "Rule";
+
   static fromJSON(json, fileContext) {
     let rule;
 
@@ -235,7 +237,7 @@ class Rule {
   }
 
   static fromRuleNode(ruleNode, fileContext) {
-    const { Label, Proof, Premise, Conclusion } = shim,
+    const { Label, Proof, Premise, Conclusion } = dom,
           proofNode = proofNodeQuery(ruleNode),
           labelNodes = labelNodesQuery(ruleNode),
           premiseNodes = premiseNodesQuery(ruleNode),
@@ -257,10 +259,4 @@ class Rule {
 
     return rule;
   }
-}
-
-Object.assign(shim, {
-  Rule
 });
-
-export default Rule;