fitch-js 0.1.0

package/dist/cjs/symbols.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertAsciiToSymbols = convertAsciiToSymbols;
+exports.convertSymbolsToAscii = convertSymbolsToAscii;
+exports.symbolMappings = void 0;
+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 _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 _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; }
+/**
+ * ASCII to Unicode symbol conversion utilities for logical notation
+ * @module symbols
+ */
+
+// ASCII to Unicode symbol mappings (sorted by length, longest first for correct replacement order)
+var SYMBOL_MAPPINGS = [['<->', '↔'], ['/\\', '∧'], ['\\/', '∨'], ['_|_', '⊥'], ['->', '→'], ['~', '¬'], ['!', '¬'], ['&', '∧'], ['#', '⊥'], ['@', '∀'], ['$', '∃']];
+
+/**
+ * Converts ASCII logical symbols to their Unicode equivalents
+ * @param {string} text - Text containing ASCII symbols
+ * @returns {string} Text with Unicode symbols
+ * @example
+ * convertAsciiToSymbols('P -> Q') // Returns 'P → Q'
+ * convertAsciiToSymbols('~P /\\ Q') // Returns '¬P ∧ Q'
+ * convertAsciiToSymbols('@x P(x)') // Returns '∀x P(x)'
+ */
+function convertAsciiToSymbols(text) {
+  var result = text;
+  var _iterator = _createForOfIteratorHelper(SYMBOL_MAPPINGS),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        ascii = _step$value[0],
+        symbol = _step$value[1];
+      var regex = new RegExp(ascii.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+      result = result.replace(regex, symbol);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+
+/**
+ * Converts Unicode logical symbols back to ASCII equivalents
+ * @param {string} text - Text containing Unicode symbols
+ * @returns {string} Text with ASCII symbols
+ * @example
+ * convertSymbolsToAscii('P → Q') // Returns 'P -> Q'
+ * convertSymbolsToAscii('¬P ∧ Q') // Returns '~P /\\ Q'
+ */
+function convertSymbolsToAscii(text) {
+  var result = text;
+  var _iterator2 = _createForOfIteratorHelper(SYMBOL_MAPPINGS),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+        ascii = _step2$value[0],
+        symbol = _step2$value[1];
+      var regex = new RegExp(symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+      result = result.replace(regex, ascii);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return result;
+}
+
+/**
+ * The symbol mappings array for external use
+ * @type {Array<[string, string]>}
+ */
+var symbolMappings = exports.symbolMappings = SYMBOL_MAPPINGS;

package/dist/cjs/types.js

@@ -0,0 +1,184 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RULE_REQUIREMENTS = exports.RULES = void 0;
+exports.getAllTerms = getAllTerms;
+var _parser = require("./parser.js");
+var _RULE_REQUIREMENTS;
+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); }
+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 _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 _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 _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; }
+/**
+ * @typedef {Object} Formula
+ * @property {string} type - The type of formula ('atomic', 'compound', 'quantified', 'identity', 'splat')
+ * @property {string} [operator] - The main logical operator (for compound/quantified formulas)
+ * @property {string} [predicate] - The predicate symbol (for atomic formulas)
+ * @property {string[]} [terms] - The terms in the formula
+ * @property {Formula} [left] - The left subformula (for binary operators)
+ * @property {Formula} [right] - The right subformula (for binary operators)
+ * @property {string} [variable] - The bound variable (for quantified formulas)
+ * @property {Formula} [scope] - The scope of the quantifier (for quantified formulas)
+ */
+
+/**
+ * @typedef {Object} ProofLine
+ * @property {number} lineNum - The line number in the proof
+ * @property {Formula} formula - The formula at this line
+ * @property {string} rule - The rule applied at this line
+ * @property {number[]} citations - Line numbers cited in the justification
+ * @property {Array<{start: number, end: number}>} subproofs - Subproof ranges cited
+ * @property {string[]} issues - Any issues with this line
+ * @property {number[]} location - Array indicating the scope depth
+ */
+
+/**
+ * @typedef {Object} Proof
+ * @property {ProofLine[]} lines - The lines in the proof
+ * @property {number} numPremises - The number of premises
+ * @property {Formula} conclusion - The desired conclusion
+ */
+
+/**
+ * @typedef {Object} ValidationResult
+ * @property {boolean} isValid - Whether the proof is valid
+ * @property {string[]} issues - Any issues with the proof
+ * @property {boolean} conclusionReached - Whether the conclusion was reached
+ */
+
+/**
+ * Extracts all terms from a formula recursively
+ * @param {Formula} formula
+ * @returns {string[]}
+ */
+function getAllTerms(formula) {
+  if (!formula) return [];
+  switch (formula.type) {
+    case 'atomic':
+      return formula.terms || [];
+    case 'compound':
+      if (formula.operator === _parser.OPERATORS.NOT) {
+        return formula.right ? getAllTerms(formula.right) : [];
+      }
+      return [].concat(_toConsumableArray(formula.left ? getAllTerms(formula.left) : []), _toConsumableArray(formula.right ? getAllTerms(formula.right) : []));
+    case 'quantified':
+      if (!formula.scope) return [];
+      return getAllTerms(formula.scope).filter(function (t) {
+        return t !== formula.variable;
+      });
+    case 'identity':
+      return formula.terms || [];
+    default:
+      return [];
+  }
+}
+
+// Rule definitions
+var RULES = exports.RULES = {
+  // Propositional Logic Rules
+  CONJ_INTRO: '∧I',
+  CONJ_ELIM: '∧E',
+  DISJ_INTRO: '∨I',
+  DISJ_ELIM: '∨E',
+  COND_INTRO: '→I',
+  COND_ELIM: '→E',
+  BICOND_INTRO: '↔I',
+  BICOND_ELIM: '↔E',
+  NEG_INTRO: '¬I',
+  NEG_ELIM: '¬E',
+  CONTRA_INTRO: '⊥I',
+  CONTRA_ELIM: '⊥E',
+  LEM: 'LEM',
+  // First-Order Logic Rules
+  UNIV_INTRO: '∀I',
+  UNIV_ELIM: '∀E',
+  EXIST_INTRO: '∃I',
+  EXIST_ELIM: '∃E',
+  ID_INTRO: '=I',
+  ID_ELIM: '=E',
+  CQ: 'CQ',
+  // Structural Rules
+  PREMISE: 'Pr',
+  HYPOTHESIS: 'Hyp',
+  REIT: 'R'
+};
+
+// Rule citation requirements
+var RULE_REQUIREMENTS = exports.RULE_REQUIREMENTS = (_RULE_REQUIREMENTS = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_RULE_REQUIREMENTS, RULES.CONJ_INTRO, {
+  lines: 2,
+  subproofs: 0
+}), RULES.CONJ_ELIM, {
+  lines: 1,
+  subproofs: 0
+}), RULES.DISJ_INTRO, {
+  lines: 1,
+  subproofs: 0
+}), RULES.DISJ_ELIM, {
+  lines: 1,
+  subproofs: 2
+}), RULES.COND_INTRO, {
+  lines: 0,
+  subproofs: 1
+}), RULES.COND_ELIM, {
+  lines: 2,
+  subproofs: 0
+}), RULES.BICOND_INTRO, {
+  lines: 0,
+  subproofs: 2
+}), RULES.BICOND_ELIM, {
+  lines: 2,
+  subproofs: 0
+}), RULES.NEG_INTRO, {
+  lines: 0,
+  subproofs: 1
+}), RULES.NEG_ELIM, {
+  lines: 2,
+  subproofs: 0
+}), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_RULE_REQUIREMENTS, RULES.CONTRA_INTRO, {
+  lines: 2,
+  subproofs: 0
+}), RULES.CONTRA_ELIM, {
+  lines: 1,
+  subproofs: 0
+}), RULES.LEM, {
+  lines: 0,
+  subproofs: 2
+}), RULES.UNIV_INTRO, {
+  lines: 1,
+  subproofs: 0
+}), RULES.UNIV_ELIM, {
+  lines: 1,
+  subproofs: 0
+}), RULES.EXIST_INTRO, {
+  lines: 1,
+  subproofs: 0
+}), RULES.EXIST_ELIM, {
+  lines: 1,
+  subproofs: 1
+}), RULES.ID_INTRO, {
+  lines: 0,
+  subproofs: 0
+}), RULES.ID_ELIM, {
+  lines: 2,
+  subproofs: 0
+}), RULES.CQ, {
+  lines: 1,
+  subproofs: 0
+}), _defineProperty(_defineProperty(_defineProperty(_RULE_REQUIREMENTS, RULES.PREMISE, {
+  lines: 0,
+  subproofs: 0
+}), RULES.HYPOTHESIS, {
+  lines: 0,
+  subproofs: 0
+}), RULES.REIT, {
+  lines: 1,
+  subproofs: 0
+}));

package/dist/esm/index.js

@@ -0,0 +1,17 @@
+// Public API exports
+
+// Formula parsing
+export { parseFormula, OPERATORS } from './parser.js';
+
+// Proof validation
+export { checkProof, formulasEqual, occursFree, substitute, getAvailableTerms } from './proofChecker.js';
+
+// Rule definitions and utilities
+export { RULES, RULE_REQUIREMENTS, getAllTerms } from './types.js';
+export { isVariable, isLineAvailable, isValidCitation } from './ruleValidators.js';
+
+// Symbol conversion utilities
+export { convertAsciiToSymbols, convertSymbolsToAscii, symbolMappings } from './symbols.js';
+
+// Text-format proof parsing
+export { parseProofText, getLineForPosition, getDocumentLineForProofLine, RULE_MAP } from './proof/index.js';

package/dist/esm/parser.js

@@ -0,0 +1,204 @@
+/**
+ * Formula parser for Fitch-style proofs
+ */
+
+export var 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
+ */
+export 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/esm/proof/index.js

@@ -0,0 +1,7 @@
+/**
+ * Proof text parsing module
+ * @module proof
+ */
+
+export { parseProofText, getLineForPosition, getDocumentLineForProofLine } from './textParser.js';
+export { RULE_MAP } from './types.js';