From 26da267b732e28e4d9697278e735b410e50e5e08 Mon Sep 17 00:00:00 2001
From: Richard Qin <richard.qin.x@gmail.com>
Date: Thu, 2 Apr 2026 04:10:53 +0800
Subject: Initial commit: Build project architecture, define interfaces, write
 documentation, with the help of Claude

---
 include/atp/normalize/clausifier.h | 38 ++++++++++++++++++++
 include/atp/normalize/formula.h    | 74 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 include/atp/normalize/clausifier.h
 create mode 100644 include/atp/normalize/formula.h

(limited to 'include/atp/normalize')

diff --git a/include/atp/normalize/clausifier.h b/include/atp/normalize/clausifier.h
new file mode 100644
index 0000000..1ff4d27
--- /dev/null
+++ b/include/atp/normalize/clausifier.h
@@ -0,0 +1,38 @@
+/*
+ * richard-atp-engine: A saturation-based automated theorem prover for first-order logic.
+ * Copyright (C) 2026 Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+#pragma once
+
+/// @file clausifier.h
+/// @brief Converts FOL formulas to Clause Normal Form (CNF).
+///
+/// Pipeline: eliminate ↔/→  →  NNF  →  Skolemize  →  distribute ∨ over ∧  →  flatten.
+
+#include "atp/core/clause.h"
+#include "atp/core/term_bank.h"
+#include "atp/normalize/formula.h"
+
+#include <vector>
+
+namespace atp {
+
+/// Convert a first-order formula into a set of clauses (CNF).
+std::vector<Clause> clausify(const Formula& formula, TermBank& bank);
+
+}  // namespace atp
diff --git a/include/atp/normalize/formula.h b/include/atp/normalize/formula.h
new file mode 100644
index 0000000..ccf1302
--- /dev/null
+++ b/include/atp/normalize/formula.h
@@ -0,0 +1,74 @@
+/*
+ * richard-atp-engine: A saturation-based automated theorem prover for first-order logic.
+ * Copyright (C) 2026 Richard Qin
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * 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).
+
+#include "atp/core/types.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace atp {
+
+/// AST node types for first-order logic formulas.
+enum class FormulaKind : uint8_t {
+    kAtom,       ///< Predicate application: P(t1, ..., tn)
+    kNot,        ///< Negation: ¬F
+    kAnd,        ///< Conjunction: F ∧ G
+    kOr,         ///< Disjunction: F ∨ G
+    kImplies,    ///< Implication: F → G
+    kIff,        ///< Biconditional: F ↔ G
+    kForall,     ///< Universal: ∀x. F
+    kExists,     ///< Existential: ∃x. F
+};
+
+/// A first-order logic formula node.
+struct Formula {
+    FormulaKind kind;
+
+    // For kAtom: the predicate term
+    TermId atom = kInvalidId;
+
+    // For quantifiers: the bound variable name
+    std::string var_name;
+
+    // Sub-formulas (1 for Not/Quantifiers, 2 for binary connectives)
+    std::vector<std::unique_ptr<Formula>> children;
+
+    static std::unique_ptr<Formula> makeAtom(TermId 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);
+    static std::unique_ptr<Formula> makeOr(std::unique_ptr<Formula> lhs,
+                                           std::unique_ptr<Formula> rhs);
+    static std::unique_ptr<Formula> makeImplies(std::unique_ptr<Formula> lhs,
+                                                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,
+                                               std::unique_ptr<Formula> body);
+    static std::unique_ptr<Formula> makeExists(std::string var,
+                                               std::unique_ptr<Formula> body);
+};
+
+}  // namespace atp
-- 
cgit v1.2.3