From 31a3d01ef27c559bf7ff453ca60033478ac19ef8 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Thu, 2 Apr 2026 15:23:43 +0800
Subject: refactor: replace string-based formula representation with interned
 SymbolIds and introduce stateful Clausifier for TPTP parsing

---
 include/atp/normalize/formula.h | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

(limited to 'include/atp/normalize/formula.h')

diff --git a/include/atp/normalize/formula.h b/include/atp/normalize/formula.h
index ccf1302..2cd7900 100644
--- a/include/atp/normalize/formula.h
+++ b/include/atp/normalize/formula.h
@@ -16,16 +16,19 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-
 #pragma once
 
 /// @file formula.h
 /// @brief First-order logic formula AST (pre-clausification).
+///
+/// Design decision: atoms use TermId (interned), quantifier variables use
+/// SymbolId (interned). The parser interns all symbols during parsing.
+/// This avoids string→ID lookups during clausification and ensures
+/// consistent variable identity across quantifier scopes.
 
 #include "atp/core/types.h"
 
 #include <memory>
-#include <string>
 #include <vector>
 
 namespace atp {
@@ -33,6 +36,7 @@ namespace atp {
 /// AST node types for first-order logic formulas.
 enum class FormulaKind : uint8_t {
     kAtom,       ///< Predicate application: P(t1, ..., tn)
+    kEquality,   ///< Equality atom: t1 = t2 (distinguished for equality reasoning)
     kNot,        ///< Negation: ¬F
     kAnd,        ///< Conjunction: F ∧ G
     kOr,         ///< Disjunction: F ∨ G
@@ -43,19 +47,27 @@ enum class FormulaKind : uint8_t {
 };
 
 /// A first-order logic formula node.
+///
+/// All identifiers are interned: atoms as TermIds, quantifier variables as
+/// SymbolIds. No raw strings survive past the parser.
 struct Formula {
     FormulaKind kind;
 
-    // For kAtom: the predicate term
+    /// For kAtom / kEquality: the predicate/equality term, already interned.
     TermId atom = kInvalidId;
 
-    // For quantifiers: the bound variable name
-    std::string var_name;
+    /// For kForall / kExists: the bound variable, as an interned SymbolId.
+    /// Using SymbolId (not string) so the clausifier can map bound variables
+    /// back to term-bank variables without string lookups.
+    SymbolId bound_var = kInvalidId;
 
-    // Sub-formulas (1 for Not/Quantifiers, 2 for binary connectives)
+    /// Sub-formulas (1 for Not/Quantifiers, 2 for binary connectives).
     std::vector<std::unique_ptr<Formula>> children;
 
+    // ── Factory methods ──
+
     static std::unique_ptr<Formula> makeAtom(TermId atom);
+    static std::unique_ptr<Formula> makeEquality(TermId lhs, TermId rhs, TermId eq_atom);
     static std::unique_ptr<Formula> makeNot(std::unique_ptr<Formula> child);
     static std::unique_ptr<Formula> makeAnd(std::unique_ptr<Formula> lhs,
                                             std::unique_ptr<Formula> rhs);
@@ -65,9 +77,9 @@ struct Formula {
                                                 std::unique_ptr<Formula> rhs);
     static std::unique_ptr<Formula> makeIff(std::unique_ptr<Formula> lhs,
                                             std::unique_ptr<Formula> rhs);
-    static std::unique_ptr<Formula> makeForall(std::string var,
+    static std::unique_ptr<Formula> makeForall(SymbolId var,
                                                std::unique_ptr<Formula> body);
-    static std::unique_ptr<Formula> makeExists(std::string var,
+    static std::unique_ptr<Formula> makeExists(SymbolId var,
                                                std::unique_ptr<Formula> body);
 };
 
-- 
cgit v1.2.3