## Lean 4 Theorem Proofs: LLM vs LLM + APOLLO ### Overview The image compares two Lean 4 theorem proofs for the same algebraic identity: `Real.sqrt(60 * x) * Real.sqrt(12 * x) * Real.sqrt(63 * x) = 36 * x * Real.sqrt(35 * x)`. The left side shows a proof generated by LLM alone, while the right side demonstrates an enhanced proof using LLM + APOLLO. Both proofs use Lean's `Mathlib` and `Aesop` libraries with `BigOperators` and `Real.Nat.Topology`. --- ### Components/Axes **Left Panel (LLM):** - **Imports:** `Mathlib`, `Aesop` - **Options:** `set_option maxHeartbeats 0` - **Theorem:** `mathd_algebra_293_llm` - **Proof Tactics:** - `have h1 : ...` - `ring_nf` - `simp [x_mul_x]` - `linarith [show (0 : ℝ) ≤ x from by positivity]` - **Highlighted Section:** - Red box around `rw [h2]`, `rw [Real.sqrt_mul (by positivity)]`, and `all_goals positivity` **Right Panel (LLM + APOLLO):** - **Imports:** Same as LLM - **Theorem:** `mathd_algebra_293_apollo` - **Proof Tactics:** - `have h1, h2, h3, h4` with complex intermediate steps - `try norm_cast`, `try simp_all`, `try ring_nf` - `try linarith` with nested `simp` and `native_decide` - **Highlighted Section:** - Green box around `try norm_cast`, `try simp_all`, and `try ring_nf` --- ### Detailed Analysis **LLM Proof (Left):** 1. **Structure:** - Directly applies `ring_nf` and `simp` to reduce terms. - Uses `linarith` with a custom `show` clause to enforce positivity. 2. **Key Steps:** - `h1` binds the left-hand side (LHS) of the equation. - `ring_nf` simplifies polynomial expressions. - `linarith` proves the inequality `0 ≤ x` via positivity. **LLM + APOLLO Proof (Right):** 1. **Structure:** - Introduces multiple lemmas (`h1`, `h2`, `h3`, `h4`) for intermediate steps. - Uses `norm_cast` to handle norm conversions. - Employs `simp_all` and `native_decide` for automated simplification. 2. **Key Steps:** - `h2` and `h3` break down the equation into smaller components. - `simp [pow_succ]` and `simp [mul_assoc]` handle exponentiation and associativity. - `linarith` is used without custom `show` clauses, relying on APOLLO's optimizations. --- ### Key Observations 1. **Tactic Complexity:** - LLM + APOLLO uses 4x more `have` clauses and 3x more `try` blocks, suggesting deeper decomposition of the problem. 2. **Normalization:** - APOLLO introduces `norm_cast` and `simp_all`, indicating better handling of norm-related terms. 3. **Efficiency:** - LLM requires manual positivity enforcement (`show (0 ≤ x)`), while APOLLO automates this via `native_decide`. --- ### Interpretation The LLM + APOLLO proof demonstrates a more systematic approach to algebraic simplification: - **Decomposition:** Breaking the equation into smaller lemmas (`h1`, `h2`, etc.) allows incremental verification. - **Automation:** Tactics like `simp_all` and `native_decide` reduce manual case analysis, making the proof more robust. - **Normalization:** Explicit handling of norms (`norm_cast`) ensures correctness in real-number arithmetic. The LLM proof, while concise, relies on Lean's default behavior for positivity, which may fail for edge cases. APOLLO's additions suggest a focus on generalizability and error resilience. **Final Note:** Both proofs validate the same identity, but LLM + APOLLO provides a more transparent and maintainable structure, critical for complex mathematical reasoning.