fitch-js 0.1.0

package/dist/esm/ruleValidators.js

@@ -0,0 +1,799 @@
+var _RULE_VALIDATORS;
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { RULES, getAllTerms } from './types.js';
+import { OPERATORS } from './parser.js';
+
+// Standard variable names used in first-order logic quantifiers
+var STANDARD_VARIABLES = new Set(['x', 'y', 'z', 'w', 'v', 'u']);
+
+/**
+ * Determines if a term is a variable (as opposed to a constant)
+ * @param {string} term
+ * @returns {boolean}
+ */
+export function isVariable(term) {
+  if (term.length === 1) {
+    return STANDARD_VARIABLES.has(term);
+  }
+  if (term.length >= 2 && STANDARD_VARIABLES.has(term[0]) && /^\d+$/.test(term.slice(1))) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Checks if two formulas are structurally identical
+ * @param {import('./types').Formula} f1
+ * @param {import('./types').Formula} f2
+ * @returns {boolean}
+ */
+export function formulasEqual(f1, f2) {
+  if (!f1 || !f2) return f1 === f2;
+  if (f1.type !== f2.type) return false;
+  switch (f1.type) {
+    case 'atomic':
+      if (f1.predicate !== f2.predicate) return false;
+      if (!f1.terms || !f2.terms) return !f1.terms && !f2.terms;
+      if (f1.terms.length !== f2.terms.length) return false;
+      return f1.terms.every(function (term, i) {
+        return term === f2.terms[i];
+      });
+    case 'compound':
+      if (f1.operator !== f2.operator) return false;
+      if (f1.operator === OPERATORS.NOT) {
+        return formulasEqual(f1.right, f2.right);
+      }
+      return formulasEqual(f1.left, f2.left) && formulasEqual(f1.right, f2.right);
+    case 'quantified':
+      return f1.operator === f2.operator && f1.variable === f2.variable && formulasEqual(f1.scope, f2.scope);
+    case 'identity':
+      return f1.terms[0] === f2.terms[0] && f1.terms[1] === f2.terms[1];
+    case 'splat':
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Checks if a variable occurs free in a formula
+ * @param {string} variable
+ * @param {import('./types').Formula} formula
+ * @returns {boolean}
+ */
+export function occursFree(variable, formula) {
+  var _formula$terms$includ, _formula$terms;
+  if (!variable || !formula) return false;
+  switch (formula.type) {
+    case 'atomic':
+      return (_formula$terms$includ = (_formula$terms = formula.terms) === null || _formula$terms === void 0 ? void 0 : _formula$terms.includes(variable)) !== null && _formula$terms$includ !== void 0 ? _formula$terms$includ : false;
+    case 'compound':
+      if (formula.operator === OPERATORS.NOT) {
+        return occursFree(variable, formula.right);
+      }
+      return occursFree(variable, formula.left) || occursFree(variable, formula.right);
+    case 'quantified':
+      if (formula.variable === variable) return false;
+      return occursFree(variable, formula.scope);
+    case 'identity':
+      return formula.terms.includes(variable);
+    default:
+      return false;
+  }
+}
+
+/**
+ * Substitutes a term for a variable in a formula
+ * @param {import('./types').Formula} formula
+ * @param {string} term
+ * @param {string} variable
+ * @returns {import('./types').Formula}
+ */
+export function substitute(formula, term, variable) {
+  var _formula$terms$map, _formula$terms2;
+  if (!formula) return formula;
+  switch (formula.type) {
+    case 'atomic':
+      return _objectSpread(_objectSpread({}, formula), {}, {
+        terms: (_formula$terms$map = (_formula$terms2 = formula.terms) === null || _formula$terms2 === void 0 ? void 0 : _formula$terms2.map(function (t) {
+          return t === variable ? term : t;
+        })) !== null && _formula$terms$map !== void 0 ? _formula$terms$map : []
+      });
+    case 'compound':
+      if (formula.operator === OPERATORS.NOT) {
+        return _objectSpread(_objectSpread({}, formula), {}, {
+          right: substitute(formula.right, term, variable)
+        });
+      }
+      return _objectSpread(_objectSpread({}, formula), {}, {
+        left: substitute(formula.left, term, variable),
+        right: substitute(formula.right, term, variable)
+      });
+    case 'quantified':
+      if (formula.variable === variable) return formula;
+      return _objectSpread(_objectSpread({}, formula), {}, {
+        scope: substitute(formula.scope, term, variable)
+      });
+    case 'identity':
+      return _objectSpread(_objectSpread({}, formula), {}, {
+        terms: formula.terms.map(function (t) {
+          return t === variable ? term : t;
+        })
+      });
+    default:
+      return formula;
+  }
+}
+
+/**
+ * Checks if a line is available at the current scope
+ * @param {number[]} currentLocation
+ * @param {number[]} targetLocation
+ * @returns {boolean}
+ */
+export function isLineAvailable(currentLocation, targetLocation) {
+  if (!currentLocation || !targetLocation) return true;
+  if (targetLocation.length > currentLocation.length) return false;
+  for (var i = 0; i < targetLocation.length - 1; i++) {
+    if (targetLocation[i] !== currentLocation[i]) return false;
+  }
+  return true;
+}
+
+/**
+ * Checks if a citation is valid within current scope
+ * @param {import('./types').ProofLine} citedLine
+ * @param {import('./types').ProofLine} currentLine
+ * @returns {boolean}
+ */
+export function isValidCitation(citedLine, currentLine) {
+  return isLineAvailable(currentLine.location, citedLine.location);
+}
+
+/**
+ * Validates a subproof range
+ * @param {{start: number, end: number}} subproof
+ * @param {number} lineIndex
+ * @param {number} totalLines
+ * @returns {{valid: boolean, startIdx: number, endIdx: number}}
+ */
+export function validateSubproofRange(subproof, lineIndex, totalLines) {
+  var startIdx = subproof.start - 1;
+  var endIdx = subproof.end - 1;
+  var valid = startIdx <= endIdx && startIdx >= 0 && endIdx < totalLines && endIdx < lineIndex;
+  return {
+    valid: valid,
+    startIdx: startIdx,
+    endIdx: endIdx
+  };
+}
+
+// ============================================================================
+// PROPOSITIONAL LOGIC RULE VALIDATORS
+// ============================================================================
+
+function validateConjIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2) return;
+  var _line$citations = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations[0],
+    cite2 = _line$citations[1];
+  var idx1 = cite1 - 1;
+  var idx2 = cite2 - 1;
+  if (idx1 < 0 || idx1 >= previousLines.length || idx2 < 0 || idx2 >= previousLines.length) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var formula1 = previousLines[idx1].formula;
+  var formula2 = previousLines[idx2].formula;
+  if (line.formula.type !== 'compound' || line.formula.operator !== OPERATORS.AND) {
+    issues.push('Conclusion must be a conjunction');
+    return;
+  }
+  var matchesOrder1 = formulasEqual(line.formula.left, formula1) && formulasEqual(line.formula.right, formula2);
+  var matchesOrder2 = formulasEqual(line.formula.left, formula2) && formulasEqual(line.formula.right, formula1);
+  if (!matchesOrder1 && !matchesOrder2) {
+    issues.push('Cited formulas must match the left and right sides of the conjunction');
+  }
+}
+function validateConjElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) return;
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var formula = previousLines[citeIdx].formula;
+  if (formula.type !== 'compound' || formula.operator !== OPERATORS.AND) {
+    issues.push('Cited formula must be a conjunction');
+    return;
+  }
+  if (!formulasEqual(line.formula, formula.left) && !formulasEqual(line.formula, formula.right)) {
+    issues.push('Conclusion must match either the left or right side of the conjunction');
+  }
+}
+function validateDisjIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) return;
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var formula = previousLines[citeIdx].formula;
+  if (line.formula.type !== 'compound' || line.formula.operator !== OPERATORS.OR) {
+    issues.push('Conclusion must be a disjunction');
+    return;
+  }
+  if (!formulasEqual(formula, line.formula.left) && !formulasEqual(formula, line.formula.right)) {
+    issues.push('Cited formula must match either the left or right side of the disjunction');
+  }
+}
+function validateDisjElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) {
+    issues.push('Disjunction elimination requires exactly one citation');
+    return;
+  }
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var disjFormula = previousLines[citeIdx].formula;
+  if (disjFormula.type !== 'compound' || disjFormula.operator !== OPERATORS.OR) {
+    issues.push('First cited formula must be a disjunction');
+    return;
+  }
+  if (line.subproofs.length !== 2) {
+    issues.push('Disjunction elimination requires exactly two subproofs');
+    return;
+  }
+  var _line$subproofs = _slicedToArray(line.subproofs, 2),
+    sp1 = _line$subproofs[0],
+    sp2 = _line$subproofs[1];
+  var sp1Range = validateSubproofRange(sp1, lineIndex, previousLines.length);
+  var sp2Range = validateSubproofRange(sp2, lineIndex, previousLines.length);
+  if (!sp1Range.valid || !sp2Range.valid) {
+    issues.push('Invalid subproof ranges');
+    return;
+  }
+  var sp1Assumption = previousLines[sp1Range.startIdx].formula;
+  var sp2Assumption = previousLines[sp2Range.startIdx].formula;
+  var sp1Conclusion = previousLines[sp1Range.endIdx].formula;
+  var sp2Conclusion = previousLines[sp2Range.endIdx].formula;
+  if (!formulasEqual(sp1Assumption, disjFormula.left)) {
+    issues.push('First subproof must start with the left disjunct');
+    return;
+  }
+  if (!formulasEqual(sp2Assumption, disjFormula.right)) {
+    issues.push('Second subproof must start with the right disjunct');
+    return;
+  }
+  if (!formulasEqual(sp1Conclusion, sp2Conclusion)) {
+    issues.push('Both subproofs must reach the same conclusion');
+    return;
+  }
+  if (!formulasEqual(sp1Conclusion, line.formula)) {
+    issues.push('Subproof conclusions must match the final conclusion');
+  }
+}
+function validateCondIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 0 || line.subproofs.length !== 1) {
+    issues.push('Conditional introduction requires exactly one subproof and no citations');
+    return;
+  }
+  var spRange = validateSubproofRange(line.subproofs[0], lineIndex, previousLines.length);
+  if (!spRange.valid) {
+    issues.push('Invalid subproof range');
+    return;
+  }
+  if (line.formula.type !== 'compound' || line.formula.operator !== OPERATORS.IMPLIES) {
+    issues.push('Conclusion must be a conditional');
+    return;
+  }
+  var assumption = previousLines[spRange.startIdx].formula;
+  var conclusion = previousLines[spRange.endIdx].formula;
+  if (!formulasEqual(assumption, line.formula.left)) {
+    issues.push('Subproof assumption must match antecedent of conditional');
+    return;
+  }
+  if (!formulasEqual(conclusion, line.formula.right)) {
+    issues.push('Subproof conclusion must match consequent of conditional');
+  }
+}
+function validateCondElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2) {
+    issues.push('Conditional elimination requires exactly two citations');
+    return;
+  }
+  var _line$citations2 = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations2[0],
+    cite2 = _line$citations2[1];
+  var idx1 = cite1 - 1;
+  var idx2 = cite2 - 1;
+  if (idx1 < 0 || idx1 >= previousLines.length || idx2 < 0 || idx2 >= previousLines.length) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var formula1 = previousLines[idx1].formula;
+  var formula2 = previousLines[idx2].formula;
+  var valid1 = formula1.type === 'compound' && formula1.operator === OPERATORS.IMPLIES && formulasEqual(formula1.left, formula2) && formulasEqual(formula1.right, line.formula);
+  var valid2 = formula2.type === 'compound' && formula2.operator === OPERATORS.IMPLIES && formulasEqual(formula2.left, formula1) && formulasEqual(formula2.right, line.formula);
+  if (!valid1 && !valid2) {
+    issues.push('One citation must be a conditional and the other must match its antecedent');
+  }
+}
+function validateBicondIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 0 || line.subproofs.length !== 2) {
+    issues.push('Biconditional introduction requires exactly two subproofs and no citations');
+    return;
+  }
+  if (line.formula.type !== 'compound' || line.formula.operator !== OPERATORS.IFF) {
+    issues.push('Conclusion must be a biconditional');
+    return;
+  }
+  var _line$subproofs2 = _slicedToArray(line.subproofs, 2),
+    sp1 = _line$subproofs2[0],
+    sp2 = _line$subproofs2[1];
+  var sp1Range = validateSubproofRange(sp1, lineIndex, previousLines.length);
+  var sp2Range = validateSubproofRange(sp2, lineIndex, previousLines.length);
+  if (!sp1Range.valid || !sp2Range.valid) {
+    issues.push('Invalid subproof ranges');
+    return;
+  }
+  var sp1Assumption = previousLines[sp1Range.startIdx];
+  var sp1Conclusion = previousLines[sp1Range.endIdx];
+  var sp2Assumption = previousLines[sp2Range.startIdx];
+  var sp2Conclusion = previousLines[sp2Range.endIdx];
+  if (sp1Assumption.rule !== RULES.HYPOTHESIS || sp2Assumption.rule !== RULES.HYPOTHESIS) {
+    issues.push('Subproofs must begin with hypotheses');
+    return;
+  }
+  var validOrder1 = formulasEqual(sp1Assumption.formula, line.formula.left) && formulasEqual(sp1Conclusion.formula, line.formula.right) && formulasEqual(sp2Assumption.formula, line.formula.right) && formulasEqual(sp2Conclusion.formula, line.formula.left);
+  var validOrder2 = formulasEqual(sp1Assumption.formula, line.formula.right) && formulasEqual(sp1Conclusion.formula, line.formula.left) && formulasEqual(sp2Assumption.formula, line.formula.left) && formulasEqual(sp2Conclusion.formula, line.formula.right);
+  if (!validOrder1 && !validOrder2) {
+    issues.push('Invalid biconditional introduction - subproofs must prove P→Q and Q→P');
+  }
+}
+function validateBicondElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2) {
+    issues.push('Biconditional elimination requires exactly two citations');
+    return;
+  }
+  var _line$citations3 = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations3[0],
+    cite2 = _line$citations3[1];
+  if (cite1 < 1 || cite1 > lineIndex || cite2 < 1 || cite2 > lineIndex) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var citedLine1 = previousLines[cite1 - 1];
+  var citedLine2 = previousLines[cite2 - 1];
+  if (!isValidCitation(citedLine1, line) || !isValidCitation(citedLine2, line)) {
+    issues.push('Cited lines must be available in the current scope');
+    return;
+  }
+  var valid = false;
+  if (citedLine1.formula.type === 'compound' && citedLine1.formula.operator === OPERATORS.IFF) {
+    valid = formulasEqual(citedLine1.formula.left, citedLine2.formula) && formulasEqual(citedLine1.formula.right, line.formula) || formulasEqual(citedLine1.formula.right, citedLine2.formula) && formulasEqual(citedLine1.formula.left, line.formula);
+  }
+  if (!valid && citedLine2.formula.type === 'compound' && citedLine2.formula.operator === OPERATORS.IFF) {
+    valid = formulasEqual(citedLine2.formula.left, citedLine1.formula) && formulasEqual(citedLine2.formula.right, line.formula) || formulasEqual(citedLine2.formula.right, citedLine1.formula) && formulasEqual(citedLine2.formula.left, line.formula);
+  }
+  if (!valid) {
+    issues.push('Invalid biconditional elimination - one citation must be a biconditional and the other must match one of its sides');
+  }
+}
+function validateNegIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 0 || line.subproofs.length !== 1) {
+    issues.push('Negation introduction requires exactly one subproof and no citations');
+    return;
+  }
+  if (line.formula.type !== 'compound' || line.formula.operator !== OPERATORS.NOT) {
+    issues.push('Conclusion must be a negation');
+    return;
+  }
+  var spRange = validateSubproofRange(line.subproofs[0], lineIndex, previousLines.length);
+  if (!spRange.valid) {
+    issues.push('Invalid subproof range');
+    return;
+  }
+  var assumption = previousLines[spRange.startIdx];
+  var conclusion = previousLines[spRange.endIdx];
+  if (!formulasEqual(assumption.formula, line.formula.right)) {
+    issues.push('Subproof assumption must match what is being negated');
+    return;
+  }
+  if (conclusion.formula.type !== 'splat') {
+    issues.push('Subproof must end in a contradiction');
+  }
+}
+function validateNegElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2 || line.subproofs.length !== 0) {
+    issues.push('Negation elimination requires exactly two citations and no subproofs');
+    return;
+  }
+  if (line.formula.type !== 'splat') {
+    issues.push('Conclusion must be a contradiction');
+    return;
+  }
+  var _line$citations4 = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations4[0],
+    cite2 = _line$citations4[1];
+  if (cite1 < 1 || cite1 > lineIndex || cite2 < 1 || cite2 > lineIndex) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var citedLine1 = previousLines[cite1 - 1];
+  var citedLine2 = previousLines[cite2 - 1];
+  if (!isValidCitation(citedLine1, line) || !isValidCitation(citedLine2, line)) {
+    issues.push('Cited lines must be available in the current scope');
+    return;
+  }
+  var valid = citedLine1.formula.type === 'compound' && citedLine1.formula.operator === OPERATORS.NOT && formulasEqual(citedLine1.formula.right, citedLine2.formula) || citedLine2.formula.type === 'compound' && citedLine2.formula.operator === OPERATORS.NOT && formulasEqual(citedLine2.formula.right, citedLine1.formula);
+  if (!valid) {
+    issues.push('Invalid negation elimination - one line must be the negation of the other');
+  }
+}
+function validateContraIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2 || line.subproofs.length !== 0) {
+    issues.push('Contradiction introduction requires exactly two citations and no subproofs');
+    return;
+  }
+  if (line.formula.type !== 'splat') {
+    issues.push('Conclusion must be a contradiction');
+    return;
+  }
+  var _line$citations5 = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations5[0],
+    cite2 = _line$citations5[1];
+  if (cite1 < 1 || cite1 > lineIndex || cite2 < 1 || cite2 > lineIndex) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var citedLine1 = previousLines[cite1 - 1];
+  var citedLine2 = previousLines[cite2 - 1];
+  if (!isValidCitation(citedLine1, line) || !isValidCitation(citedLine2, line)) {
+    issues.push('Cited lines must be available in the current scope');
+    return;
+  }
+  var valid = citedLine1.formula.type === 'compound' && citedLine1.formula.operator === OPERATORS.NOT && formulasEqual(citedLine1.formula.right, citedLine2.formula) || citedLine2.formula.type === 'compound' && citedLine2.formula.operator === OPERATORS.NOT && formulasEqual(citedLine2.formula.right, citedLine1.formula);
+  if (!valid) {
+    issues.push('Invalid contradiction introduction - one line must be the negation of the other');
+  }
+}
+function validateContraElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1 || line.subproofs.length !== 0) {
+    issues.push('Contradiction elimination requires exactly one citation and no subproofs');
+    return;
+  }
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var citedLine = previousLines[citeIdx];
+  if (!isValidCitation(citedLine, line)) {
+    issues.push('Cited line must be available in the current scope');
+    return;
+  }
+  if (citedLine.formula.type !== 'splat') {
+    issues.push('Contradiction elimination requires a contradiction');
+  }
+}
+function validateLEM(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 0 || line.subproofs.length !== 2) {
+    issues.push('Law of excluded middle requires exactly two subproofs and no citations');
+    return;
+  }
+  var _line$subproofs3 = _slicedToArray(line.subproofs, 2),
+    sp1 = _line$subproofs3[0],
+    sp2 = _line$subproofs3[1];
+  var sp1Range = validateSubproofRange(sp1, lineIndex, previousLines.length);
+  var sp2Range = validateSubproofRange(sp2, lineIndex, previousLines.length);
+  if (!sp1Range.valid || !sp2Range.valid) {
+    issues.push('Invalid subproof ranges');
+    return;
+  }
+  var sp1Assumption = previousLines[sp1Range.startIdx];
+  var sp1Conclusion = previousLines[sp1Range.endIdx];
+  var sp2Assumption = previousLines[sp2Range.startIdx];
+  var sp2Conclusion = previousLines[sp2Range.endIdx];
+  if (sp1Assumption.rule !== RULES.HYPOTHESIS || sp2Assumption.rule !== RULES.HYPOTHESIS) {
+    issues.push('Subproofs must begin with hypotheses');
+    return;
+  }
+  var valid = sp2Assumption.formula.type === 'compound' && sp2Assumption.formula.operator === OPERATORS.NOT && formulasEqual(sp2Assumption.formula.right, sp1Assumption.formula) || sp1Assumption.formula.type === 'compound' && sp1Assumption.formula.operator === OPERATORS.NOT && formulasEqual(sp1Assumption.formula.right, sp2Assumption.formula);
+  if (!valid) {
+    issues.push('Invalid law of excluded middle - subproofs must assume P and ¬P');
+    return;
+  }
+  if (!formulasEqual(sp1Conclusion.formula, sp2Conclusion.formula) || !formulasEqual(line.formula, sp1Conclusion.formula)) {
+    issues.push('Invalid law of excluded middle - both subproofs must reach the same conclusion');
+  }
+}
+
+// ============================================================================
+// FIRST-ORDER LOGIC RULE VALIDATORS
+// ============================================================================
+
+function validateUnivElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) return;
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var cited = previousLines[citeIdx];
+  if (cited.formula.type !== 'quantified' || cited.formula.operator !== OPERATORS.FORALL) {
+    issues.push('Universal elimination requires a universal formula');
+    return;
+  }
+  var conclusionTerms = getAllTerms(line.formula);
+  var foundValidSubstitution = false;
+  var _iterator = _createForOfIteratorHelper(conclusionTerms),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var term = _step.value;
+      var substituted = substitute(cited.formula.scope, term, cited.formula.variable);
+      if (formulasEqual(substituted, line.formula)) {
+        foundValidSubstitution = true;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (!foundValidSubstitution) {
+    var withOriginal = substitute(cited.formula.scope, cited.formula.variable, cited.formula.variable);
+    foundValidSubstitution = formulasEqual(withOriginal, line.formula);
+  }
+  if (!foundValidSubstitution) {
+    issues.push('Formula does not follow by universal elimination');
+  }
+}
+function validateUnivIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) {
+    issues.push('Universal introduction requires exactly one citation');
+    return;
+  }
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  if (line.formula.type !== 'quantified' || line.formula.operator !== OPERATORS.FORALL) {
+    issues.push('Universal introduction must conclude with a universal formula');
+    return;
+  }
+  var cited = previousLines[citeIdx];
+  var variable = line.formula.variable;
+  var citedTerms = getAllTerms(cited.formula);
+  var foundValidSubstitution = false;
+  var _iterator2 = _createForOfIteratorHelper(citedTerms),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var term = _step2.value;
+      var substituted = substitute(line.formula.scope, term, variable);
+      if (formulasEqual(substituted, cited.formula)) {
+        foundValidSubstitution = true;
+        if (line.location && !isVariable(term)) {
+          for (var j = 0; j < lineIndex; j++) {
+            var prevLine = previousLines[j];
+            if (prevLine.rule === RULES.PREMISE && getAllTerms(prevLine.formula).includes(term)) {
+              issues.push("Eigenvariable condition violated: '".concat(term, "' appears in premise"));
+              return;
+            }
+          }
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (!foundValidSubstitution) {
+    var withVariable = substitute(line.formula.scope, variable, variable);
+    foundValidSubstitution = formulasEqual(withVariable, cited.formula);
+  }
+  if (!foundValidSubstitution) {
+    issues.push('Formula does not follow by universal introduction');
+  }
+}
+function validateExistIntro(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) return;
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var cited = previousLines[citeIdx];
+  if (line.formula.type !== 'quantified' || line.formula.operator !== OPERATORS.EXISTS) {
+    issues.push('Existential introduction must introduce an existential formula');
+    return;
+  }
+  var citedTerms = getAllTerms(cited.formula);
+  var foundValidSubstitution = false;
+  var _iterator3 = _createForOfIteratorHelper(citedTerms),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var term = _step3.value;
+      var substituted = substitute(line.formula.scope, term, line.formula.variable);
+      if (formulasEqual(substituted, cited.formula)) {
+        foundValidSubstitution = true;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (!foundValidSubstitution) {
+    issues.push('Formula does not follow by existential introduction');
+  }
+}
+function validateExistElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1 || line.subproofs.length !== 1) {
+    issues.push('Existential elimination requires exactly one citation and one subproof');
+    return;
+  }
+  var citeIdx = line.citations[0] - 1;
+  if (citeIdx < 0 || citeIdx >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var cited = previousLines[citeIdx];
+  var subproof = line.subproofs[0];
+  if (cited.formula.type !== 'quantified' || cited.formula.operator !== OPERATORS.EXISTS) {
+    issues.push('Existential elimination requires an existential formula');
+    return;
+  }
+  var spRange = validateSubproofRange(subproof, lineIndex, previousLines.length);
+  if (!spRange.valid) {
+    issues.push('Invalid subproof range');
+    return;
+  }
+  var subproofLines = previousLines.slice(spRange.startIdx, spRange.endIdx + 1);
+  if (subproofLines.length < 2) {
+    issues.push('Subproof must contain at least an assumption and a conclusion');
+    return;
+  }
+  var assumption = subproofLines[0];
+  if (assumption.rule !== RULES.HYPOTHESIS) {
+    issues.push('First line of existential elimination subproof must be a hypothesis');
+    return;
+  }
+  var witnessTerms = getAllTerms(assumption.formula);
+  var validWitness = false;
+  var _iterator4 = _createForOfIteratorHelper(witnessTerms),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var witness = _step4.value;
+      if (isVariable(witness)) continue;
+      var substituted = substitute(cited.formula.scope, witness, cited.formula.variable);
+      if (!formulasEqual(assumption.formula, substituted)) continue;
+      if (getAllTerms(line.formula).includes(witness)) continue;
+      if (getAllTerms(cited.formula).includes(witness)) continue;
+      var foundInPremises = false;
+      for (var j = 0; j < spRange.startIdx; j++) {
+        var prevLine = previousLines[j];
+        if ((prevLine.rule === RULES.PREMISE || prevLine.rule === RULES.HYPOTHESIS) && prevLine.location && line.location && prevLine.location.length <= line.location.length && prevLine.location.every(function (loc, i) {
+          return line.location[i] === loc;
+        })) {
+          if (getAllTerms(prevLine.formula).includes(witness)) {
+            foundInPremises = true;
+            break;
+          }
+        }
+      }
+      if (!foundInPremises) {
+        validWitness = true;
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  if (!validWitness) {
+    issues.push('Witness term must not appear in any available premises or hypotheses');
+  }
+}
+function validateIdIntro(line, previousLines, lineIndex, issues) {
+  if (line.formula.type !== 'identity') {
+    issues.push('Identity introduction must conclude with an identity formula');
+    return;
+  }
+  if (line.formula.terms[0] !== line.formula.terms[1]) {
+    issues.push('Identity introduction requires t = t (reflexivity)');
+  }
+}
+function validateIdElim(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 2) {
+    issues.push('Identity elimination requires exactly two citations');
+    return;
+  }
+  var _line$citations6 = _slicedToArray(line.citations, 2),
+    cite1 = _line$citations6[0],
+    cite2 = _line$citations6[1];
+  if (cite1 < 1 || cite1 > lineIndex || cite2 < 1 || cite2 > lineIndex) {
+    issues.push('Invalid line citations');
+    return;
+  }
+  var citedLine1 = previousLines[cite1 - 1];
+  var citedLine2 = previousLines[cite2 - 1];
+  if (!isValidCitation(citedLine1, line) || !isValidCitation(citedLine2, line)) {
+    issues.push('Cited lines must be available in the current scope');
+    return;
+  }
+  var valid = false;
+  if (citedLine1.formula.type === 'identity') {
+    var _citedLine1$formula$t = _slicedToArray(citedLine1.formula.terms, 2),
+      a = _citedLine1$formula$t[0],
+      b = _citedLine1$formula$t[1];
+    var subAtoB = substitute(citedLine2.formula, b, a);
+    var subBtoA = substitute(citedLine2.formula, a, b);
+    valid = formulasEqual(subAtoB, line.formula) || formulasEqual(subBtoA, line.formula);
+  }
+  if (!valid && citedLine2.formula.type === 'identity') {
+    var _citedLine2$formula$t = _slicedToArray(citedLine2.formula.terms, 2),
+      _a = _citedLine2$formula$t[0],
+      _b = _citedLine2$formula$t[1];
+    var _subAtoB = substitute(citedLine1.formula, _b, _a);
+    var _subBtoA = substitute(citedLine1.formula, _a, _b);
+    valid = formulasEqual(_subAtoB, line.formula) || formulasEqual(_subBtoA, line.formula);
+  }
+  if (!valid) {
+    issues.push('Identity elimination requires an identity and a formula to substitute into');
+  }
+}
+
+// ============================================================================
+// STRUCTURAL RULE VALIDATORS
+// ============================================================================
+
+function validateReit(line, previousLines, lineIndex, issues) {
+  if (line.citations.length !== 1) {
+    issues.push('Reiteration requires exactly one citation');
+    return;
+  }
+  var citedIndex = line.citations[0] - 1;
+  if (citedIndex < 0 || citedIndex >= previousLines.length) {
+    issues.push('Invalid line citation');
+    return;
+  }
+  var cited = previousLines[citedIndex];
+  if (!isValidCitation(cited, line)) {
+    issues.push('Cited line is not available in current scope');
+    return;
+  }
+  if (!formulasEqual(line.formula, cited.formula)) {
+    issues.push('Formula does not match cited line');
+  }
+}
+
+// ============================================================================
+// VALIDATOR REGISTRY
+// ============================================================================
+
+export var RULE_VALIDATORS = (_RULE_VALIDATORS = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_RULE_VALIDATORS, RULES.CONJ_INTRO, validateConjIntro), RULES.CONJ_ELIM, validateConjElim), RULES.DISJ_INTRO, validateDisjIntro), RULES.DISJ_ELIM, validateDisjElim), RULES.COND_INTRO, validateCondIntro), RULES.COND_ELIM, validateCondElim), RULES.BICOND_INTRO, validateBicondIntro), RULES.BICOND_ELIM, validateBicondElim), RULES.NEG_INTRO, validateNegIntro), RULES.NEG_ELIM, validateNegElim), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_RULE_VALIDATORS, RULES.CONTRA_INTRO, validateContraIntro), RULES.CONTRA_ELIM, validateContraElim), RULES.LEM, validateLEM), RULES.UNIV_INTRO, validateUnivIntro), RULES.UNIV_ELIM, validateUnivElim), RULES.EXIST_INTRO, validateExistIntro), RULES.EXIST_ELIM, validateExistElim), RULES.ID_INTRO, validateIdIntro), RULES.ID_ELIM, validateIdElim), RULES.REIT, validateReit));