fitch-js 0.1.0

package/dist/esm/symbols.js

@@ -0,0 +1,77 @@
+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)'
+ */
+export 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'
+ */
+export 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]>}
+ */
+export var symbolMappings = SYMBOL_MAPPINGS;

package/dist/esm/types.js

@@ -0,0 +1,178 @@
+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); }
+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; }
+import { OPERATORS } from './parser.js';
+
+/**
+ * @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[]}
+ */
+export function getAllTerms(formula) {
+  if (!formula) return [];
+  switch (formula.type) {
+    case 'atomic':
+      return formula.terms || [];
+    case 'compound':
+      if (formula.operator === 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
+export var 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
+export var 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/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "fitch-js",
+  "version": "0.1.0",
+  "description": "A JavaScript library for validating Fitch-style natural deduction proofs",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "build": "npm run build:clean && npm run build:cjs && npm run build:esm",
+    "build:clean": "rm -rf dist",
+    "build:cjs": "BABEL_ENV=cjs babel src -d dist/cjs --extensions '.js,.ts'",
+    "build:esm": "BABEL_ENV=esm babel src -d dist/esm --extensions '.js,.ts'",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "logic",
+    "proof",
+    "fitch",
+    "natural-deduction",
+    "validation"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/cli": "^7.23.9",
+    "@babel/core": "^7.23.9",
+    "@babel/preset-env": "^7.23.9",
+    "@babel/preset-typescript": "^7.23.3",
+    "jest": "^29.7.0",
+    "typescript": "^5.3.3"
+  }
+}