fitch-js 0.1.0

package/dist/esm/proof/textParser.js

@@ -0,0 +1,217 @@
+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; }
+/**
+ * Text-format proof parser for Fitch-style natural deduction proofs
+ * @module proof/textParser
+ */
+
+import { parseFormula } from '../parser.js';
+import { convertAsciiToSymbols } from '../symbols.js';
+import { RULE_MAP } from './types.js';
+
+/**
+ * @typedef {import('./types.js').ProofLine} ProofLine
+ * @typedef {import('./types.js').ParsedProof} ParsedProof
+ * @typedef {import('./types.js').SubproofCitation} SubproofCitation
+ * @typedef {import('../types.js').Formula} Formula
+ */
+
+/**
+ * Parses a text-format Fitch proof into a structured representation
+ *
+ * @param {string} text - The proof text to parse
+ * @returns {ParsedProof} The parsed proof structure
+ *
+ * @example
+ * const proof = parseProofText(`
+ * P → Q         :PR
+ * P             :PR
+ * Q             :→E 1 2
+ * // Goal: Q
+ * `);
+ *
+ * @description
+ * Text format specification:
+ * - Each line: FORMULA :RULE citations
+ * - Subproofs indicated by leading pipes: | or ||
+ * - Comments: // text
+ * - Goal: // Goal: FORMULA
+ * - Line citations: space-separated numbers (e.g., 1 2)
+ * - Subproof citations: hyphenated ranges (e.g., 3-5)
+ */
+export function parseProofText(text) {
+  /** @type {ProofLine[]} */
+  var lines = [];
+  var rawLines = text.split('\n');
+  var lineNum = 0;
+  /** @type {Formula|null} */
+  var goal = null;
+  /** @type {string|null} */
+  var goalText = null;
+  /** @type {number[]} */
+  var subproofStack = [];
+  for (var i = 0; i < rawLines.length; i++) {
+    var raw = rawLines[i];
+    var trimmed = raw.trim();
+
+    // Skip empty lines
+    if (!trimmed) continue;
+
+    // Handle comments
+    if (trimmed.startsWith('//')) {
+      // Check for goal declaration
+      var goalMatch = trimmed.match(/\/\/\s*Goal:\s*(.+)/i);
+      if (goalMatch) {
+        goalText = goalMatch[1].trim();
+        try {
+          goal = parseFormula(convertAsciiToSymbols(goalText));
+        } catch (_unused) {
+          // Invalid goal formula - will be caught during validation
+        }
+      }
+      continue;
+    }
+    lineNum++;
+
+    // Calculate depth from leading pipes
+    var depthMatch = raw.match(/^(\s*\|*)/);
+    var depth = depthMatch ? (depthMatch[1].match(/\|/g) || []).length : 0;
+
+    // Update subproof stack based on depth changes
+    while (subproofStack.length > depth) {
+      subproofStack.pop();
+    }
+    if (depth > subproofStack.length) {
+      subproofStack.push(lineNum);
+    }
+
+    // Parse the line content (strip leading pipes and whitespace)
+    var content = trimmed.replace(/^\|+\s*/, '');
+    var colonIndex = content.lastIndexOf(':');
+    var formulaText = '';
+    var ruleText = '';
+    /** @type {number[]} */
+    var citations = [];
+    /** @type {SubproofCitation[]} */
+    var subproofCitations = [];
+    if (colonIndex !== -1) {
+      formulaText = content.substring(0, colonIndex).trim();
+      var rulePart = content.substring(colonIndex + 1).trim();
+      var ruleParts = rulePart.split(/\s+/);
+      ruleText = ruleParts[0] || '';
+
+      // Parse citations
+      for (var j = 1; j < ruleParts.length; j++) {
+        var cit = ruleParts[j];
+        if (cit.includes('-')) {
+          var _cit$split$map = cit.split('-').map(Number),
+            _cit$split$map2 = _slicedToArray(_cit$split$map, 2),
+            start = _cit$split$map2[0],
+            end = _cit$split$map2[1];
+          if (!isNaN(start) && !isNaN(end)) {
+            subproofCitations.push({
+              start: start,
+              end: end
+            });
+          }
+        } else {
+          var num = parseInt(cit, 10);
+          if (!isNaN(num)) {
+            citations.push(num);
+          }
+        }
+      }
+    } else {
+      formulaText = content;
+    }
+
+    // Parse formula
+    /** @type {Formula|null} */
+    var formula = null;
+    /** @type {string[]} */
+    var issues = [];
+    try {
+      if (formulaText) {
+        formula = parseFormula(convertAsciiToSymbols(formulaText));
+      }
+    } catch (e) {
+      issues.push("Parse error: ".concat(e instanceof Error ? e.message : 'Invalid formula'));
+    }
+
+    // Normalize rule - try both the raw rule and the converted version
+    var convertedRule = convertAsciiToSymbols(ruleText);
+    var normalizedRule = RULE_MAP[convertedRule] || RULE_MAP[ruleText] || ruleText;
+
+    // Validate that rule is known
+    if (ruleText && !RULE_MAP[convertedRule] && !RULE_MAP[ruleText]) {
+      issues.push("Unknown rule: ".concat(ruleText));
+    }
+    lines.push({
+      lineNum: lineNum,
+      rawText: raw,
+      formula: formula,
+      rule: normalizedRule,
+      citations: citations,
+      subproofCitations: subproofCitations,
+      depth: depth,
+      location: [].concat(subproofStack),
+      issues: issues
+    });
+  }
+  return {
+    lines: lines,
+    goal: goal,
+    goalText: goalText
+  };
+}
+
+/**
+ * Finds the proof line corresponding to a document position
+ *
+ * @param {ParsedProof} parsed - The parsed proof
+ * @param {string} text - The original document text
+ * @param {number} line - The 0-indexed document line number
+ * @returns {ProofLine|null} The proof line at that position, or null
+ */
+export function getLineForPosition(parsed, text, line) {
+  var textLines = text.split('\n');
+  var proofLineCount = 0;
+  for (var i = 0; i < textLines.length && i <= line; i++) {
+    var trimmed = textLines[i].trim();
+    if (trimmed && !trimmed.startsWith('//')) {
+      proofLineCount++;
+      if (i === line) {
+        return parsed.lines.find(function (l) {
+          return l.lineNum === proofLineCount;
+        }) || null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Finds the document line number for a given proof line number
+ *
+ * @param {string} text - The original document text
+ * @param {number} proofLineNum - The 1-indexed proof line number
+ * @returns {number} The 0-indexed document line number
+ */
+export function getDocumentLineForProofLine(text, proofLineNum) {
+  var textLines = text.split('\n');
+  var proofLineCount = 0;
+  for (var i = 0; i < textLines.length; i++) {
+    var trimmed = textLines[i].trim();
+    if (trimmed && !trimmed.startsWith('//')) {
+      proofLineCount++;
+      if (proofLineCount === proofLineNum) {
+        return i;
+      }
+    }
+  }
+  return 0;
+}

package/dist/esm/proof/types.js

@@ -0,0 +1,111 @@
+/**
+ * Type definitions for proof text parsing
+ * @module proof/types
+ */
+
+/**
+ * @typedef {import('../types.js').Formula} Formula
+ */
+
+/**
+ * A parsed line from a text-format proof
+ * @typedef {Object} ProofLine
+ * @property {number} lineNum - The proof line number (1-indexed, excludes comments)
+ * @property {string} rawText - The original text of the line
+ * @property {Formula|null} formula - The parsed formula, or null if parsing failed
+ * @property {string} rule - The normalized rule name (e.g., '∧I', 'Pr')
+ * @property {number[]} citations - Line numbers cited in justification
+ * @property {SubproofCitation[]} subproofCitations - Subproof ranges cited
+ * @property {number} depth - Subproof nesting depth (0 = main proof)
+ * @property {number[]} location - Path through subproof tree
+ * @property {string[]} issues - Parse errors for this line
+ */
+
+/**
+ * A subproof citation range
+ * @typedef {Object} SubproofCitation
+ * @property {number} start - Starting line number
+ * @property {number} end - Ending line number
+ */
+
+/**
+ * Result of parsing a proof text file
+ * @typedef {Object} ParsedProof
+ * @property {ProofLine[]} lines - All parsed proof lines
+ * @property {Formula|null} goal - The goal formula (from // Goal: comment)
+ * @property {string|null} goalText - The raw goal text
+ */
+
+/**
+ * Rule normalization map - maps various ASCII/Unicode rule names to canonical form
+ * @type {Record<string, string>}
+ */
+export var RULE_MAP = {
+  // Structural rules
+  'PR': 'Pr',
+  'Pr': 'Pr',
+  'Hyp': 'Hyp',
+  'AS': 'Hyp',
+  'R': 'R',
+  // Conjunction
+  '∧I': '∧I',
+  '&I': '∧I',
+  '/\\I': '∧I',
+  '^I': '∧I',
+  '∧E': '∧E',
+  '&E': '∧E',
+  '/\\E': '∧E',
+  '^E': '∧E',
+  // Disjunction
+  '∨I': '∨I',
+  '|I': '∨I',
+  '\\/I': '∨I',
+  '∨E': '∨E',
+  '|E': '∨E',
+  '\\/E': '∨E',
+  // Implication
+  '→I': '→I',
+  '->I': '→I',
+  '→E': '→E',
+  '->E': '→E',
+  'MP': '→E',
+  // Biconditional
+  '↔I': '↔I',
+  '<->I': '↔I',
+  '↔E': '↔E',
+  '<->E': '↔E',
+  // Negation
+  '¬I': '¬I',
+  '~I': '¬I',
+  '!I': '¬I',
+  '¬E': '¬E',
+  '~E': '¬E',
+  '!E': '¬E',
+  'DNE': '¬E',
+  // Contradiction
+  '⊥I': '⊥I',
+  '#I': '⊥I',
+  '_|_I': '⊥I',
+  '⊥E': '⊥E',
+  '#E': '⊥E',
+  '_|_E': '⊥E',
+  'X': '⊥E',
+  // Quantifiers
+  '∀I': '∀I',
+  '@I': '∀I',
+  '∀E': '∀E',
+  '@E': '∀E',
+  '∃I': '∃I',
+  '$I': '∃I',
+  '∃E': '∃E',
+  '$E': '∃E',
+  // Identity
+  '=I': '=I',
+  '=E': '=E',
+  // Meta rules
+  'LEM': 'LEM',
+  'CQ': 'CQ'
+};
+
+// Export empty object to make this a module (types are in JSDoc)
+export default {};

package/dist/esm/proofChecker.js

@@ -0,0 +1,128 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+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 _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; }
+import { RULES, RULE_REQUIREMENTS, getAllTerms } from './types.js';
+import { RULE_VALIDATORS, formulasEqual, occursFree, substitute, isLineAvailable, isValidCitation } from './ruleValidators.js';
+
+/**
+ * Gets all available terms from premises and hypotheses at the current scope
+ * @param {import('./types').ProofLine[]} previousLines
+ * @param {number[]} currentLocation
+ * @returns {Set<string>}
+ */
+export function getAvailableTerms(previousLines, currentLocation) {
+  var terms = new Set();
+  var _iterator = _createForOfIteratorHelper(previousLines),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      if ((line.rule === RULES.PREMISE || line.rule === RULES.HYPOTHESIS) && isLineAvailable(currentLocation, line.location)) {
+        getAllTerms(line.formula).forEach(function (term) {
+          return terms.add(term);
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return terms;
+}
+
+/**
+ * Validates a single proof line
+ * @param {import('./types').ProofLine} line
+ * @param {import('./types').ProofLine[]} previousLines
+ * @param {number} lineIndex
+ * @param {number} numPremises
+ * @returns {string[]} Array of issues found
+ */
+function validateLine(line, previousLines, lineIndex, numPremises) {
+  var issues = [];
+
+  // Validate premises
+  if (lineIndex < numPremises) {
+    if (line.rule !== RULES.PREMISE) {
+      issues.push('Line must be marked as a premise');
+    }
+    return issues;
+  }
+
+  // Check rule requirements exist
+  var requirements = RULE_REQUIREMENTS[line.rule];
+  if (!requirements) {
+    issues.push("Unknown rule: ".concat(line.rule));
+    return issues;
+  }
+
+  // Validate citation counts
+  if (line.citations.length !== requirements.lines) {
+    issues.push("Rule ".concat(line.rule, " requires exactly ").concat(requirements.lines, " line citations"));
+  }
+  if (line.subproofs.length !== requirements.subproofs) {
+    issues.push("Rule ".concat(line.rule, " requires exactly ").concat(requirements.subproofs, " subproof citations"));
+  }
+
+  // Skip structural rules that don't need validation
+  if (line.rule === RULES.PREMISE || line.rule === RULES.HYPOTHESIS) {
+    return issues;
+  }
+
+  // Get the appropriate validator and execute it
+  var validator = RULE_VALIDATORS[line.rule];
+  if (validator) {
+    validator(line, previousLines, lineIndex, issues);
+  }
+  return issues;
+}
+
+/**
+ * Validates an entire proof
+ * @param {import('./types').Proof} proof
+ * @returns {import('./types').ValidationResult}
+ */
+export function checkProof(proof) {
+  var result = {
+    isValid: true,
+    issues: [],
+    conclusionReached: false
+  };
+
+  // Validate each line
+  var _loop = function _loop(i) {
+    var line = proof.lines[i];
+    var previousLines = proof.lines.slice(0, i);
+    var lineIssues = validateLine(line, previousLines, i, proof.numPremises);
+    if (lineIssues.length > 0) {
+      var _result$issues;
+      result.isValid = false;
+      (_result$issues = result.issues).push.apply(_result$issues, _toConsumableArray(lineIssues.map(function (issue) {
+        return "Line ".concat(i + 1, ": ").concat(issue);
+      })));
+    }
+
+    // Check if conclusion is reached
+    if (formulasEqual(line.formula, proof.conclusion)) {
+      result.conclusionReached = true;
+    }
+  };
+  for (var i = 0; i < proof.lines.length; i++) {
+    _loop(i);
+  }
+
+  // Verify conclusion was reached
+  if (!result.conclusionReached) {
+    result.issues.push('Conclusion not reached in proof');
+    result.isValid = false;
+  }
+  return result;
+}
+
+// Re-export utilities for external use
+export { formulasEqual, occursFree, substitute, isLineAvailable, isValidCitation };