fitch-js 0.1.0

package/dist/cjs/parser.js

@@ -0,0 +1,211 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OPERATORS = void 0;
+exports.parseFormula = parseFormula;
+/**
+ * Formula parser for Fitch-style proofs
+ */
+
+var OPERATORS = exports.OPERATORS = {
+  AND: '∧',
+  OR: '∨',
+  NOT: '¬',
+  IMPLIES: '→',
+  IFF: '↔',
+  FORALL: '∀',
+  EXISTS: '∃',
+  EQUALS: '=',
+  CONTRA: '⊥'
+};
+
+// Pre-compute operator set for O(1) lookup
+var OPERATOR_SET = new Set(Object.values(OPERATORS));
+
+/**
+ * Tokenizes a formula string into an array of tokens
+ * @param {string} formula - The formula string to tokenize
+ * @returns {string[]} Array of tokens
+ */
+function tokenize(formula) {
+  var tokens = [];
+  var chars = [];
+  for (var i = 0; i < formula.length; i++) {
+    var _char = formula[i];
+    if (_char === ' ') {
+      if (chars.length > 0) {
+        tokens.push(chars.join(''));
+        chars.length = 0;
+      }
+      continue;
+    }
+    if ('(),'.includes(_char)) {
+      if (chars.length > 0) {
+        tokens.push(chars.join(''));
+        chars.length = 0;
+      }
+      tokens.push(_char);
+      continue;
+    }
+    if (OPERATOR_SET.has(_char)) {
+      if (chars.length > 0) {
+        tokens.push(chars.join(''));
+        chars.length = 0;
+      }
+      tokens.push(_char);
+      continue;
+    }
+    chars.push(_char);
+  }
+  if (chars.length > 0) {
+    tokens.push(chars.join(''));
+  }
+  return tokens;
+}
+
+/**
+ * Parses a formula string into a Formula object
+ * @param {string} formulaStr - The formula string to parse
+ * @returns {import('./types').Formula} The parsed formula
+ */
+function parseFormula(formulaStr) {
+  var tokens = tokenize(formulaStr);
+  var pos = 0;
+  function parseAtom() {
+    var token = tokens[pos];
+    pos++;
+
+    // Check for contradiction
+    if (token === OPERATORS.CONTRA) {
+      return {
+        type: 'splat'
+      };
+    }
+
+    // Check if it's followed by terms in parentheses
+    if (pos < tokens.length && tokens[pos] === '(') {
+      pos++; // Skip opening parenthesis
+      var terms = [];
+      while (pos < tokens.length && tokens[pos] !== ')') {
+        if (tokens[pos] !== ',') {
+          terms.push(tokens[pos]);
+        }
+        pos++;
+      }
+      if (pos >= tokens.length || tokens[pos] !== ')') {
+        throw new Error('Missing closing parenthesis');
+      }
+      pos++; // Skip closing parenthesis
+
+      return {
+        type: 'atomic',
+        predicate: token,
+        terms: terms
+      };
+    }
+
+    // Single term atomic formula (propositional variable)
+    return {
+      type: 'atomic',
+      predicate: token,
+      terms: []
+    };
+  }
+  function parseQuantified() {
+    var operator = tokens[pos];
+    pos++;
+    if (pos >= tokens.length) {
+      throw new Error('Incomplete quantified formula');
+    }
+    var variable = tokens[pos];
+    pos++;
+    var scope = parseFormula(tokens.slice(pos).join(' '));
+    pos = tokens.length;
+    return {
+      type: 'quantified',
+      operator: operator,
+      variable: variable,
+      scope: scope
+    };
+  }
+  function parseCompound() {
+    if (tokens[pos] === '(') {
+      pos++; // Skip opening parenthesis
+      var formula = parseFormula(tokens.slice(pos).join(' '));
+
+      // Find matching closing parenthesis
+      var parenCount = 1;
+      var endPos = pos;
+      while (parenCount > 0 && endPos < tokens.length) {
+        endPos++;
+        if (tokens[endPos] === '(') parenCount++;
+        if (tokens[endPos] === ')') parenCount--;
+      }
+      if (parenCount > 0) {
+        throw new Error('Unmatched parentheses');
+      }
+      pos = endPos + 1;
+
+      // Check if there's an operator after the parentheses
+      if (pos < tokens.length && OPERATOR_SET.has(tokens[pos])) {
+        var _operator = tokens[pos];
+        pos++;
+        var _right = parseFormula(tokens.slice(pos).join(' '));
+        pos = tokens.length;
+        return {
+          type: 'compound',
+          operator: _operator,
+          left: formula,
+          right: _right
+        };
+      }
+      return formula;
+    }
+    if (tokens[pos] === OPERATORS.NOT) {
+      pos++;
+      return {
+        type: 'compound',
+        operator: OPERATORS.NOT,
+        right: parseFormula(tokens.slice(pos).join(' '))
+      };
+    }
+    var left = parseAtom();
+    if (pos >= tokens.length) {
+      return left;
+    }
+    var operator = tokens[pos];
+    if (!OPERATOR_SET.has(operator)) {
+      return left;
+    }
+    pos++;
+    var right = parseFormula(tokens.slice(pos).join(' '));
+    pos = tokens.length;
+    return {
+      type: 'compound',
+      operator: operator,
+      left: left,
+      right: right
+    };
+  }
+
+  // Start parsing
+  if (pos >= tokens.length) {
+    throw new Error('Empty formula');
+  }
+
+  // Check for quantifiers
+  if (tokens[pos] === OPERATORS.FORALL || tokens[pos] === OPERATORS.EXISTS) {
+    return parseQuantified();
+  }
+
+  // Check for identity formulas
+  if (tokens.length >= 3 && tokens[1] === OPERATORS.EQUALS) {
+    return {
+      type: 'identity',
+      terms: [tokens[0], tokens[2]]
+    };
+  }
+  return parseCompound();
+}

package/dist/cjs/proof/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "RULE_MAP", {
+  enumerable: true,
+  get: function get() {
+    return _types.RULE_MAP;
+  }
+});
+Object.defineProperty(exports, "getDocumentLineForProofLine", {
+  enumerable: true,
+  get: function get() {
+    return _textParser.getDocumentLineForProofLine;
+  }
+});
+Object.defineProperty(exports, "getLineForPosition", {
+  enumerable: true,
+  get: function get() {
+    return _textParser.getLineForPosition;
+  }
+});
+Object.defineProperty(exports, "parseProofText", {
+  enumerable: true,
+  get: function get() {
+    return _textParser.parseProofText;
+  }
+});
+var _textParser = require("./textParser.js");
+var _types = require("./types.js");

package/dist/cjs/proof/textParser.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDocumentLineForProofLine = getDocumentLineForProofLine;
+exports.getLineForPosition = getLineForPosition;
+exports.parseProofText = parseProofText;
+var _parser = require("../parser.js");
+var _symbols = require("../symbols.js");
+var _types = require("./types.js");
+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
+ */
+/**
+ * @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)
+ */
+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 = (0, _parser.parseFormula)((0, _symbols.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 = (0, _parser.parseFormula)((0, _symbols.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 = (0, _symbols.convertAsciiToSymbols)(ruleText);
+    var normalizedRule = _types.RULE_MAP[convertedRule] || _types.RULE_MAP[ruleText] || ruleText;
+
+    // Validate that rule is known
+    if (ruleText && !_types.RULE_MAP[convertedRule] && !_types.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
+ */
+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
+ */
+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/cjs/proof/types.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.RULE_MAP = void 0;
+/**
+ * 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>}
+ */
+var RULE_MAP = exports.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)
+var _default = exports["default"] = {};