occam-verify-cli 0.0.922 → 0.0.924

package/src/verify/statement/unqualified.js

@@ -7,28 +7,70 @@ import { nodeQuery } from "../../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let unqualifiedStatementVerified = false;
+  let unqualifiedStatementVerified;
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode),
-        unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
+  const verifyUnqualifiedStatementFunctions = [
+    verifyDerivedUnqualifiedStatement,
+    verifyStatedUnqualifiedStatement
+  ];
+
+  unqualifiedStatementVerified = verifyUnqualifiedStatementFunctions.some((verifyUnqualifiedStatementFunction) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatementFunction(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  if (unqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+  }
+
+  return unqualifiedStatementVerified;
+}
+
+function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let derivedUnqualifiedStatementVerified = false;
+
   if (derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+
     const matchesStatementNode = localContext.matchStatementNode(statementNode);
 
-    unqualifiedStatementVerified = matchesStatementNode;  ///
+    derivedUnqualifiedStatementVerified = matchesStatementNode;  ///
+
+    if (derivedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  if (!unqualifiedStatementVerified) {
+  return derivedUnqualifiedStatementVerified;
+}
+
+function verifyStatedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let statedUnqualifiedStatementVerified = false;
+
+  if (!derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' stated unqualified statement...`, unqualifiedStatementNode);
+
     const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    unqualifiedStatementVerified = statementVerified;  ///
-  }
+    statedUnqualifiedStatementVerified = statementVerified; ///
 
-  if (unqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+    if (statedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' stated unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  return unqualifiedStatementVerified;
+  return statedUnqualifiedStatementVerified;
 }

package/src/verify/statement.js

@@ -1,18 +1,21 @@
 "use strict";
 
 import verifyEquality from "../verify/equality";
-import bracketedCombinator from "../ocmbinator/bracketed";
+import verifyJudgement from "../verify/judgement";
 import verifyTypeAssertion from "../verify/typeAssertion";
-import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAssertion";
-import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
+import verifyDefinedAssertion from "./definedAssertion";
+import verifyContainedAssertion from "./containedAssertion";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
 import { nodeQuery } from "../utilities/query";
-import { isStatementDefinedAssertion } from "../verify/statementAsDefinedAssertion";
-import { isStatementContainedAssertion } from "../verify/statementAsContainedAssertion";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -22,7 +25,9 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
+    verifyStatementAsMetavariable,
     verifyStatementAsEquality,
+    verifyStatementAsJudgement,
     verifyStatementAsTypeAssertion,
     verifyStatementAsDefinedAssertion,
     verifyStatementAsContainedAssertion,
@@ -77,15 +82,14 @@ export default verifyStatement;
 export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
-  const statementEquality = isStatementEquality(statementNode);
+  const equalityNode = equalityNodeQuery(statementNode);
 
-  if (statementEquality) {
+  if (equalityNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityNode = equalityNodeQuery(statementNode),
-          equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -104,15 +108,14 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
-  const statementTypeAssertion = isStatementTypeAssertion(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-  if (statementTypeAssertion) {
+  if (typeAssertionNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -128,21 +131,126 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
   return statementVerifiedAsTypeAssertion;
 }
 
+function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsJudgement = false;
+
+  const judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+
+    statementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (statementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsJudgement;
+}
+
+function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsMetavariable = false;
+
+  const metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
+
+    const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+
+    if (metavariable !== null) {
+      const metaTypeName  = metavariable.getMetaTypeName();
+
+      if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+        statementVerifiedAsMetavariable = true;
+      }
+    }
+
+    if (statementVerifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsMetavariable;
+}
+
+function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsDefinedAssertion = false;
+
+  const definedAssertionNode = definedAssertionNodeQuery(statementNode);
+
+  if (definedAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (statementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedAssertion;
+}
+
+function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion = false;
+
+  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (containedAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (statementVerifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
 function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
   let statementVerifiedAgainstCombinators = false;
 
-  const statementEquality = isStatementEquality(statementNode),
-        statementTypeAssertion = isStatementTypeAssertion(statementNode),
-        statementDefinedAssertion = isStatementDefinedAssertion(statementNode),
-        statementContainedAssertion = isStatementContainedAssertion(statementNode);
+  const equalityNode = equalityNodeQuery(statementNode),
+        judgementNode = judgementNodeQuery(statementNode),
+        metavariableNode = metavariableNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
 
-  if (!statementEquality && !statementTypeAssertion && !statementDefinedAssertion && !statementContainedAssertion) {
-    let combinators = localContext.getCombinators();
+  if (  (equalityNode === null) &&
+        (judgementNode === null) &&
+        (metavariableNode === null) &&
+        (typeAssertionNode === null) &&
+        (definedAssertionNode === null) &&
+        (containedAssertionNode === null) ) {
 
-    combinators = [ ///
-      bracketedCombinator,
-      ...combinators
-    ];
+    const combinators = localContext.getCombinators();
 
     statementVerifiedAgainstCombinators = combinators.some((combinator) => {
       const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext);
@@ -180,18 +288,4 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
   }
 
   return statementVerifiedAgainstCombinator;
-}
-
-function isStatementEquality(statementNode) {
-  const equalityNode = equalityNodeQuery(statementNode),
-        statementEquality = (equalityNode !== null);
-
-  return statementEquality;
-}
-
-function isStatementTypeAssertion(statementNode) {
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        statementTypeAssertion = (typeAssertionNode !== null);
-
-  return statementTypeAssertion;
-}
+}

package/src/verify/subDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default function verifySubDerivation(subDerivationNode, localContext) {
+export default function verifySubDerivation(subDerivationNode, substitutions, localContext) {
   let subDerivationVerified;
 
   const proofStepNodes = proofStepNodesQuery(subDerivationNode);
 
   subDerivationVerified = proofStepNodes.every((proofStepNode) => {
     const { verifyProofStep } = verifySubDerivation,
-          proofStepVerified = verifyProofStep(proofStepNode, localContext);
+          proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {
       return true;

package/src/verify/subproof.js

@@ -9,7 +9,7 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default function verifySubproof(subproofNode, localContext) {
+export default function verifySubproof(subproofNode, substitutions, localContext) {
   let subproofVerified = false;
 
   localContext = LocalContext.fromLocalContext(localContext);  ///
@@ -20,7 +20,7 @@ export default function verifySubproof(subproofNode, localContext) {
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
+          subDerivationVerified = verifySubDerivation(subDerivationNode, substitutions, localContext);
 
     if (subDerivationVerified) {
       subproofVerified = true;

package/src/verify/supposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import ProofStep from "../step/proof";
+import ProofStep from "../proofStep";
 import Supposition from "../supposition";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 

package/src/verify/termAsConstructor.js

@@ -11,9 +11,9 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
   fileContext.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
-  const nonTerminalNode = termNode, ///
+  const localContext = LocalContext.fromFileContext(fileContext),
+        nonTerminalNode = termNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        localContext = LocalContext.fromFileContext(fileContext),
         childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, localContext, () => {
           const verifiedAhead = true;
 

package/src/verify/theorem.js

@@ -27,9 +27,9 @@ export default function verifyTheorem(theoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositionNodes = suppositionsNodeQuery(theoremNode),
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
-          localContext = LocalContext.fromFileContext(fileContext),
+          suppositionNodes = suppositionsNodeQuery(theoremNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
@@ -41,10 +41,13 @@ export default function verifyTheorem(theoremNode, fileContext) {
         const proofNode = proofNodeQuery(theoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, localContext);
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+          const substitutions = [],
+                theorem = Theorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addTheorem(theorem);
 

package/lib/axiomLemmaTheoremConjecture.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return AxiomLemmaTheoremConjecture;
-    }
-});
-var _label = /*#__PURE__*/ _interop_require_default(require("./label"));
-var _consequent = /*#__PURE__*/ _interop_require_default(require("./consequent"));
-var _supposition = /*#__PURE__*/ _interop_require_default(require("./supposition"));
-var _local = /*#__PURE__*/ _interop_require_default(require("./context/local"));
-var _array = require("./utilities/array");
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var AxiomLemmaTheoremConjecture = /*#__PURE__*/ function() {
-    function AxiomLemmaTheoremConjecture(labels, suppositions, consequent, localContext) {
-        _class_call_check(this, AxiomLemmaTheoremConjecture);
-        this.labels = labels;
-        this.suppositions = suppositions;
-        this.consequent = consequent;
-        this.localContext = localContext;
-    }
-    _create_class(AxiomLemmaTheoremConjecture, [
-        {
-            key: "getLabels",
-            value: function getLabels() {
-                return this.labels;
-            }
-        },
-        {
-            key: "getSuppositions",
-            value: function getSuppositions() {
-                return this.suppositions;
-            }
-        },
-        {
-            key: "getConsequent",
-            value: function getConsequent() {
-                return this.consequent;
-            }
-        },
-        {
-            key: "getLocalContext",
-            value: function getLocalContext() {
-                return this.localContext;
-            }
-        },
-        {
-            key: "matchStatement",
-            value: function matchStatement(statementNode, localContext) {
-                var statementNatches = false;
-                var proofSteps = localContext.getProofSteps(), substitutions = [], suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, localContext);
-                if (suppositionsMatch) {
-                    var consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, localContext);
-                    statementNatches = consequentMatches; ///
-                }
-                return statementNatches;
-            }
-        },
-        {
-            key: "matchMetavariableNode",
-            value: function matchMetavariableNode(metavariableNode) {
-                var matchesMetavariableNode = this.labels.some(function(label) {
-                    var labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
-                    if (labelMatchesMetavariableNode) {
-                        return true;
-                    }
-                });
-                return matchesMetavariableNode;
-            }
-        },
-        {
-            key: "toJSON",
-            value: function toJSON(tokens) {
-                var labelsJSON = this.labels.map(function(label) {
-                    var labelJSON = label.toJSON(tokens);
-                    return labelJSON;
-                }), suppositionsJSON = this.suppositions.map(function(supposition) {
-                    var suppositionJSON = supposition.toJSON(tokens);
-                    return suppositionJSON;
-                }), consequentJSON = this.consequent.toJSON(tokens), localContextJSON = this.localContext.toJSON(tokens), labels = labelsJSON, suppositions = suppositionsJSON, consequent = consequentJSON, localContext = localContextJSON, json = {
-                    labels: labels,
-                    suppositions: suppositions,
-                    consequent: consequent,
-                    localContext: localContext
-                };
-                return json;
-            }
-        }
-    ], [
-        {
-            key: "fromJSONAndFileContext",
-            value: function fromJSONAndFileContext(Class, json, fileContext) {
-                var labels = json.labels;
-                var labelsJSON = labels; ///
-                labels = labelsJSON.map(function(labelJSON) {
-                    var _$json = labelJSON, label = _label.default.fromJSONAndFileContext(_$json, fileContext);
-                    return label;
-                });
-                var suppositions = json.suppositions, consequent = json.consequent, localContext = json.localContext;
-                var suppositionsJSON = suppositions; ///
-                suppositions = suppositionsJSON.map(function(suppositionJSON) {
-                    var _$json = suppositionJSON, supposition = _supposition.default.fromJSONAndFileContext(_$json, fileContext);
-                    return supposition;
-                });
-                var consequentJSON = consequent; ///
-                json = consequentJSON; ///
-                consequent = _consequent.default.fromJSONAndFileContext(json, fileContext);
-                var localContextJSON = localContext; ///
-                json = localContextJSON; ///
-                localContext = _local.default.fromJSONAndFileContext(json, fileContext);
-                return new Class(labels, suppositions, consequent, localContext); ///
-            }
-        },
-        {
-            key: "fromLabelsSuppositionsConsequentAndLocalContext",
-            value: function fromLabelsSuppositionsConsequentAndLocalContext(Class, labels, suppositions, consequent, localContext) {
-                return new Class(labels, suppositions, consequent, localContext);
-            }
-        }
-    ]);
-    return AxiomLemmaTheoremConjecture;
-}();
-function matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {
-    suppositions = (0, _array.reverse)(suppositions); ///
-    proofSteps = (0, _array.reverse)(proofSteps); ///
-    var suppositionsMatch = (0, _array.correlate)(suppositions, proofSteps, function(supposition, proofStep) {
-        var suppositionMatches = matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext);
-        if (suppositionMatches) {
-            return true;
-        }
-    });
-    return suppositionsMatch;
-}
-function matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext) {
-    var suppositionMatches = false;
-    var statementNode = proofStep.getStatementNode();
-    if (statementNode !== null) {
-        var suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
-        suppositionMatches = suppositionMatchesStatementNode; ///
-    }
-    return suppositionMatches;
-}
-function matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {
-    var consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext), consequentMatches = consequentMatchesStatementNode; ///
-    return consequentMatches;
-}
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/axiomLemmaTheoremConjecture.js"],"sourcesContent":["\"use strict\";\n\nimport Label from \"./label\";\nimport Consequent from \"./consequent\";\nimport Supposition from \"./supposition\";\nimport LocalContext from \"./context/local\";\n\nimport { reverse, correlate } from \"./utilities/array\";\n\nexport default class AxiomLemmaTheoremConjecture {\n  constructor(labels, suppositions, consequent, localContext) {\n    this.labels = labels;\n    this.suppositions = suppositions;\n    this.consequent = consequent;\n    this.localContext = localContext;\n  }\n\n  getLabels() {\n    return this.labels;\n  }\n\n  getSuppositions() {\n    return this.suppositions;\n  }\n\n  getConsequent() {\n    return this.consequent;\n  }\n\n  getLocalContext() {\n    return this.localContext;\n  }\n\n  matchStatement(statementNode, localContext) {\n    let statementNatches = false;\n\n    const proofSteps = localContext.getProofSteps(),\n          substitutions = [],\n          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, localContext);\n\n    if (suppositionsMatch) {\n      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, localContext);\n\n      statementNatches = consequentMatches;  ///\n    }\n\n    return statementNatches;\n  }\n\n  matchMetavariableNode(metavariableNode) {\n    const matchesMetavariableNode = this.labels.some((label) => {\n      const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);\n\n      if (labelMatchesMetavariableNode) {\n        return true;\n      }\n    });\n\n    return matchesMetavariableNode;\n  }\n\n  toJSON(tokens) {\n    const labelsJSON = this.labels.map((label) => {\n            const labelJSON = label.toJSON(tokens);\n\n            return labelJSON;\n          }),\n          suppositionsJSON = this.suppositions.map((supposition) => {\n            const suppositionJSON = supposition.toJSON(tokens);\n\n            return suppositionJSON;\n          }),\n          consequentJSON = this.consequent.toJSON(tokens),\n          localContextJSON = this.localContext.toJSON(tokens),\n          labels = labelsJSON,  ///\n          suppositions = suppositionsJSON,  ///\n          consequent = consequentJSON,  ///\n          localContext = localContextJSON,  ///\n          json = {\n            labels,\n            suppositions,\n            consequent,\n            localContext\n          };\n\n    return json;\n  }\n\n  static fromJSONAndFileContext(Class, json, fileContext) {\n    let { labels } = json;\n\n    const labelsJSON = labels;  ///\n\n    labels = labelsJSON.map((labelJSON) => {\n      const json = labelJSON, ///\n            label = Label.fromJSONAndFileContext(json, fileContext);\n\n      return label;\n    });\n\n    let { suppositions, consequent, localContext } = json;\n\n    const suppositionsJSON = suppositions;  ///\n\n    suppositions = suppositionsJSON.map((suppositionJSON) => {\n      const json = suppositionJSON, ///\n            supposition = Supposition.fromJSONAndFileContext(json, fileContext);\n\n      return supposition;\n    });\n\n    const consequentJSON = consequent;  ///\n\n    json = consequentJSON;  ///\n\n    consequent = Consequent.fromJSONAndFileContext(json, fileContext);\n\n    const localContextJSON = localContext;  ///\n\n    json = localContextJSON;  ///\n\n    localContext = LocalContext.fromJSONAndFileContext(json, fileContext);\n\n    return new Class(labels, suppositions, consequent, localContext);  ///\n  }\n\n  static fromLabelsSuppositionsConsequentAndLocalContext(Class, labels, suppositions, consequent, localContext) { return new Class(labels, suppositions, consequent, localContext); }\n}\n\nfunction matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {\n  suppositions = reverse(suppositions); ///\n\n  proofSteps = reverse(proofSteps); ///\n\n  const suppositionsMatch = correlate(suppositions, proofSteps, (supposition, proofStep) => {\n    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext);\n\n    if (suppositionMatches) {\n      return true;\n    }\n  });\n\n  return suppositionsMatch;\n}\n\nfunction matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext) {\n  let suppositionMatches = false;\n\n  const statementNode = proofStep.getStatementNode();\n\n  if (statementNode !== null) {\n    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);\n\n    suppositionMatches = suppositionMatchesStatementNode;  ///\n  }\n\n  return suppositionMatches;\n}\n\nfunction matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {\n  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),\n        consequentMatches = consequentMatchesStatementNode; ///\n\n  return consequentMatches;\n}\n"],"names":["AxiomLemmaTheoremConjecture","labels","suppositions","consequent","localContext","getLabels","getSuppositions","getConsequent","getLocalContext","matchStatement","statementNode","statementNatches","proofSteps","getProofSteps","substitutions","suppositionsMatch","matchSuppositions","consequentMatches","matchConsequent","matchMetavariableNode","metavariableNode","matchesMetavariableNode","some","label","labelMatchesMetavariableNode","toJSON","tokens","labelsJSON","map","labelJSON","suppositionsJSON","supposition","suppositionJSON","consequentJSON","localContextJSON","json","fromJSONAndFileContext","Class","fileContext","Label","Supposition","Consequent","LocalContext","fromLabelsSuppositionsConsequentAndLocalContext","statementLocalContext","reverse","correlate","proofStep","suppositionMatches","matchSupposition","getStatementNode","suppositionMatchesStatementNode","matchStatementNode","consequentMatchesStatementNode"],"mappings":"AAAA;;;;;;;eASqBA;;;4DAPH;iEACK;kEACC;4DACC;qBAEU;;;;;;;;;;;;;;;;;;;;;;;;;AAEpB,IAAA,AAAMA,4CAAD,AAAL;aAAMA,4BACPC,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,YAAY;gCADvCJ;QAEjB,IAAI,CAACC,MAAM,GAAGA;QACd,IAAI,CAACC,YAAY,GAAGA;QACpB,IAAI,CAACC,UAAU,GAAGA;QAClB,IAAI,CAACC,YAAY,GAAGA;;kBALHJ;;YAQnBK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,MAAM;YACpB;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,YAAY;YAC1B;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,UAAU;YACxB;;;YAEAK,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACJ,YAAY;YAC1B;;;YAEAK,KAAAA;mBAAAA,SAAAA,eAAeC,aAAa,EAAEN,YAAY;gBACxC,IAAIO,mBAAmB;gBAEvB,IAAMC,aAAaR,aAAaS,aAAa,IACvCC,gBAAgB,EAAE,EAClBC,oBAAoBC,kBAAkB,IAAI,CAACd,YAAY,EAAEU,YAAYE,eAAe,IAAI,CAACV,YAAY,EAAEA;gBAE7G,IAAIW,mBAAmB;oBACrB,IAAME,oBAAoBC,gBAAgB,IAAI,CAACf,UAAU,EAAEO,eAAeI,eAAe,IAAI,CAACV,YAAY,EAAEA;oBAE5GO,mBAAmBM,mBAAoB,GAAG;gBAC5C;gBAEA,OAAON;YACT;;;YAEAQ,KAAAA;mBAAAA,SAAAA,sBAAsBC,gBAAgB;gBACpC,IAAMC,0BAA0B,IAAI,CAACpB,MAAM,CAACqB,IAAI,CAAC,SAACC;oBAChD,IAAMC,+BAA+BD,MAAMJ,qBAAqB,CAACC;oBAEjE,IAAII,8BAA8B;wBAChC,OAAO;oBACT;gBACF;gBAEA,OAAOH;YACT;;;YAEAI,KAAAA;mBAAAA,SAAAA,OAAOC,MAAM;gBACX,IAAMC,aAAa,IAAI,CAAC1B,MAAM,CAAC2B,GAAG,CAAC,SAACL;oBAC5B,IAAMM,YAAYN,MAAME,MAAM,CAACC;oBAE/B,OAAOG;gBACT,IACAC,mBAAmB,IAAI,CAAC5B,YAAY,CAAC0B,GAAG,CAAC,SAACG;oBACxC,IAAMC,kBAAkBD,YAAYN,MAAM,CAACC;oBAE3C,OAAOM;gBACT,IACAC,iBAAiB,IAAI,CAAC9B,UAAU,CAACsB,MAAM,CAACC,SACxCQ,mBAAmB,IAAI,CAAC9B,YAAY,CAACqB,MAAM,CAACC,SAC5CzB,SAAS0B,YACTzB,eAAe4B,kBACf3B,aAAa8B,gBACb7B,eAAe8B,kBACfC,OAAO;oBACLlC,QAAAA;oBACAC,cAAAA;oBACAC,YAAAA;oBACAC,cAAAA;gBACF;gBAEN,OAAO+B;YACT;;;;YAEOC,KAAAA;mBAAP,SAAOA,uBAAuBC,KAAK,EAAEF,IAAI,EAAEG,WAAW;gBACpD,IAAI,AAAErC,SAAWkC,KAAXlC;gBAEN,IAAM0B,aAAa1B,QAAS,GAAG;gBAE/BA,SAAS0B,WAAWC,GAAG,CAAC,SAACC;oBACvB,IAAMM,SAAON,WACPN,QAAQgB,cAAK,CAACH,sBAAsB,CAACD,QAAMG;oBAEjD,OAAOf;gBACT;gBAEA,IAAMrB,eAA2CiC,KAA3CjC,cAAcC,aAA6BgC,KAA7BhC,YAAYC,eAAiB+B,KAAjB/B;gBAEhC,IAAM0B,mBAAmB5B,cAAe,GAAG;gBAE3CA,eAAe4B,iBAAiBF,GAAG,CAAC,SAACI;oBACnC,IAAMG,SAAOH,iBACPD,cAAcS,oBAAW,CAACJ,sBAAsB,CAACD,QAAMG;oBAE7D,OAAOP;gBACT;gBAEA,IAAME,iBAAiB9B,YAAa,GAAG;gBAEvCgC,OAAOF,gBAAiB,GAAG;gBAE3B9B,aAAasC,mBAAU,CAACL,sBAAsB,CAACD,MAAMG;gBAErD,IAAMJ,mBAAmB9B,cAAe,GAAG;gBAE3C+B,OAAOD,kBAAmB,GAAG;gBAE7B9B,eAAesC,cAAY,CAACN,sBAAsB,CAACD,MAAMG;gBAEzD,OAAO,IAAID,MAAMpC,QAAQC,cAAcC,YAAYC,eAAgB,GAAG;YACxE;;;YAEOuC,KAAAA;mBAAP,SAAOA,gDAAgDN,KAAK,EAAEpC,MAAM,EAAEC,YAAY,EAAEC,UAAU,EAAEC,YAAY;gBAAI,OAAO,IAAIiC,MAAMpC,QAAQC,cAAcC,YAAYC;YAAe;;;WArH/JJ;;AAwHrB,SAASgB,kBAAkBd,YAAY,EAAEU,UAAU,EAAEE,aAAa,EAAEV,YAAY,EAAEwC,qBAAqB;IACrG1C,eAAe2C,IAAAA,cAAO,EAAC3C,eAAe,GAAG;IAEzCU,aAAaiC,IAAAA,cAAO,EAACjC,aAAa,GAAG;IAErC,IAAMG,oBAAoB+B,IAAAA,gBAAS,EAAC5C,cAAcU,YAAY,SAACmB,aAAagB;QAC1E,IAAMC,qBAAqBC,iBAAiBlB,aAAagB,WAAWjC,eAAeV,cAAcwC;QAEjG,IAAII,oBAAoB;YACtB,OAAO;QACT;IACF;IAEA,OAAOjC;AACT;AAEA,SAASkC,iBAAiBlB,WAAW,EAAEgB,SAAS,EAAEjC,aAAa,EAAEV,YAAY,EAAEwC,qBAAqB;IAClG,IAAII,qBAAqB;IAEzB,IAAMtC,gBAAgBqC,UAAUG,gBAAgB;IAEhD,IAAIxC,kBAAkB,MAAM;QAC1B,IAAMyC,kCAAkCpB,YAAYqB,kBAAkB,CAAC1C,eAAeI,eAAeV,cAAcwC;QAEnHI,qBAAqBG,iCAAkC,GAAG;IAC5D;IAEA,OAAOH;AACT;AAEA,SAAS9B,gBAAgBf,UAAU,EAAEO,aAAa,EAAEI,aAAa,EAAEV,YAAY,EAAEwC,qBAAqB;IACpG,IAAMS,iCAAiClD,WAAWiD,kBAAkB,CAAC1C,eAAeI,eAAeV,cAAcwC,wBAC3G3B,oBAAoBoC,gCAAgC,GAAG;IAE7D,OAAOpC;AACT"}