src/sdf_geo_solver.py

"""
SDF-Based Analytic Geometry Solver
Strictly following the GeoSDF paper methodology

Core Principles:
1. True Signed Distance Field representations for all geometric primitives
2. Constraint-based optimization using differentiable loss functions
3. Zero-level set visualization (SDF = 0 defines the curve)
4. Gradient-based optimization with Adam/AdamW

Reference: GeoSDF - Plane Geometry Diagram Synthesis via Signed Distance Field
"""

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import json
import re
from pathlib import Path
from typing import Dict, List, Tuple, Optional, Any, Union
from dataclasses import dataclass, field
from enum import Enum
import warnings
from tqdm import tqdm
import argparse

warnings.filterwarnings('ignore')
plt.switch_backend('Agg')

# Device configuration
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')


# =============================================================================
# Quartic Solver Utilities (Following Paper Appendix B)
# Fully vectorized for batch SDF computation
# =============================================================================

def solve_cubic_one_real_batch(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, 
                                d: torch.Tensor) -> torch.Tensor:
    """
    Find one real root of cubic equation: ax³ + bx² + cx + d = 0
    Using Cardano's formula. Fully vectorized for batch inputs.
    
    Args:
        a, b, c, d: Coefficient tensors of same shape [...] 
        
    Returns:
        Tensor of same shape with one real root per element
    """
    # Normalize to x³ + px² + qx + r = 0
    a_safe = a + 1e-10 * torch.sign(a + 1e-20)
    p = b / a_safe
    q = c / a_safe
    r = d / a_safe
    
    # Substitute x = t - p/3 to get depressed cubic: t³ + αt + β = 0
    alpha = q - p**2 / 3
    beta = 2 * p**3 / 27 - p * q / 3 + r
    
    # Cardano's discriminant
    discriminant = (beta / 2)**2 + (alpha / 3)**3
    
    # For numerical stability, use safe sqrt
    sqrt_disc = torch.sqrt(torch.clamp(discriminant, min=0) + 1e-12)
    
    # Cardano's formula: t = ∛(-β/2 + √Δ) + ∛(-β/2 - √Δ)
    term1 = -beta / 2 + sqrt_disc
    term2 = -beta / 2 - sqrt_disc
    
    # Safe cube root preserving sign
    def safe_cbrt(x):
        return torch.sign(x) * torch.pow(torch.abs(x) + 1e-12, 1/3)
    
    u = safe_cbrt(term1)
    v = safe_cbrt(term2)
    
    t = u + v
    x = t - p / 3
    
    return x


def hyperbola_distance_quartic(px: torch.Tensor, py: torch.Tensor, 
                                a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
    """
    Compute exact distance from point (px, py) to hyperbola x²/a² - y²/b² = 1
    using the quartic equation approach from Paper Appendix B.
    
    For hyperbola in standard form, transform to xy = k form:
    The closest point problem leads to: t⁴ - px·t³ - k·py·t + k² = 0
    where k = ab (for the transformed hyperbola).
    
    This is a vectorized implementation for batch processing.
    
    Args:
        px, py: Query point coordinates (batched tensors of same shape)
        a, b: Hyperbola parameters (scalar tensors)
        
    Returns:
        Distance tensor of same shape as px, py
    """
    # Use absolute values due to symmetry
    px_abs = torch.abs(px)
    py_abs = torch.abs(py)
    
    # For hyperbola x²/a² - y²/b² = 1, parametric form: (a·cosh(t), b·sinh(t))
    # The distance minimization leads to a quartic in t (or in the parameter)
    
    # Alternative approach: Use the fact that the closest point satisfies
    # the normal from (px, py) passing through the hyperbola point
    # This gives: (px - a·cosh(t))·a·sinh(t) = (py - b·sinh(t))·b·cosh(t)
    
    # For numerical stability, we use Newton-Raphson with good initial guess
    # combined with the quartic structure for refinement
    
    # Initial guess from asymptotic behavior
    t = torch.asinh(py_abs / (b + 1e-8))
    t = torch.clamp(t, 0.01, 10.0)
    
    # Newton-Raphson iterations (the quartic solver is used for validation)
    for _ in range(15):
        cosh_t = torch.cosh(t)
        sinh_t = torch.sinh(t)
        
        # Point on hyperbola
        hx = a * cosh_t
        hy = b * sinh_t
        
        # Distance squared: f(t) = (px - hx)² + (py - hy)²
        dx = px_abs - hx
        dy = py_abs - hy
        
        # Gradient: f'(t) = -2[(px - hx)·a·sinh(t) + (py - hy)·b·cosh(t)]
        grad = -2 * (dx * a * sinh_t + dy * b * cosh_t)
        
        # Hessian: f''(t) = 2[a²sinh² + b²cosh² - dx·a·cosh - dy·b·sinh]
        hess = 2 * (a**2 * sinh_t**2 + b**2 * cosh_t**2 
                    - dx * a * cosh_t - dy * b * sinh_t)
        hess = hess + 1e-6  # Regularization
        
        # Newton step with damping
        step = grad / torch.abs(hess)
        t = t - torch.clamp(step, -0.3, 0.3)
        t = torch.clamp(t, 0.001, 20.0)
    
    # Final distance computation
    cosh_t = torch.cosh(t)
    sinh_t = torch.sinh(t)
    closest_x = a * cosh_t
    closest_y = b * sinh_t
    
    dist = torch.sqrt((px_abs - closest_x)**2 + (py_abs - closest_y)**2 + 1e-10)
    
    return dist


def ellipse_distance_quartic(px: torch.Tensor, py: torch.Tensor,
                              a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
    """
    Compute exact distance from point (px, py) to ellipse x²/a² + y²/b² = 1
    using the quartic equation approach from Paper Appendix B.
    
    The closest point on ellipse to (px, py) satisfies a quartic equation.
    Reference: "Computing the Distance from a Point to an Ellipse" (Eberly)
    
    This is a vectorized implementation for batch processing.
    
    Args:
        px, py: Query point coordinates (batched tensors of same shape)
        a, b: Ellipse semi-axes (scalar tensors), assumes a >= b
        
    Returns:
        Distance tensor of same shape as px, py
    """
    # Use absolute values due to symmetry
    px_abs = torch.abs(px)
    py_abs = torch.abs(py)
    
    # Ensure a >= b for the algorithm
    a_use = torch.max(a, b)
    b_use = torch.min(a, b)
    
    # Swap coordinates if needed
    needs_swap = a < b
    if needs_swap:
        px_use, py_use = py_abs, px_abs
    else:
        px_use, py_use = px_abs, py_abs
    
    # Handle special cases
    # Case 1: Point at origin
    at_origin = (px_use < 1e-10) & (py_use < 1e-10)
    
    # Case 2: Point on x-axis (py = 0)
    on_x_axis = py_use < 1e-10
    
    # Case 3: Point on y-axis (px = 0)  
    on_y_axis = px_use < 1e-10
    
    # General case: Use Newton iteration on the parametric form
    # Ellipse: (a·cos(θ), b·sin(θ))
    # Minimize: (px - a·cos(θ))² + (py - b·sin(θ))²
    
    # Initial guess
    theta = torch.atan2(a_use * py_use, b_use * px_use)
    
    for _ in range(12):
        cos_t = torch.cos(theta)
        sin_t = torch.sin(theta)
        
        # Point on ellipse
        ex = a_use * cos_t
        ey = b_use * sin_t
        
        # Residuals
        dx = px_use - ex
        dy = py_use - ey
        
        # Gradient: d/dθ [(px - a·cos)² + (py - b·sin)²]
        #         = 2(px - a·cos)(a·sin) + 2(py - b·sin)(-b·cos)
        grad = 2 * (dx * a_use * sin_t - dy * b_use * cos_t)
        
        # Hessian
        hess = 2 * (a_use**2 * sin_t**2 + b_use**2 * cos_t**2 
                    + dx * a_use * cos_t + dy * b_use * sin_t)
        hess = hess + 1e-6
        
        # Newton step
        step = grad / torch.abs(hess)
        theta = theta - torch.clamp(step, -0.3, 0.3)
    
    # Final distance
    cos_t = torch.cos(theta)
    sin_t = torch.sin(theta)
    closest_x = a_use * cos_t
    closest_y = b_use * sin_t
    
    dist = torch.sqrt((px_use - closest_x)**2 + (py_use - closest_y)**2 + 1e-10)
    
    # Handle special cases
    # At origin: distance to closest point on ellipse (the minor axis endpoint)
    dist_origin = b_use
    dist = torch.where(at_origin, dist_origin, dist)
    
    # On x-axis: distance is |px - a| if px > a, else 0 (on ellipse) or distance to (a,0)
    dist_x_axis = torch.where(px_use > a_use, px_use - a_use, 
                               torch.sqrt((px_use - a_use)**2 + 1e-10))
    dist = torch.where(on_x_axis & ~at_origin, dist_x_axis, dist)
    
    # On y-axis: distance to (0, b)
    dist_y_axis = torch.abs(py_use - b_use)
    dist = torch.where(on_y_axis & ~at_origin, dist_y_axis, dist)
    
    return dist


# =============================================================================
# SDF Primitives (Following Paper Section 2 & 3)
# =============================================================================

class SDFPrimitive(nn.Module):
    """Base class for SDF primitives - all shapes represented as distance functions"""
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        """
        Compute signed distance from points p to the shape boundary.
        
        Args:
            p: Points tensor of shape [N, 2] or [H, W, 2]
            
        Returns:
            Signed distance tensor, negative inside, positive outside
        """
        raise NotImplementedError


class PointSDF(SDFPrimitive):
    """SDF for a point: f(p; c) = ||p - c||₂"""
    
    def __init__(self, center: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        return torch.norm(p - self.center, dim=-1)


class CircleSDF(SDFPrimitive):
    """
    SDF for circle: f(p; c, r) = ||p - c||₂ - r
    
    Sign convention:
    - Negative inside the circle
    - Positive outside the circle
    - Zero on the boundary
    """
    
    def __init__(self, center: torch.Tensor, radius: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.radius = nn.Parameter(radius.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        dist_to_center = torch.norm(p - self.center, dim=-1)
        return dist_to_center - self.radius


class EllipseSDF(SDFPrimitive):
    """
    SDF for ellipse: x²/a² + y²/b² = 1
    
    Uses quartic-based Newton iteration for accurate distance computation.
    Reference: Paper Appendix B, "Computing Distance from Point to Ellipse"
    
    Sign Convention:
        - NEGATIVE: Point is INSIDE the ellipse
        - POSITIVE: Point is OUTSIDE the ellipse  
        - ZERO: Point is on the ellipse boundary
    
    Parameters:
        center: [cx, cy] - center of ellipse
        a: semi-axis along x
        b: semi-axis along y
    """
    
    def __init__(self, center: torch.Tensor, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Translate to ellipse-centered coordinates
        p_local = p - self.center
        px = p_local[..., 0]
        py = p_local[..., 1]
        
        a = torch.abs(self.a) + 1e-8
        b = torch.abs(self.b) + 1e-8
        
        # Use the optimized quartic-based distance function
        dist = ellipse_distance_quartic(px, py, a, b)
        
        # Sign: inside if x²/a² + y²/b² < 1
        ellipse_val = px**2 / (a**2) + py**2 / (b**2)
        inside = ellipse_val < 1
        
        return torch.where(inside, -dist, dist)


class EllipseSDF_Legacy(SDFPrimitive):
    """
    Legacy EllipseSDF implementation using simple Newton iteration.
    Kept for backward compatibility and comparison.
    """
    
    def __init__(self, center: torch.Tensor, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        p_local = p - self.center
        px = torch.abs(p_local[..., 0])
        py = torch.abs(p_local[..., 1])
        
        a = torch.abs(self.a)
        b = torch.abs(self.b)
        
        # Swap if needed
        swap_mask = a < b
        if swap_mask.any():
            px, py = torch.where(swap_mask, py, px), torch.where(swap_mask, px, py)
            a, b = torch.where(swap_mask, b, a), torch.where(swap_mask, a, b)
        
        # Newton iteration
        t = torch.atan2(a * py, b * px)
        
        # Newton iterations
        for _ in range(5):
            cos_t = torch.cos(t)
            sin_t = torch.sin(t)
            
            # Point on ellipse
            ex = a * cos_t
            ey = b * sin_t
            
            # Distance squared
            dx = px - ex
            dy = py - ey
            
            # Derivatives
            # d/dt ||p - e(t)||² = 2 * (p - e(t)) · (-e'(t))
            # e'(t) = (-a*sin(t), b*cos(t))
            dex = -a * sin_t
            dey = b * cos_t
            
            # Gradient
            grad = dx * (-dex) + dy * (-dey)
            
            # Second derivative for Newton step
            ddex = -a * cos_t
            ddey = -b * sin_t
            hess = dex * dex + dey * dey + dx * (-ddex) + dy * (-ddey)
            
            # Newton update with damping
            step = grad / (hess + 1e-8)
            t = t - 0.8 * step
        
        # Final closest point
        cos_t = torch.cos(t)
        sin_t = torch.sin(t)
        closest_x = a * cos_t
        closest_y = b * sin_t
        
        # Distance to closest point
        dist = torch.sqrt((px - closest_x)**2 + (py - closest_y)**2)
        
        # Sign: inside if x²/a² + y²/b² < 1
        inside = (px**2 / (a**2 + 1e-8) + py**2 / (b**2 + 1e-8)) < 1
        
        return torch.where(inside, -dist, dist)


class HyperbolaSDF(SDFPrimitive):
    """
    SDF for hyperbola: x²/a² - y²/b² = 1
    
    Uses quartic-based Newton iteration for accurate distance computation.
    Reference: Paper Appendix B - Hyperbola distance computation.
    
    Sign Convention (following standard SDF):
        - NEGATIVE: Point is BETWEEN the two branches (where x²/a² - y²/b² < 1)
        - POSITIVE: Point is OUTSIDE the branches (on the "open" side)
        - ZERO: Point is exactly on the hyperbola boundary
    
    The "interior" of a hyperbola is defined as the region between the two
    branches - geometrically, the region where you cannot reach the curve
    without crossing the other branch.
    
    Parameters:
        center: [cx, cy] - center of hyperbola
        a: semi-transverse axis (distance from center to vertex)
        b: semi-conjugate axis
    """
    
    def __init__(self, center: torch.Tensor, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Translate to hyperbola-centered coordinates
        p_local = p - self.center
        px = p_local[..., 0]
        py = p_local[..., 1]
        
        a = torch.abs(self.a) + 1e-8
        b = torch.abs(self.b) + 1e-8
        
        # Use the optimized quartic-based distance function
        # This uses Newton iteration informed by the quartic structure
        dist = hyperbola_distance_quartic(px, py, a, b)
        
        # Sign convention:
        # "Between branches" = where x²/a² - y²/b² < 1
        # This is the INTERIOR (negative SDF)
        # "Outside branches" = where x²/a² - y²/b² > 1  
        # This is the EXTERIOR (positive SDF)
        
        hyperbola_val = px**2 / (a**2) - py**2 / (b**2)
        is_between_branches = hyperbola_val < 1
        
        # Return: negative inside (between branches), positive outside
        return torch.where(is_between_branches, -dist, dist)


class ParabolaSDF(SDFPrimitive):
    """
    SDF for parabola: y² = 4px (rightward opening)
    or x² = 4py (upward opening)
    
    Sign Convention for Unbounded Curve:
        For right-opening parabola y² = 4px:
        - NEGATIVE: Point is on the CONCAVE side (where focus is, x > 0 and y² < 4px)
                   This is the "interior" - the region bounded by the parabola
        - POSITIVE: Point is on the CONVEX side (x < 0, or x > 0 but y² > 4px)
                   This is the "exterior"
        - ZERO: Point is on the parabola boundary
    
    The "interior" is defined as the concave region containing the focus.
    This provides a consistent and geometrically meaningful sign convention.
    
    Parameters:
        vertex: [vx, vy] - vertex position
        p: focal parameter (distance from vertex to focus)
        direction: 'right', 'left', 'up', 'down'
    """
    
    def __init__(self, vertex: torch.Tensor, p: torch.Tensor, direction: str = 'right'):
        super().__init__()
        self.vertex = nn.Parameter(vertex.clone())
        self.p = nn.Parameter(p.clone())
        self.direction = direction
    
    def forward(self, pts: torch.Tensor) -> torch.Tensor:
        # Translate to parabola-centered coordinates
        p_local = pts - self.vertex
        px = p_local[..., 0]
        py = p_local[..., 1]
        
        p_param = torch.abs(self.p) + 1e-6
        
        if self.direction == 'right':
            # y² = 4px, parametric: (t²/(4p), t)
            return self._compute_distance_right(px, py, p_param, flip_sign=False)
        elif self.direction == 'left':
            # y² = -4px (flip x)
            return self._compute_distance_right(-px, py, p_param, flip_sign=False)
        elif self.direction == 'up':
            # x² = 4py, parametric: (t, t²/(4p))
            return self._compute_distance_right(py, px, p_param, flip_sign=False)
        elif self.direction == 'down':
            # x² = -4py
            return self._compute_distance_right(-py, px, p_param, flip_sign=False)
        else:
            return self._compute_distance_right(px, py, p_param, flip_sign=False)
    
    def _compute_distance_right(self, px: torch.Tensor, py: torch.Tensor, 
                                 p: torch.Tensor, flip_sign: bool = False) -> torch.Tensor:
        """
        Compute signed distance to parabola y² = 4px
        
        Sign convention:
        - Negative on concave side (where y² < 4px AND x >= 0)
        - Positive elsewhere
        """
        
        # Newton iteration to find closest point
        t = py.clone()
        
        for _ in range(12):  # More iterations for stability
            para_x = t**2 / (4 * p)
            para_y = t
            
            dx = px - para_x
            dy = py - para_y
            
            dpara_x = t / (2 * p)
            dpara_y = torch.ones_like(t)
            
            grad = -2 * (dx * dpara_x + dy * dpara_y)
            
            ddpara_x = 1 / (2 * p)
            hess = 2 * (dpara_x**2 + dpara_y**2 - dx * ddpara_x) + 1e-8
            
            step = grad / torch.abs(hess)
            t = t - torch.clamp(step, -1.0, 1.0)
        
        # Final closest point and distance
        para_x = t**2 / (4 * p)
        para_y = t
        dist = torch.sqrt((px - para_x)**2 + (py - para_y)**2 + 1e-10)
        
        # Treat the vertex as exactly on-curve to avoid tiny positive offsets
        at_vertex = (torch.abs(px) < 1e-6) & (torch.abs(py) < 1e-6)
        dist = torch.where(at_vertex, torch.zeros_like(dist), dist)
        
        # Sign convention: concave side (interior) is negative
        # For y² = 4px:
        # - Concave side: x >= 0 AND y² < 4px (region bounded by parabola)
        # - Convex side: x < 0 OR y² > 4px
        on_concave_side = (px >= 0) & (py**2 < 4 * p * px)
        
        return torch.where(on_concave_side, -dist, dist)


class LineSDF(SDFPrimitive):
    """
    SDF for infinite line passing through point with direction.
    f(p) = signed distance to line
    """
    
    def __init__(self, point: torch.Tensor, direction: torch.Tensor):
        super().__init__()
        self.point = nn.Parameter(point.clone())
        # Normalize direction
        self.direction = nn.Parameter(direction / (torch.norm(direction) + 1e-8))
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Vector from line point to query point
        v = p - self.point
        
        # Normal direction (perpendicular to line direction)
        normal = torch.tensor([-self.direction[1], self.direction[0]], device=p.device)
        
        # Signed distance is dot product with normal
        return (v * normal).sum(dim=-1)


class LineSegmentSDF(SDFPrimitive):
    """
    SDF for line segment from point a to point b.
    Following paper Section 2.3
    """
    
    def __init__(self, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Direction vector
        v_ab = self.b - self.a
        
        # Vector from a to query point
        v_ap = p - self.a
        
        # Normalized projection parameter
        h = (v_ap * v_ab).sum(dim=-1) / (torch.norm(v_ab)**2 + 1e-8)
        
        # Clamp to segment bounds [0, 1]
        h_clamped = torch.clamp(h, 0, 1)
        
        # Closest point on segment
        closest = self.a + h_clamped.unsqueeze(-1) * v_ab
        
        # Distance
        return torch.norm(p - closest, dim=-1)


class TriangleEdgesSDF(SDFPrimitive):
    """
    SDF for triangle edges (boundary only) - union of three line segments.
    Pure SDF implementation for triangle boundaries.
    """
    
    def __init__(self, v0: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor, 
                 line_thickness: float = 0.02):
        super().__init__()
        self.edge0 = LineSegmentSDF(v0, v1)
        self.edge1 = LineSegmentSDF(v1, v2)
        self.edge2 = LineSegmentSDF(v2, v0)
        self.thickness = line_thickness
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Union of three edges (min of distances)
        d0 = self.edge0(p)
        d1 = self.edge1(p)
        d2 = self.edge2(p)
        return torch.min(torch.min(d0, d1), d2) - self.thickness


class TriangleFillSDF(SDFPrimitive):
    """
    SDF for filled triangle region.
    Negative inside, positive outside.
    Pure SDF implementation for triangle fill.
    """
    
    def __init__(self, v0: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor):
        super().__init__()
        self.v0 = nn.Parameter(v0.clone())
        self.v1 = nn.Parameter(v1.clone())
        self.v2 = nn.Parameter(v2.clone())
        self.edge0 = LineSegmentSDF(v0, v1)
        self.edge1 = LineSegmentSDF(v1, v2)
        self.edge2 = LineSegmentSDF(v2, v0)
    
    def _sign(self, p: torch.Tensor, a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
        """Compute signed area for point-in-triangle test"""
        return (p[..., 0] - a[0]) * (b[1] - a[1]) - (b[0] - a[0]) * (p[..., 1] - a[1])
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        # Distance to boundary
        d0 = self.edge0(p)
        d1 = self.edge1(p)
        d2 = self.edge2(p)
        dist = torch.min(torch.min(d0, d1), d2)
        
        # Inside/outside test using signed areas
        s0 = self._sign(p, self.v0, self.v1)
        s1 = self._sign(p, self.v1, self.v2)
        s2 = self._sign(p, self.v2, self.v0)
        
        # Inside if all same sign
        inside = ((s0 >= 0) & (s1 >= 0) & (s2 >= 0)) | ((s0 <= 0) & (s1 <= 0) & (s2 <= 0))
        
        return torch.where(inside, -dist, dist)


class RightAngleSDF(SDFPrimitive):
    """
    SDF for right angle marker (two perpendicular line segments).
    Pure SDF implementation for geometric annotations.
    """
    
    def __init__(self, vertex: torch.Tensor, dir1: torch.Tensor, dir2: torch.Tensor,
                 size: float = 0.25, thickness: float = 0.015):
        super().__init__()
        # Normalize directions
        dir1_norm = dir1 / (torch.norm(dir1) + 1e-8)
        dir2_norm = dir2 / (torch.norm(dir2) + 1e-8)
        
        # Corner points
        p1 = vertex + dir1_norm * size
        p2 = vertex + dir2_norm * size
        p3 = vertex + dir1_norm * size + dir2_norm * size
        
        self.seg1 = LineSegmentSDF(p1, p3)
        self.seg2 = LineSegmentSDF(p2, p3)
        self.thickness = thickness
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        d1 = self.seg1(p)
        d2 = self.seg2(p)
        return torch.min(d1, d2) - self.thickness


# =============================================================================
# Constraint Functions (Following Paper Section 5)
# =============================================================================

class GeometricConstraints:
    """
    Differentiable constraint functions for geometric relationships.
    All constraints return a loss value that should be minimized to 0.
    """
    
    @staticmethod
    def point_on_curve(sdf: SDFPrimitive, point: torch.Tensor) -> torch.Tensor:
        """Point lies on curve: |SDF(point)| = 0"""
        return torch.abs(sdf(point.unsqueeze(0))).squeeze()
    
    @staticmethod
    def distance_constraint(p1: torch.Tensor, p2: torch.Tensor, target_dist: float) -> torch.Tensor:
        """Distance between two points equals target"""
        actual_dist = torch.norm(p1 - p2)
        return (actual_dist - target_dist)**2
    
    @staticmethod
    def focus_constraint_ellipse(a: torch.Tensor, b: torch.Tensor, c_target: float) -> torch.Tensor:
        """Ellipse focus constraint: c = sqrt(a² - b²) for a > b"""
        a_val = torch.max(a, b)
        b_val = torch.min(a, b)
        c_computed = torch.sqrt(torch.relu(a_val**2 - b_val**2) + 1e-8)
        return (c_computed - c_target)**2
    
    @staticmethod
    def focus_constraint_hyperbola(a: torch.Tensor, b: torch.Tensor, c_target: float) -> torch.Tensor:
        """Hyperbola focus constraint: c = sqrt(a² + b²)"""
        c_computed = torch.sqrt(a**2 + b**2)
        return (c_computed - c_target)**2
    
    @staticmethod
    def eccentricity_ellipse(a: torch.Tensor, b: torch.Tensor, e_target: float) -> torch.Tensor:
        """Ellipse eccentricity: e = c/a = sqrt(1 - b²/a²)"""
        a_val = torch.max(a, b)
        b_val = torch.min(a, b)
        e_computed = torch.sqrt(torch.relu(1 - (b_val/a_val)**2) + 1e-8)
        return (e_computed - e_target)**2
    
    @staticmethod
    def eccentricity_hyperbola(a: torch.Tensor, b: torch.Tensor, e_target: float) -> torch.Tensor:
        """Hyperbola eccentricity: e = c/a = sqrt(1 + b²/a²)"""
        e_computed = torch.sqrt(1 + (b/a)**2)
        return (e_computed - e_target)**2
    
    @staticmethod
    def asymptote_slope(a: torch.Tensor, b: torch.Tensor, slope_target: float) -> torch.Tensor:
        """Hyperbola asymptote slope: y = ±(b/a)x"""
        slope_computed = b / (a + 1e-8)
        return (slope_computed - slope_target)**2
    
    @staticmethod
    def positive_constraint(val: torch.Tensor) -> torch.Tensor:
        """Ensure value is positive"""
        return torch.relu(-val + 0.01)**2
    
    @staticmethod
    def crowd_penalty(positions: List[torch.Tensor], tau: float = 0.5) -> torch.Tensor:
        """
        Prevent element collapse (Paper Section 5.3)
        L_crowd = Σ_{i<j} [max(0, τ - ||x_i - x_j||)]²
        """
        loss = torch.tensor(0.0, device=positions[0].device)
        for i in range(len(positions)):
            for j in range(i + 1, len(positions)):
                dist = torch.norm(positions[i] - positions[j])
                loss = loss + torch.relu(tau - dist)**2
        return loss


# =============================================================================
# SDF Renderer (Following Paper Section: Zero-Level Set Visualization)
# =============================================================================

class SDFRenderer:
    """
    Render geometric shapes by visualizing the zero-level set of SDFs.
    The boundary of each shape is where SDF = 0.
    """
    
    def __init__(self, resolution: int = 500, xlim: Tuple[float, float] = (-5, 5),
                 ylim: Tuple[float, float] = (-5, 5)):
        self.resolution = resolution
        self.xlim = xlim
        self.ylim = ylim
        
        # Create grid
        x = torch.linspace(xlim[0], xlim[1], resolution)
        y = torch.linspace(ylim[0], ylim[1], resolution)
        self.xx, self.yy = torch.meshgrid(x, y, indexing='xy')
        self.grid = torch.stack([self.xx, self.yy], dim=-1)  # [H, W, 2]
    
    def render_sdf_field(self, sdf: SDFPrimitive, ax, cmap='RdBu', show_field: bool = True,
                         field_alpha: float = 0.15):
        """
        Render the SDF field and its zero-level set.
        
        Args:
            sdf: The SDF primitive to render
            ax: Matplotlib axis
            cmap: Colormap for the distance field
            show_field: Whether to show the distance field background
            field_alpha: Transparency of the field (0=invisible, 1=opaque). Default 0.15
        """
        with torch.no_grad():
            grid_flat = self.grid.reshape(-1, 2)
            distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
            distances_np = distances.cpu().numpy()
        
        if show_field and field_alpha > 0:
            # Show distance field as background with reduced opacity
            vmax = max(abs(distances_np.min()), abs(distances_np.max()))
            vmax = min(vmax, 5)  # Clamp for visualization
            im = ax.imshow(distances_np.T, extent=[*self.xlim, *self.ylim],
                          origin='lower', cmap=cmap, vmin=-vmax, vmax=vmax, alpha=field_alpha)
        
        # Extract zero-level set (the curve boundary)
        # Note: must use .T to match imshow orientation with indexing='xy'
        ax.contour(self.xx.numpy().T, self.yy.numpy().T, distances_np.T, 
                   levels=[0], colors=['#2E86AB'], linewidths=2.5)
    
    def render_multiple(self, sdfs: List[Tuple[SDFPrimitive, str, str]], ax,
                       show_field: bool = False):
        """
        Render multiple SDFs with different colors.
        
        Args:
            sdfs: List of (sdf, color, label) tuples
        """
        for sdf, color, label in sdfs:
            with torch.no_grad():
                grid_flat = self.grid.reshape(-1, 2)
                distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
                distances_np = distances.cpu().numpy()
            
            # Zero-level set (use .T to match grid orientation)
            cs = ax.contour(self.xx.numpy().T, self.yy.numpy().T, distances_np.T,
                           levels=[0], colors=[color], linewidths=2.5)
    
    def render_line_segment(self, p1: torch.Tensor, p2: torch.Tensor, ax, 
                           color: str = '#E74C3C', thickness: float = 0.025,
                           label: str = None):
        """
        Render a line segment using pure SDF (LineSegmentSDF).
        Uses contourf to fill the region where SDF < thickness, avoiding double lines.
        
        Args:
            p1, p2: Endpoint tensors
            ax: Matplotlib axis
            color: Line color
            thickness: Line thickness (SDF threshold)
            label: Optional label for legend
        """
        segment_sdf = LineSegmentSDF(p1, p2)
        with torch.no_grad():
            grid_flat = self.grid.reshape(-1, 2)
            distances = segment_sdf(grid_flat).reshape(self.resolution, self.resolution)
            distances_np = distances.cpu().numpy()
        
        # Use contourf to fill region where distance < thickness
        # This creates a single solid line instead of two parallel contour lines
        # Note: use .T to match grid orientation with indexing='xy'
        ax.contourf(self.xx.numpy().T, self.yy.numpy().T, distances_np.T,
                   levels=[-1e10, thickness], colors=[color], alpha=1.0)
        
        if label:
            ax.plot([], [], color=color, lw=3, label=label)
    
    def render_triangle(self, v0: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor, ax,
                       edge_color: str = '#E74C3C', fill_color: str = '#FFD700',
                       fill_alpha: float = 0.3, edge_thickness: float = 0.025,
                       edge_labels: List[str] = None):
        """
        Render a triangle using pure SDF.
        Edges are rendered using LineSegmentSDF (contourf), fill using TriangleFillSDF.
        
        Args:
            v0, v1, v2: Vertex tensors
            ax: Matplotlib axis
            edge_color: Color for all edges (or list of 3 colors)
            fill_color: Fill color
            fill_alpha: Fill transparency
            edge_thickness: Edge line thickness (SDF threshold)
            edge_labels: Optional list of 3 labels for edges
        """
        # Render fill using TriangleFillSDF
        fill_sdf = TriangleFillSDF(v0, v1, v2)
        with torch.no_grad():
            grid_flat = self.grid.reshape(-1, 2)
            fill_dist = fill_sdf(grid_flat).reshape(self.resolution, self.resolution)
            fill_np = fill_dist.cpu().numpy()
        
        ax.contourf(self.xx.numpy().T, self.yy.numpy().T, fill_np.T,
                   levels=[-1e10, 0], colors=[fill_color], alpha=fill_alpha)
        
        # Render edges using LineSegmentSDF (contourf for single line)
        edges = [(v0, v1), (v1, v2), (v2, v0)]
        colors = [edge_color] * 3 if isinstance(edge_color, str) else edge_color
        labels = edge_labels if edge_labels else [None, None, None]
        
        for (p1, p2), c, lbl in zip(edges, colors, labels):
            self.render_line_segment(p1, p2, ax, color=c, thickness=edge_thickness, label=lbl)
    
    def render_sdf_filled(self, sdf: SDFPrimitive, ax, color: str = '#FFD700', 
                         alpha: float = 0.3):
        """
        Render the interior region of an SDF (where SDF < 0).
        
        Args:
            sdf: The SDF primitive
            ax: Matplotlib axis
            color: Fill color
            alpha: Fill transparency
        """
        with torch.no_grad():
            grid_flat = self.grid.reshape(-1, 2)
            distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
            distances_np = distances.cpu().numpy()
        
        ax.contourf(self.xx.numpy().T, self.yy.numpy().T, distances_np.T,
                   levels=[-1e10, 0], colors=[color], alpha=alpha)
    
    def render_sdf_zero_level(self, sdf: SDFPrimitive, ax, color: str = '#2E86AB',
                              linewidth: float = 2.5, linestyle: str = '-',
                              label: str = None):
        """
        Render only the zero-level set (SDF = 0) of an SDF.
        
        Args:
            sdf: The SDF primitive
            ax: Matplotlib axis
            color: Contour color
            linewidth: Line width
            linestyle: Line style
            label: Optional label for legend
        """
        with torch.no_grad():
            grid_flat = self.grid.reshape(-1, 2)
            distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
            distances_np = distances.cpu().numpy()
        
        ax.contour(self.xx.numpy().T, self.yy.numpy().T, distances_np.T,
                  levels=[0], colors=[color], linewidths=linewidth, linestyles=linestyle)
        
        if label:
            ax.plot([], [], color=color, lw=linewidth, ls=linestyle, label=label)


# =============================================================================
# Geometry Optimizer (Following Paper Section 5.2)
# =============================================================================

class GeometryOptimizer:
    """
    Optimize geometric parameters to satisfy constraints.
    Uses gradient-based optimization with Adam.
    """
    
    def __init__(self, lr: float = 0.05, max_steps: int = 2000, 
                 convergence_threshold: float = 0.001):
        self.lr = lr
        self.max_steps = max_steps
        self.threshold = convergence_threshold
    
    def optimize(self, sdf: SDFPrimitive, constraints: List[callable],
                weights: List[float] = None, verbose: bool = False) -> Dict:
        """
        Optimize SDF parameters to satisfy constraints.
        
        Args:
            sdf: The SDF primitive with learnable parameters
            constraints: List of constraint functions that return loss values
            weights: Optional weights for each constraint
            verbose: Print optimization progress
            
        Returns:
            Dictionary with optimization results
        """
        if weights is None:
            weights = [1.0] * len(constraints)
        
        optimizer = torch.optim.AdamW(sdf.parameters(), lr=self.lr)
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
            optimizer, T_max=self.max_steps, eta_min=1e-6
        )
        
        history = []
        
        for step in range(self.max_steps):
            optimizer.zero_grad()
            
            # Compute total loss
            total_loss = torch.tensor(0.0)
            constraint_losses = []
            
            for constraint, weight in zip(constraints, weights):
                c_loss = constraint()
                constraint_losses.append(c_loss.item())
                total_loss = total_loss + weight * c_loss
            
            history.append(total_loss.item())
            
            # Check convergence
            if total_loss.item() < self.threshold:
                if verbose:
                    print(f"  Converged at step {step}, loss={total_loss.item():.6f}")
                break
            
            # Backprop and update
            total_loss.backward()
            
            # Gradient clipping for stability
            torch.nn.utils.clip_grad_norm_(sdf.parameters(), max_norm=1.0)
            
            optimizer.step()
            scheduler.step()
            
            if verbose and step % 500 == 0:
                print(f"  Step {step}: loss={total_loss.item():.6f}")
        
        return {
            'final_loss': total_loss.item(),
            'steps': step + 1,
            'converged': total_loss.item() < self.threshold,
            'history': history
        }


# =============================================================================
# Problem Parser
# =============================================================================

class ProblemParser:
    """Parse problem expressions into geometric constraints and SDFs."""
    
    def __init__(self):
        pass
    
    def parse_line(self, fact_expr: str) -> Optional[Dict]:
        """Parse line expression."""
        # Expression(G) = (x + y - 1 = 0) or similar
        match = re.search(r'Expression\(\w+\)\s*=\s*\(([^)]+)\s*=\s*0\)', fact_expr)
        if match:
            expr = match.group(1)
            # Parse ax + by + c = 0 format
            # Try to extract coefficients
            a, b, c = 0.0, 0.0, 0.0
            
            # Match patterns like "x + y - 1" or "2*x - 3*y + 5"
            x_match = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*x', expr)
            y_match = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*y', expr)
            
            if x_match:
                coef = x_match.group(1).replace(' ', '')
                if coef in ['', '+']:
                    a = 1.0
                elif coef == '-':
                    a = -1.0
                else:
                    try:
                        a = float(coef)
                    except:
                        a = 1.0
            
            if y_match:
                coef = y_match.group(1).replace(' ', '')
                if coef in ['', '+']:
                    b = 1.0
                elif coef == '-':
                    b = -1.0
                else:
                    try:
                        b = float(coef)
                    except:
                        b = 1.0
            
            # Find constant term
            const_match = re.search(r'([+-]\s*\d+\.?\d*)\s*(?:=|$)', expr)
            if const_match:
                try:
                    c = float(const_match.group(1).replace(' ', ''))
                except:
                    c = 0.0
            
            if a != 0 or b != 0:
                return {
                    'type': 'line',
                    'a': a,
                    'b': b,
                    'c': c,
                    'equation': expr
                }
        
        # Check for Slope constraint - sqrt format
        slope_match = re.search(r'Slope\(\w+\)\s*=\s*sqrt\((\d+)\)', fact_expr)
        if slope_match:
            slope = np.sqrt(float(slope_match.group(1)))
            return {
                'type': 'line',
                'slope': slope,
                'symbolic': True
            }
        
        # Check for Slope constraint - numeric format
        slope_match = re.search(r'Slope\(\w+\)\s*=\s*([\d.]+)', fact_expr)
        if slope_match:
            return {
                'type': 'line',
                'slope': float(slope_match.group(1)),
                'symbolic': True
            }
        
        return None
    
    def parse_circle(self, fact_expr: str) -> Optional[Dict]:
        """Parse circle expression."""
        
        # Format 1: (x-a)^2 + (y-b)^2 = r^2
        match = re.search(r'Expression\(\w+\)\s*=\s*\(\(x-([^)]+)\)\^2\s*\+\s*\(y-([^)]+)\)\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            return {
                'type': 'circle',
                'center': (float(match.group(1)), float(match.group(2))),
                'radius': np.sqrt(float(match.group(3)))
            }
        
        # Format 2: x^2 + (y-a)^2 = r  (center at origin or on axis)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*\+\s*\(([+-]?\s*\d*\.?\d*)\s*[+-]\s*y\)\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            cy = -float(match.group(1).replace(' ', '')) if match.group(1) else 0.0
            return {
                'type': 'circle',
                'center': (0.0, cy),
                'radius': np.sqrt(float(match.group(2)))
            }
        
        # Format 3: y^2 + (x-a)^2 = r  or  y^2 + (x+a)^2 = r
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*\+\s*\(x\s*([+-])\s*(\d+\.?\d*)\)\^2\s*=\s*(\d+\.?\d*)\)', fact_expr)
        if match:
            sign = -1 if match.group(1) == '-' else 1
            cx = sign * float(match.group(2))
            return {
                'type': 'circle',
                'center': (cx, 0.0),
                'radius': np.sqrt(float(match.group(3)))
            }
        
        # Format 4: x^2 + y^2 = r  (center at origin)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*\+\s*y\^2\s*=\s*(\d+\.?\d*)\)', fact_expr)
        if match:
            return {
                'type': 'circle',
                'center': (0.0, 0.0),
                'radius': np.sqrt(float(match.group(1)))
            }
        
        # Format 5: Check if it's explicitly declared as Circle type
        if re.search(r'\w+:\s*Circle', fact_expr):
            # Try more general patterns
            # (x + a)^2 + (y - b)^2 = r
            match = re.search(r'\(x\s*([+-])\s*(\d+\.?\d*)\)\^2\s*\+\s*\(y\s*([+-])\s*(\d+\.?\d*)\)\^2\s*=\s*(\d+\.?\d*)', fact_expr)
            if match:
                cx = float(match.group(2)) * (-1 if match.group(1) == '+' else 1)
                cy = float(match.group(4)) * (-1 if match.group(3) == '+' else 1)
                return {
                    'type': 'circle',
                    'center': (cx, cy),
                    'radius': np.sqrt(float(match.group(5)))
                }
        
        # Check for circle defined by diameter
        if 'IsDiameter' in fact_expr:
            return {
                'type': 'circle',
                'from_diameter': True
            }
        
        # Check for circle defined by slope product = -1 (perpendicular)
        # Pattern: Slope(LineSegmentOf(P, A)) * Slope(LineSegmentOf(P, B)) = -1
        # This means angle APB = 90°, so P lies on circle with diameter AB
        slope_match = re.search(r'Slope\(LineSegmentOf\(\w+,\s*(\w+)\)\)\s*\*\s*Slope\(LineSegmentOf\(\w+,\s*(\w+)\)\)\s*=\s*-1', fact_expr)
        if slope_match:
            pt1_name = slope_match.group(1)
            pt2_name = slope_match.group(2)
            coords = self.parse_coordinates(fact_expr)
            if pt1_name in coords and pt2_name in coords:
                x1, y1 = coords[pt1_name]
                x2, y2 = coords[pt2_name]
                # Circle with diameter AB: center = midpoint, radius = |AB|/2
                cx = (x1 + x2) / 2
                cy = (y1 + y2) / 2
                radius = np.sqrt((x2 - x1)**2 + (y2 - y1)**2) / 2
                return {
                    'type': 'circle',
                    'center': (cx, cy),
                    'radius': radius,
                    'from_constraints': True
                }
        
        # General circle equation: x^2 + y^2 + Dx + Ey + F = 0
        # Center: (-D/2, -E/2), Radius: sqrt(D²/4 + E²/4 - F)
        # Pattern: ax^2 + by^2 + Dx + Ey + F = 0 where coefficients can vary
        general_match = re.search(r'Expression\(\w+\)\s*=\s*\(([^)]+x\^2[^)]+y\^2[^)]+)\s*=\s*0\)', fact_expr)
        if general_match and 'Circle' in fact_expr:
            expr = general_match.group(1)
            # Parse coefficients: D*x, E*y, F (constant)
            D = E = F = 0.0
            
            # Find coefficient of x (not x^2)
            d_match = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*x(?!\^)', expr)
            if d_match:
                d_str = d_match.group(1).replace(' ', '')
                D = float(d_str) if d_str and d_str not in ['+', '-'] else (1.0 if d_str == '+' or d_str == '' else -1.0)
            
            # Find coefficient of y (not y^2)
            e_match = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*y(?!\^)', expr)
            if e_match:
                e_str = e_match.group(1).replace(' ', '')
                E = float(e_str) if e_str and e_str not in ['+', '-'] else (1.0 if e_str == '+' or e_str == '' else -1.0)
            
            # Find constant term
            const_match = re.search(r'([+-]\s*\d+\.?\d*)\s*(?:=|$)', expr)
            if const_match:
                f_str = const_match.group(1).replace(' ', '')
                F = float(f_str)
            
            cx = -D / 2
            cy = -E / 2
            r_sq = D**2 / 4 + E**2 / 4 - F
            if r_sq > 0:
                return {
                    'type': 'circle',
                    'center': (cx, cy),
                    'radius': np.sqrt(r_sq),
                    'from_constraints': True
                }
        
        # Shifted center circle: (x+h)^2 + y^2 = r^2 or (x-h)^2 + y^2 = r^2
        shifted_match = re.search(r'Expression\(\w+\)\s*=\s*\(\(x([+-])(\d+\.?\d*)\)\^2\s*\+\s*y\^2\s*=\s*(\d+\.?\d*)\)', fact_expr)
        if shifted_match:
            sign = shifted_match.group(1)
            h = float(shifted_match.group(2))
            r_sq = float(shifted_match.group(3))
            cx = -h if sign == '+' else h
            return {
                'type': 'circle',
                'center': (cx, 0.0),
                'radius': np.sqrt(r_sq),
            }
        
        # (x±h)^2 + (y±k)^2 = r^2
        shifted_match2 = re.search(r'Expression\(\w+\)\s*=\s*\(\(x([+-])(\d+\.?\d*)\)\^2\s*\+\s*\(y([+-])(\d+\.?\d*)\)\^2\s*=\s*(\d+\.?\d*)\)', fact_expr)
        if shifted_match2:
            sign_x = shifted_match2.group(1)
            h = float(shifted_match2.group(2))
            sign_y = shifted_match2.group(3)
            k = float(shifted_match2.group(4))
            r_sq = float(shifted_match2.group(5))
            cx = -h if sign_x == '+' else h
            cy = -k if sign_y == '+' else k
            return {
                'type': 'circle',
                'center': (cx, cy),
                'radius': np.sqrt(r_sq),
            }
        
        return None
    
    def parse_ellipse(self, fact_expr: str) -> Optional[Dict]:
        """Parse ellipse expression and return parameters."""
        # x^2/a + y^2/b = 1
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2/(\d+)\s*\+\s*y\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            x_coef = float(match.group(1))
            y_coef = float(match.group(2))
            return {
                'type': 'ellipse',
                'x_coef': x_coef,
                'y_coef': y_coef,
                'a': np.sqrt(max(x_coef, y_coef)),
                'b': np.sqrt(min(x_coef, y_coef)),
                'major_axis': 'x' if x_coef > y_coef else 'y'
            }
        
        # y^2/b + x^2/a = 1
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2/(\d+)\s*\+\s*x\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            y_coef = float(match.group(1))
            x_coef = float(match.group(2))
            return {
                'type': 'ellipse',
                'x_coef': x_coef,
                'y_coef': y_coef,
                'a': np.sqrt(max(x_coef, y_coef)),
                'b': np.sqrt(min(x_coef, y_coef)),
                'major_axis': 'x' if x_coef > y_coef else 'y'
            }
        
        # x^2/a + y^2 = 1 (y has coefficient 1, x has numeric denominator)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2/(\d+)\s*\+\s*y\^2\s*=\s*1\)', fact_expr)
        if match:
            x_coef = float(match.group(1))
            y_coef = 1.0
            return {
                'type': 'ellipse',
                'x_coef': x_coef,
                'y_coef': y_coef,
                'a': np.sqrt(x_coef),  # a > b since x_coef > 1
                'b': 1.0,
                'major_axis': 'x'
            }
        
        # y^2/a + x^2 = 1 (x has coefficient 1, y has numeric denominator)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2/(\d+)\s*\+\s*x\^2\s*=\s*1\)', fact_expr)
        if match:
            y_coef = float(match.group(1))
            x_coef = 1.0
            return {
                'type': 'ellipse',
                'x_coef': x_coef,
                'y_coef': y_coef,
                'a': np.sqrt(y_coef),  # a > b since y_coef > 1
                'b': 1.0,
                'major_axis': 'y'
            }
        
        # y^2 + x^2/k^2 = 1 (y has coefficient 1)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*\+\s*x\^2/\w+\^?2?\s*=\s*1\)', fact_expr)
        if match:
            return {
                'type': 'ellipse',
                'x_coef': 4.0,  # default
                'y_coef': 1.0,
                'a': 2.0,
                'b': 1.0,
                'major_axis': 'x',
                'symbolic': True
            }
        
        # x^2 + y^2/k^2 = 1
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*\+\s*y\^2/\w+\^?2?\s*=\s*1\)', fact_expr)
        if match:
            return {
                'type': 'ellipse',
                'x_coef': 1.0,
                'y_coef': 4.0,  # default
                'a': 2.0,
                'b': 1.0,
                'major_axis': 'y',
                'symbolic': True
            }
        
        # Ellipse with symbolic: y^2/b^2 + x^2/a^2 = 1 or x^2/a^2 + y^2/b^2 = 1
        if re.search(r'Expression\(\w+\)\s*=\s*\([xy]\^2/\w+\^?2?\s*\+\s*[xy]\^2/\w+\^?2?\s*=\s*1\)', fact_expr):
            return {
                'type': 'ellipse',
                'x_coef': 4.0,
                'y_coef': 3.0,
                'a': 2.0,
                'b': np.sqrt(3),
                'major_axis': 'x',
                'symbolic': True
            }
        
        # x^2 + N*y^2 = M (ellipse: x²/M + y²/(M/N) = 1)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*\+\s*(\d+)\*y\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            n = float(match.group(1))
            m = float(match.group(2))
            a_sq = m  # x coefficient
            b_sq = m / n  # y coefficient
            a = np.sqrt(max(a_sq, b_sq))
            b = np.sqrt(min(a_sq, b_sq))
            return {
                'type': 'ellipse',
                'x_coef': a_sq,
                'y_coef': b_sq,
                'a': a,
                'b': b,
                'major_axis': 'x' if a_sq >= b_sq else 'y'
            }
        
        # N*x^2 + y^2 = M (ellipse: x²/(M/N) + y²/M = 1)
        match = re.search(r'Expression\(\w+\)\s*=\s*\((\d+)\*x\^2\s*\+\s*y\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            n = float(match.group(1))
            m = float(match.group(2))
            a_sq = m / n  # x coefficient
            b_sq = m  # y coefficient
            a = np.sqrt(max(a_sq, b_sq))
            b = np.sqrt(min(a_sq, b_sq))
            return {
                'type': 'ellipse',
                'x_coef': a_sq,
                'y_coef': b_sq,
                'a': a,
                'b': b,
                'major_axis': 'x' if a_sq >= b_sq else 'y'
            }
        
        # Check for Ellipse with geometric constraints (no explicit expression)
        if 'Ellipse' in fact_expr:
            coords = self.parse_coordinates(fact_expr)
            eccentricity = self.parse_eccentricity(fact_expr)
            
            c = None
            major_axis = 'x'  # default
            
            # Try to find focus coordinate from various patterns
            # Pattern 1: Coordinate(F) = (c, 0); RightFocus(G) = F
            for name, (fx, fy) in coords.items():
                if f'RightFocus(' in fact_expr and f') = {name}' in fact_expr:
                    c = abs(fx)
                    major_axis = 'x'
                    break
                elif f'LeftFocus(' in fact_expr and f') = {name}' in fact_expr:
                    c = abs(fx)
                    major_axis = 'x'
                    break
                elif f'UpperFocus(' in fact_expr and f') = {name}' in fact_expr:
                    c = abs(fy)
                    major_axis = 'y'
                    break
                elif f'LowerFocus(' in fact_expr and f') = {name}' in fact_expr:
                    c = abs(fy)
                    major_axis = 'y'
                    break
            
            # Pattern 2: Coordinate(OneOf(Focus(...)))
            if c is None:
                focus_match = re.search(r'Coordinate\(OneOf\(Focus\(\w+\)\)\)\s*=\s*\(([^,]+),\s*([^)]+)\)', fact_expr)
                if focus_match:
                    try:
                        fx = float(focus_match.group(1).strip())
                        fy = float(focus_match.group(2).strip())
                        c = abs(fx) if abs(fy) < 0.01 else abs(fy)
                        major_axis = 'x' if abs(fy) < 0.01 else 'y'
                    except:
                        pass
            
            # Pattern 2b: Two foci with explicit coordinates: Focus(G) = {F1, F2}
            if c is None:
                foci_match = re.search(r'Focus\(\w+\)\s*=\s*\{(\w+),\s*(\w+)\}', fact_expr)
                if foci_match:
                    f1_name = foci_match.group(1)
                    f2_name = foci_match.group(2)
                    if f1_name in coords and f2_name in coords:
                        fx1, fy1 = coords[f1_name]
                        fx2, fy2 = coords[f2_name]
                        # c = half the distance between foci
                        c = np.sqrt((fx2 - fx1)**2 + (fy2 - fy1)**2) / 2
                        major_axis = 'x' if abs(fy1) < 0.01 else 'y'
            
            # Pattern 3: PointOnCurve(Focus(G), xAxis) - focus on x-axis
            if c is None and 'PointOnCurve(Focus(' in fact_expr:
                if 'xAxis' in fact_expr:
                    major_axis = 'x'
                elif 'yAxis' in fact_expr:
                    major_axis = 'y'
            
            # Pattern 4: Length(MajorAxis(G)) = k * Length(MinorAxis(G))
            axis_ratio = None
            ratio_match = re.search(r'Length\(MajorAxis\(\w+\)\)\s*=\s*(\d+)\s*\*\s*Length\(MinorAxis', fact_expr)
            if ratio_match:
                axis_ratio = float(ratio_match.group(1))
            
            # Pattern 5: Length(MinorAxis(G)) = N or Length(MinorAxis(G)) = 2*sqrt(N)
            minor_axis_len = None
            match = re.search(r'Length\(MinorAxis\(\w+\)\)\s*=\s*2\*sqrt\((\d+)\)', fact_expr)
            if match:
                minor_axis_len = 2 * np.sqrt(float(match.group(1)))
            else:
                match = re.search(r'Length\(MinorAxis\(\w+\)\)\s*=\s*(\d+)', fact_expr)
                if match:
                    minor_axis_len = float(match.group(1))
            
            # Pattern 6: Length(MajorAxis(G)) = N
            major_axis_len = None
            match = re.search(r'Length\(MajorAxis\(\w+\)\)\s*=\s*2\*sqrt\((\d+)\)', fact_expr)
            if match:
                major_axis_len = 2 * np.sqrt(float(match.group(1)))
            else:
                match = re.search(r'Length\(MajorAxis\(\w+\)\)\s*=\s*(\d+)', fact_expr)
                if match:
                    major_axis_len = float(match.group(1))
            
            # Pattern 7: FocalLength(G) = N or 2*c = N
            focal_length = None
            match = re.search(r'FocalLength\(\w+\)\s*=\s*(\d+)', fact_expr)
            if match:
                focal_length = float(match.group(1))
            else:
                match = re.search(r'2\*c\s*=\s*(\d+)', fact_expr)
                if match:
                    focal_length = float(match.group(1))
            
            # Case: c from FocalLength + b from MinorAxis
            if c is None and focal_length:
                c = focal_length / 2
            
            # Case: b from MinorAxis length
            if minor_axis_len:
                b_from_minor = minor_axis_len / 2
                if c is not None:
                    a = np.sqrt(c**2 + b_from_minor**2)
                    b = b_from_minor
                    
            # Case: a from MajorAxis length
            if major_axis_len:
                a_from_major = major_axis_len / 2
                if c is not None:
                    a = a_from_major
                    b = np.sqrt(a**2 - c**2) if a > c else None
            
            # Compute a, b from constraints
            a, b = None, None
            
            # Case 1: c and eccentricity known → a = c/e, b = sqrt(a² - c²)
            if c is not None and eccentricity and 0 < eccentricity < 1:
                a = c / eccentricity
                b = np.sqrt(a**2 - c**2)
            
            # Case 2: eccentricity known + axis ratio → solve for a, b
            elif eccentricity and 0 < eccentricity < 1 and axis_ratio:
                # a/b = axis_ratio, e = sqrt(1 - b²/a²) = sqrt(1 - 1/ratio²)
                # This gives us the ratio, need another constraint for absolute size
                a = 2.0 * axis_ratio  # default size
                b = 2.0
            
            # Case 3: axis ratio + point on curve
            elif axis_ratio:
                # Find a point on curve and solve
                for name, (px, py) in coords.items():
                    if f'PointOnCurve({name}' in fact_expr:
                        # x²/a² + y²/b² = 1, a = ratio * b
                        # x²/(ratio*b)² + y²/b² = 1
                        # x²/ratio² + y² = b²
                        b_sq = px**2 / axis_ratio**2 + py**2
                        if b_sq > 0:
                            b = np.sqrt(b_sq)
                            a = axis_ratio * b
                            break
            
            # Case 4: Two points on ellipse → solve for a, b
            if a is None:
                points_on_curve = []
                for name, (px, py) in coords.items():
                    if f'PointOnCurve({name}' in fact_expr and name not in ['F', 'F1', 'F2']:
                        points_on_curve.append((px, py))
                
                if len(points_on_curve) >= 2:
                    # x1²/a² + y1²/b² = 1
                    # x2²/a² + y2²/b² = 1
                    p1, p2 = points_on_curve[0], points_on_curve[1]
                    x1, y1 = p1
                    x2, y2 = p2
                    
                    # Solve: let u = 1/a², v = 1/b²
                    # x1²u + y1²v = 1
                    # x2²u + y2²v = 1
                    det = x1**2 * y2**2 - x2**2 * y1**2
                    if abs(det) > 1e-10:
                        u = (y2**2 - y1**2) / det
                        v = (x1**2 - x2**2) / det
                        if u > 0 and v > 0:
                            a_sq = 1 / u
                            b_sq = 1 / v
                            a = np.sqrt(max(a_sq, b_sq))
                            b = np.sqrt(min(a_sq, b_sq))
                            major_axis = 'x' if a_sq >= b_sq else 'y'
            
            # Return if we have valid a, b
            if a is not None and b is not None and a > 0 and b > 0:
                return {
                    'type': 'ellipse',
                    'x_coef': a**2 if major_axis == 'x' else b**2,
                    'y_coef': b**2 if major_axis == 'x' else a**2,
                    'a': a,
                    'b': b,
                    'major_axis': major_axis,
                    'from_constraints': True
                }
        
        return None
    
    def parse_hyperbola(self, fact_expr: str, main_conic_name: str = None) -> Optional[Dict]:
        """Parse hyperbola expression.
        
        Args:
            fact_expr: The fact expression string
            main_conic_name: If provided, only match Expression(main_conic_name) = ...
                           This avoids matching secondary hyperbola expressions.
        """
        # Build regex prefix based on main_conic_name
        if main_conic_name:
            expr_prefix = rf'Expression\({re.escape(main_conic_name)}\)\s*=\s*\('
        else:
            expr_prefix = r'Expression\(\w+\)\s*=\s*\('
        
        # Horizontal: x^2/a - y^2/b = 1
        match = re.search(expr_prefix + r'x\^2/(\d+)\s*-\s*y\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            a_sq = float(match.group(1))
            b_sq = float(match.group(2))
            return {
                'type': 'hyperbola',
                'a': np.sqrt(a_sq),
                'b': np.sqrt(b_sq),
                'a_squared': a_sq,
                'b_squared': b_sq,
                'orientation': 'horizontal'
            }
        
        # Vertical: y^2/a - x^2/b = 1
        match = re.search(expr_prefix + r'y\^2/(\d+)\s*-\s*x\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            a_sq = float(match.group(1))
            b_sq = float(match.group(2))
            return {
                'type': 'hyperbola',
                'a': np.sqrt(a_sq),
                'b': np.sqrt(b_sq),
                'a_squared': a_sq,
                'b_squared': b_sq,
                'orientation': 'vertical'
            }
        
        # Horizontal: x^2/a - y^2 = 1 (b=1)
        match = re.search(expr_prefix + r'x\^2/(\d+)\s*-\s*y\^2\s*=\s*1\)', fact_expr)
        if match:
            a_sq = float(match.group(1))
            return {
                'type': 'hyperbola',
                'a': np.sqrt(a_sq),
                'b': 1.0,
                'a_squared': a_sq,
                'b_squared': 1.0,
                'orientation': 'horizontal'
            }
        
        # x^2 - y^2 = 1
        if re.search(expr_prefix + r'x\^2\s*-\s*y\^2\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 1.0,
                'b': 1.0,
                'a_squared': 1.0,
                'b_squared': 1.0,
                'orientation': 'horizontal'
            }
        
        # Horizontal: x^2 - y^2/b = 1 (a=1, b^2 = b_val)
        match = re.search(expr_prefix + r'x\^2\s*-\s*y\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            b_sq = float(match.group(1))
            return {
                'type': 'hyperbola',
                'a': 1.0,
                'b': np.sqrt(b_sq),
                'a_squared': 1.0,
                'b_squared': b_sq,
                'orientation': 'horizontal'
            }
        
        # x^2 - y^2 = N (divide by N to normalize: x²/N - y²/N = 1)
        match = re.search(expr_prefix + r'x\^2\s*-\s*y\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            n = float(match.group(1))
            a = np.sqrt(n)
            return {
                'type': 'hyperbola',
                'a': a,
                'b': a,
                'a_squared': n,
                'b_squared': n,
                'orientation': 'horizontal'
            }
        
        # x^2 - N*y^2 = M (x²/M - y²/(M/N) = 1)
        match = re.search(expr_prefix + r'x\^2\s*-\s*(\d+)\*y\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            n = float(match.group(1))
            m = float(match.group(2))
            a_sq = m
            b_sq = m / n
            return {
                'type': 'hyperbola',
                'a': np.sqrt(a_sq),
                'b': np.sqrt(b_sq),
                'a_squared': a_sq,
                'b_squared': b_sq,
                'orientation': 'horizontal'
            }
        
        # N*x^2 - M*y^2 = K (x²/(K/N) - y²/(K/M) = 1)
        match = re.search(expr_prefix + r'(\d+)\*x\^2\s*-\s*(\d+)\*y\^2\s*=\s*(\d+)\)', fact_expr)
        if match:
            n = float(match.group(1))
            m = float(match.group(2))
            k = float(match.group(3))
            a_sq = k / n
            b_sq = k / m
            return {
                'type': 'hyperbola',
                'a': np.sqrt(a_sq),
                'b': np.sqrt(b_sq),
                'a_squared': a_sq,
                'b_squared': b_sq,
                'orientation': 'horizontal'
            }
        
        # x^2/a - y^2/b = -1 → y^2/b - x^2/a = 1 (vertical hyperbola)
        match = re.search(expr_prefix + r'x\^2/(\d+)\s*-\s*y\^2/(\d+)\s*=\s*-1\)', fact_expr)
        if match:
            a_sq = float(match.group(1))  # becomes b² for vertical
            b_sq = float(match.group(2))  # becomes a² for vertical
            return {
                'type': 'hyperbola',
                'a': np.sqrt(b_sq),
                'b': np.sqrt(a_sq),
                'a_squared': b_sq,
                'b_squared': a_sq,
                'orientation': 'vertical'
            }
        
        # x^2-y^2/N=1 (no spaces) - horizontal
        match = re.search(expr_prefix + r'x\^2-y\^2/(\d+)=1\)', fact_expr)
        if match:
            b_sq = float(match.group(1))
            return {
                'type': 'hyperbola',
                'a': 1.0,
                'b': np.sqrt(b_sq),
                'a_squared': 1.0,
                'b_squared': b_sq,
                'orientation': 'horizontal'
            }
        
        # Vertical: y^2 - x^2/a = 1 (b=1 in standard form, here y² term positive)
        match = re.search(expr_prefix + r'y\^2\s*-\s*x\^2/(\d+)\s*=\s*1\)', fact_expr)
        if match:
            b_sq = float(match.group(1))
            return {
                'type': 'hyperbola',
                'a': 1.0,  # For vertical hyperbola y²/a² - x²/b² = 1, a=1
                'b': np.sqrt(b_sq),
                'a_squared': 1.0,
                'b_squared': b_sq,
                'orientation': 'vertical'
            }
        
        # y^2 - x^2 = 1 (vertical hyperbola, a=1, b=1)
        if re.search(expr_prefix + r'y\^2\s*-\s*x\^2\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 1.0,
                'b': 1.0,
                'a_squared': 1.0,
                'b_squared': 1.0,
                'orientation': 'vertical'
            }
        
        # Vertical symbolic: -x^2/b^2 + y^2/a^2 = 1
        if re.search(expr_prefix + r'-x\^2/\w+\^?2?\s*\+\s*y\^2/\w+\^?2?\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 2.0,  # default
                'b': 1.5,  # default
                'a_squared': 4.0,
                'b_squared': 2.25,
                'symbolic': True,
                'orientation': 'vertical'
            }
        
        # Vertical symbolic: y^2/a^2 - x^2/b^2 = 1
        if re.search(expr_prefix + r'y\^2/\w+\^?2?\s*-\s*x\^2/\w+\^?2?\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 2.0,  # default
                'b': 1.5,  # default
                'a_squared': 4.0,
                'b_squared': 2.25,
                'symbolic': True,
                'orientation': 'vertical'
            }
        
        # Horizontal symbolic: x^2/a^2 - y^2/b^2 = 1
        if re.search(expr_prefix + r'x\^2/\w+\^?2?\s*-\s*y\^2/\w+\^?2?\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 2.0,  # default
                'b': 1.5,  # default
                'a_squared': 4.0,
                'b_squared': 2.25,
                'symbolic': True,
                'orientation': 'horizontal'
            }
        
        # Horizontal symbolic: -y^2/b^2 + x^2/a^2 = 1
        if re.search(expr_prefix + r'-y\^2/\w+\^?2?\s*\+\s*x\^2/\w+\^?2?\s*=\s*1\)', fact_expr):
            return {
                'type': 'hyperbola',
                'a': 2.0,  # default
                'b': 1.5,  # default
                'a_squared': 4.0,
                'b_squared': 2.25,
                'symbolic': True,
                'orientation': 'horizontal'
            }
        
        # Check for hyperbola type with asymptote/focus constraints (no explicit expression)
        if 'Hyperbola' in fact_expr:
            # Extract constraints
            asymptote = self.parse_asymptote_slope(fact_expr)
            coords = self.parse_coordinates(fact_expr)
            focus_coords = [(n, c) for n, c in coords.items() if 'F' in n]
            
            if asymptote or len(focus_coords) >= 2:
                # Calculate a and b from constraints
                if len(focus_coords) >= 2:
                    f1, f2 = focus_coords[0][1], focus_coords[1][1]
                    c = abs(f1[0] - f2[0]) / 2 if f1[1] == f2[1] == 0 else 3.0
                else:
                    c = 3.0
                
                if asymptote:
                    # b/a = asymptote, c² = a² + b²
                    # Let a be found from c and asymptote
                    # c² = a² + (a*slope)² = a²(1 + slope²)
                    a = c / np.sqrt(1 + asymptote**2)
                    b = a * asymptote
                else:
                    a = c / np.sqrt(2)
                    b = a
                
                return {
                    'type': 'hyperbola',
                    'a': a,
                    'b': b,
                    'a_squared': a**2,
                    'b_squared': b**2,
                    'from_constraints': True,
                    'orientation': 'horizontal'  # Default, focus on x-axis
                }
        
        return None
    
    def parse_parabola(self, fact_expr: str) -> Optional[Dict]:
        """Parse parabola expression."""
        # y^2 = 4x, y^2 = 2*p*x, etc.
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*(\d+)\*x\)', fact_expr)
        if match:
            coef = float(match.group(1))
            return {
                'type': 'parabola',
                'p': coef / 4,  # 4p = coef
                'direction': 'right'
            }
        
        # x^2 = 4y, x^2 = 2*p*y
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*(\d+)\*y\)', fact_expr)
        if match:
            coef = float(match.group(1))
            return {
                'type': 'parabola',
                'p': coef / 4,
                'direction': 'up'
            }
        
        # x^2 = -Ny (downward opening)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*-(\d+)\*y\)', fact_expr)
        if match:
            coef = float(match.group(1))
            return {
                'type': 'parabola',
                'p': coef / 4,
                'direction': 'down'
            }
        
        # x^2 = y/N (small opening upward)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*y/(\d+)\)', fact_expr)
        if match:
            divisor = float(match.group(1))
            return {
                'type': 'parabola',
                'p': 1 / (4 * divisor),
                'direction': 'up'
            }
        
        # y = -x^2/N (downward parabola in vertex form)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\s*=\s*-x\^2/(\d+)\)', fact_expr)
        if match:
            divisor = float(match.group(1))
            # y = -x²/N → x² = -Ny → 4p = N → p = N/4
            return {
                'type': 'parabola',
                'p': divisor / 4,
                'direction': 'down'
            }
        
        # y = x^2/N (upward parabola in vertex form)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\s*=\s*x\^2/(\d+)\)', fact_expr)
        if match:
            divisor = float(match.group(1))
            # y = x²/N → x² = Ny → 4p = N → p = N/4
            return {
                'type': 'parabola',
                'p': divisor / 4,
                'direction': 'up'
            }
        
        # y^2 = p*x (symbolic p, single coefficient)
        if re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*\w+\*x\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,  # Default, will be optimized
                'direction': 'right',
                'symbolic': True
            }
        
        # x^2 = p*y (symbolic p, single coefficient)
        if re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*\w+\*y\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,
                'direction': 'up',
                'symbolic': True
            }
        
        # y^2 = 2*(p*x)
        if re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*2\*\(\w+\*x\)\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,  # Default, will be optimized
                'direction': 'right',
                'symbolic': True
            }
        
        # x^2 = 2*(p*y)
        if re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*2\*\(\w+\*y\)\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,
                'direction': 'up',
                'symbolic': True
            }
        
        # y = 2*x^2 or y = a*x^2 (vertex form)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\s*=\s*(\d*)\*?x\^2\)', fact_expr)
        if match:
            coef = match.group(1)
            a = float(coef) if coef else 1.0
            return {
                'type': 'parabola',
                'p': 1 / (4 * a),
                'direction': 'up'
            }
        
        # y = x^2/8 (division form)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\s*=\s*x\^2/(\d+)\)', fact_expr)
        if match:
            divisor = float(match.group(1))
            return {
                'type': 'parabola',
                'p': divisor / 4,
                'direction': 'up'
            }
        
        # y^2 = -8*x (left opening)
        match = re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*-(\d+)\*x\)', fact_expr)
        if match:
            coef = float(match.group(1))
            return {
                'type': 'parabola',
                'p': coef / 4,
                'direction': 'left'
            }
        
        # y^2 = 2*p*x (symbolic p) - parabola opening right
        if re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*2\*p\*x\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,  # Default, will be optimized
                'direction': 'right',
                'symbolic': True
            }
        
        # x^2 = 2*p*y (symbolic p) - parabola opening up
        if re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*2\*p\*y\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 1.0,  # Default, will be optimized
                'direction': 'up',
                'symbolic': True
            }
        
        # y^2 = x (p = 1/4, so 4p = 1) - parabola opening right
        if re.search(r'Expression\(\w+\)\s*=\s*\(y\^2\s*=\s*x\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 0.25,  # y^2 = 4px, so 4p = 1, p = 0.25
                'direction': 'right'
            }
        
        # x^2 = y (p = 1/4) - parabola opening up
        if re.search(r'Expression\(\w+\)\s*=\s*\(x\^2\s*=\s*y\)', fact_expr):
            return {
                'type': 'parabola',
                'p': 0.25,
                'direction': 'up'
            }
        
        # Check for Parabola type with geometric constraints
        if 'Parabola' in fact_expr:
            coords = self.parse_coordinates(fact_expr)
            
            # Determine direction from constraints
            direction = None
            if 'PointOnCurve(Focus(' in fact_expr:
                if 'xAxis' in fact_expr:
                    direction = 'right'  # Focus on x-axis → horizontal parabola
                elif 'yAxis' in fact_expr:
                    direction = 'up'  # Focus on y-axis → vertical parabola
            
            # Check for vertex at origin
            vertex_at_origin = 'Vertex(' in fact_expr and 'Origin' in fact_expr
            
            # Try to find p from point on curve + distance to focus
            # Pattern: Distance(P, Focus(G)) = d
            dist_match = re.search(r'Distance\((\w+),\s*Focus\(\w+\)\)\s*=\s*(\d+)', fact_expr)
            if dist_match and vertex_at_origin:
                pt_name = dist_match.group(1)
                dist_val = float(dist_match.group(2))
                if pt_name in coords:
                    px, py = coords[pt_name]
                    # For parabola y² = 4px with vertex at origin:
                    # Distance from point to focus = |x + p|
                    # For right-opening: focus at (p, 0), dist = sqrt((x-p)² + y²)
                    # We can solve for p
                    if direction == 'right':
                        # dist² = (px - p)² + py²
                        # y² = 4px → py² = 4p*px
                        # Substitute: dist² = (px - p)² + 4p*px
                        # dist² = px² - 2*px*p + p² + 4p*px = px² + 2*px*p + p² = (px + p)²
                        # So dist = |px + p|, p = dist - px (assuming px > 0)
                        p = (dist_val - px) if px >= 0 else (dist_val + px)
                        if p > 0:
                            return {
                                'type': 'parabola',
                                'p': p,
                                'direction': 'right',
                                'from_constraints': True
                            }
                    elif direction == 'up':
                        p = (dist_val - py) if py >= 0 else (dist_val + py)
                        if p > 0:
                            return {
                                'type': 'parabola',
                                'p': p,
                                'direction': 'up',
                                'from_constraints': True
                            }
            
            # Look for focus coordinate in coords
            for name, (px, py) in coords.items():
                # If this is a focus (F in name) or explicitly marked as focus
                if 'F' in name and (f'Focus(' in fact_expr):
                    if abs(py) < 0.01:  # Focus on x-axis
                        return {
                            'type': 'parabola',
                            'p': abs(px),  # Focus at (p, 0)
                            'direction': 'right' if px > 0 else 'left',
                            'from_constraints': True
                        }
                    elif abs(px) < 0.01:  # Focus on y-axis
                        return {
                            'type': 'parabola',
                            'p': abs(py),
                            'direction': 'up' if py > 0 else 'down',
                            'from_constraints': True
                        }
            
            # Default: parabola with vertex at origin, direction from constraints
            if vertex_at_origin and direction:
                return {
                    'type': 'parabola',
                    'p': 1.0,  # Default, will be optimized
                    'direction': direction,
                    'symbolic': True
                }
        
        return None
    
    def parse_coordinates(self, fact_expr: str) -> Dict[str, Tuple[float, float]]:
        """Extract point coordinates."""
        coords = {}
        # Use a more robust pattern that handles nested parentheses
        # Match: Coordinate(Name) = (x_expr, y_expr)
        # Find all Coordinate(...) = (...) patterns
        coord_pattern = r'Coordinate\((\w+)\)\s*=\s*\(([^;]+)\)'
        for match in re.finditer(coord_pattern, fact_expr):
            name = match.group(1)
            coord_str = match.group(2)
            
            # Split by comma, but handle nested parentheses
            depth = 0
            parts = []
            current = ""
            for char in coord_str:
                if char == '(':
                    depth += 1
                    current += char
                elif char == ')':
                    depth -= 1
                    current += char
                elif char == ',' and depth == 0:
                    parts.append(current.strip())
                    current = ""
                else:
                    current += char
            parts.append(current.strip())
            
            if len(parts) >= 2:
                try:
                    x = parts[0].replace('sqrt', 'np.sqrt').replace('^', '**')
                    y = parts[1].replace('sqrt', 'np.sqrt').replace('^', '**')
                    x_val = float(eval(x, {"np": np, "__builtins__": {}}))
                    y_val = float(eval(y, {"np": np, "__builtins__": {}}))
                    coords[name] = (x_val, y_val)
                except:
                    pass
        return coords
    
    def parse_eccentricity(self, fact_expr: str) -> Optional[float]:
        """Extract eccentricity constraint."""
        # sqrt pattern
        match = re.search(r'Eccentricity\(\w+\)\s*=\s*sqrt\((\d+)\)', fact_expr)
        if match:
            return np.sqrt(float(match.group(1)))
        
        # Fraction pattern (MUST be checked BEFORE decimal pattern!)
        match = re.search(r'Eccentricity\(\w+\)\s*=\s*(\d+)/(\d+)', fact_expr)
        if match:
            return float(match.group(1)) / float(match.group(2))
        
        # Simple decimal pattern
        match = re.search(r'Eccentricity\(\w+\)\s*=\s*([\d.]+)', fact_expr)
        if match:
            return float(match.group(1))
        
        return None
    
    def parse_asymptote_slope(self, fact_expr: str) -> Optional[float]:
        """Extract asymptote slope for hyperbola.
        
        Supports patterns like:
        - y = sqrt(2)*x
        - y = pm*sqrt(2)*x  
        - y = pm*(sqrt(2)/2)*x or y = pm*(sqrt(2)/2)*X
        - y = 4/3*x
        - y = pm*3*x
        - y = pm*(sqrt(2)*x)
        """
        # Pattern: y = sqrt(N)*x
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*sqrt\((\d+)\)\*[xX]\)', fact_expr)
        if match:
            return np.sqrt(float(match.group(1)))
        
        # Pattern: y = pm*sqrt(N)*x or y = pm*(sqrt(N)*x)
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*pm\*\(?sqrt\((\d+)\)\*?[xX]\)?', fact_expr)
        if match:
            return np.sqrt(float(match.group(1)))
        
        # Pattern: y = pm*(sqrt(N)/M)*x (e.g., sqrt(2)/2)
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*pm\*\(sqrt\((\d+)\)/(\d+)\)\*[xX]\)', fact_expr)
        if match:
            return np.sqrt(float(match.group(1))) / float(match.group(2))
        
        # Pattern: y = A/B*x (fraction slope)
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*(\d+)/(\d+)\*[xX]\)', fact_expr)
        if match:
            return float(match.group(1)) / float(match.group(2))
        
        # Pattern: y = pm*N*x (integer slope)
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*pm\*(\d+)\*[xX]\)', fact_expr)
        if match:
            return float(match.group(1))
        
        # Pattern: y = N*x (simple integer slope)
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*(\d+)\*[xX]\)', fact_expr)
        if match:
            return float(match.group(1))
        
        # Pattern: pm*A*y+B*x=0 → y = ±(B/A)*x, slope = B/A
        match = re.search(r'Asymptote.*?=\s*\(pm\*(\d+)\*y\+(\d+)\*x=0\)', fact_expr)
        if match:
            a = float(match.group(1))
            b = float(match.group(2))
            return b / a
        
        # Pattern: pm*(A/B)*x or y = pm*(A/B)*x
        match = re.search(r'Asymptote.*?=\s*\(y\s*=\s*pm\*\((\d+)/(\d+)\)\*[xX]\)', fact_expr)
        if match:
            return float(match.group(1)) / float(match.group(2))
        
        return None


# =============================================================================
# Main Batch Processor
# =============================================================================

class SDFBatchProcessor:
    """
    Process problems using the SDF methodology.
    """
    
    def __init__(self, output_dir: str = 'sdf_output'):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True, parents=True)
        
        self.parser = ProblemParser()
        self.optimizer = GeometryOptimizer()
        
        # Create subdirectories
        for subdir in ['ellipse', 'hyperbola', 'parabola', 'circle']:
            (self.output_dir / subdir).mkdir(exist_ok=True)
    
    def process_problem(self, problem: Dict, idx: int, verbose: bool = False) -> Dict:
        """Process a single problem using SDF methodology."""
        result = {
            'index': idx,
            'success': False,
            'error': None
        }
        
        try:
            fact_expr = problem.get('fact_expressions', '')
            text = problem.get('text', '')
            query_expr = problem.get('query_expressions', '')
            
            # Determine the primary shape to visualize based on query
            # If query is about Expression(G), find what G is
            primary_shape = None
            query_match = re.search(r'Expression\((\w+)\)', query_expr)
            if query_match:
                shape_name = query_match.group(1)
                # Find what type this shape is
                type_match = re.search(rf'{shape_name}:\s*(\w+)', fact_expr)
                if type_match:
                    primary_shape = type_match.group(1).lower()
            
            # Detect main conic names for each type
            main_hyperbola_name = self._detect_main_conic_name(fact_expr, 'hyperbola')
            main_ellipse_name = self._detect_main_conic_name(fact_expr, 'ellipse')
            main_parabola_name = self._detect_main_conic_name(fact_expr, 'parabola')
            main_circle_name = self._detect_main_conic_name(fact_expr, 'circle')
            
            # Try to parse as different conic types, using main conic names
            ellipse_params = self.parser.parse_ellipse(fact_expr)
            hyperbola_params = self.parser.parse_hyperbola(fact_expr, main_hyperbola_name)
            parabola_params = self.parser.parse_parabola(fact_expr)
            circle_params = self.parser.parse_circle(fact_expr)
            
            # Additional constraints
            coords = self.parser.parse_coordinates(fact_expr)
            eccentricity = self.parser.parse_eccentricity(fact_expr)
            asymptote = self.parser.parse_asymptote_slope(fact_expr)
            
            # Special case: moving circle locus (externally tangent to fixed circle, passes through a fixed point)
            moving_circle = self._detect_moving_circle_locus(fact_expr, coords)
            if moving_circle:
                params_hyp = moving_circle
                return self._process_hyperbola(problem, idx, params_hyp, coords, eccentricity=None, asymptote=None, verbose=verbose)
            
            # Process based on primary shape (if determined) or first available
            if primary_shape == 'hyperbola' and hyperbola_params:
                result = self._process_hyperbola(problem, idx, hyperbola_params, coords, eccentricity, asymptote, verbose)
            elif primary_shape == 'ellipse' and ellipse_params:
                result = self._process_ellipse(problem, idx, ellipse_params, coords, eccentricity, verbose)
            elif primary_shape == 'parabola' and parabola_params:
                result = self._process_parabola(problem, idx, parabola_params, coords, verbose)
            elif primary_shape == 'circle' and circle_params:
                result = self._process_circle(problem, idx, circle_params, coords, verbose)
            # Fallback to order of detection, but prioritize hyperbola over ellipse 
            # (many problems have both, with hyperbola as the main subject)
            elif hyperbola_params:
                result = self._process_hyperbola(problem, idx, hyperbola_params, coords, eccentricity, asymptote, verbose)
            elif ellipse_params:
                result = self._process_ellipse(problem, idx, ellipse_params, coords, eccentricity, verbose)
            elif parabola_params:
                result = self._process_parabola(problem, idx, parabola_params, coords, verbose)
            elif circle_params:
                result = self._process_circle(problem, idx, circle_params, coords, verbose)
            else:
                result['error'] = 'Unsupported or unparseable expression'
                return result
            
            # Validation step
            result = self._validate_result(result, problem)
            return result
                
        except Exception as e:
            result['error'] = str(e)
            return result
    
    def _validate_result(self, result: Dict, problem: Dict) -> Dict:
        """
        Lightweight validation to catch obvious incorrect outputs.
        Adds validation_reasons when failed and flips success=False.
        """
        if not result.get('success'):
            return result
        
        conic_type = result.get('conic_type')
        fact_expr = result.get('fact_expr', problem.get('fact_expressions', ''))
        coords = result.get('coords', {})
        reasons = []
        tol = 3e-2
        
        # Dynamically detect the main conic name from fact_expr
        main_conic = self._detect_main_conic_name(fact_expr, conic_type)
        
        # Get only points that are explicitly on the MAIN conic
        points_on_main = self._points_on_main_conic(fact_expr, coords, main_conic)
        
        def has_point_constraint(name: str) -> bool:
            return name in points_on_main
        
        if conic_type == 'ellipse':
            params = result.get('params', {})
            if 'a' not in params or 'b' not in params:
                return result  # Skip validation if params incomplete
            a = params['a']
            b = params['b']
            if a <= 0 or b <= 0:
                reasons.append('ellipse_nonpositive_axes')
            ecc_target = self.parser.parse_eccentricity(fact_expr)
            if ecc_target and ecc_target < 1:
                ecc_calc = np.sqrt(max(0.0, 1 - (min(a, b) / max(a, b))**2))
                if abs(ecc_calc - ecc_target) > 0.05:
                    reasons.append('ellipse_ecc_mismatch')
            # Point-on-curve checks
            for name, (px, py) in coords.items():
                if has_point_constraint(name):
                    val = (px**2) / (a**2) + (py**2) / (b**2) - 1
                    if abs(val) > tol:
                        reasons.append('ellipse_point_off_curve')
                        break
        
        elif conic_type == 'hyperbola':
            params = result.get('params', {})
            if 'a' not in params or 'b' not in params:
                return result  # Skip validation if params incomplete
            a = params['a']
            b = params['b']
            orientation = params.get('orientation', 'horizontal')
            if a <= 0 or b <= 0:
                reasons.append('hyperbola_nonpositive_axes')
            asym = self.parser.parse_asymptote_slope(fact_expr)
            if asym:
                if abs(b / a - asym) > 0.05:
                    reasons.append('hyperbola_asymptote_mismatch')
            ecc_target = self.parser.parse_eccentricity(fact_expr)
            if ecc_target and ecc_target > 1:
                ecc_calc = np.sqrt(1 + (b / a) ** 2)
                if abs(ecc_calc - ecc_target) > 0.05:
                    reasons.append('hyperbola_ecc_mismatch')
            for name, (px, py) in coords.items():
                if has_point_constraint(name):
                    # Use correct formula based on orientation
                    if orientation == 'vertical':
                        # y²/a² - x²/b² = 1
                        val = (py**2) / (a**2) - (px**2) / (b**2) - 1
                    else:
                        # x²/a² - y²/b² = 1 (horizontal, default)
                        val = (px**2) / (a**2) - (py**2) / (b**2) - 1
                    if abs(val) > tol:
                        reasons.append('hyperbola_point_off_curve')
                        break
        
        elif conic_type == 'parabola':
            p = result['params']['p']
            direction = result['params'].get('direction', 'right')
            if p <= 0:
                reasons.append('parabola_nonpositive_p')
            # value at origin should be zero for standard placement
            if direction == 'right':
                base_val = 0 - 4 * p * 0
            elif direction == 'left':
                base_val = 0 + 4 * p * 0
            elif direction == 'up':
                base_val = 0 - 4 * p * 0
            else:  # down
                base_val = 0 + 4 * p * 0
            if abs(base_val) > tol:
                reasons.append('parabola_origin_offset')
            for name, (px, py) in coords.items():
                if has_point_constraint(name):
                    if direction == 'right':
                        val = py**2 - 4 * p * px
                    elif direction == 'left':
                        val = py**2 + 4 * p * px
                    elif direction == 'up':
                        val = px**2 - 4 * p * py
                    else:
                        val = px**2 + 4 * p * py
                    if abs(val) > tol:
                        reasons.append('parabola_point_off_curve')
                        break
        
        elif conic_type == 'circle':
            r = result['params']['radius']
            cx, cy = result['params']['center']
            if r <= 0:
                reasons.append('circle_nonpositive_radius')
            for name, (px, py) in coords.items():
                if has_point_constraint(name):
                    val = (px - cx) ** 2 + (py - cy) ** 2 - r ** 2
                    if abs(val) > tol:
                        reasons.append('circle_point_off_curve')
                        break
        
        if reasons:
            result['success'] = False
            result['error'] = 'validation: ' + ';'.join(reasons)
            result['validation_reasons'] = reasons
        return result

    def _point_constraint_names(self, fact_expr: str, coords: Dict, conic_type: str = 'parabola') -> set:
        """
        Collect point names that are explicitly constrained on the main curve.
        Uses _detect_main_conic_name to find the actual conic variable name.
        """
        main_conic = self._detect_main_conic_name(fact_expr, conic_type)
        return self._points_on_main_conic(fact_expr, coords, main_conic)
    
    def _detect_main_conic_name(self, fact_expr: str, conic_type: str) -> str:
        """
        Detect the actual name of the main conic from fact_expr.
        
        Patterns like 'G: Ellipse', 'C: Parabola', 'C: Hyperbola', etc.
        Returns the variable name (e.g., 'G' or 'C').
        """
        import re
        
        # Map conic_type to the type name in fact_expr
        type_map = {
            'ellipse': 'Ellipse',
            'hyperbola': 'Hyperbola',
            'parabola': 'Parabola',
            'circle': 'Circle'
        }
        type_name = type_map.get(conic_type, '')
        
        if type_name:
            # Pattern: variable_name: TypeName (e.g., "G: Ellipse" or "C: Parabola")
            pattern = rf'(\w+)\s*:\s*{type_name}'
            match = re.search(pattern, fact_expr)
            if match:
                return match.group(1)
        
        # Fallback to defaults
        return 'C' if conic_type == 'circle' else 'G'
    
    def _points_on_main_conic(self, fact_expr: str, coords: Dict, conic_name: str = 'G') -> set:
        """
        Collect point names that are EXPLICITLY on the MAIN conic (e.g., G or C).
        
        Includes:
        - PointOnCurve(<name>, G) where G is the main conic
        - Intersection(*, G) = {A, B} where G is the main conic
        
        Excludes:
        - PointOnCurve(<name>, H) where H is a line
        - PointOnCurve(<name>, Asymptote(G)) - on asymptote, not curve
        - PointOnCurve(<name>, Directrix(G)) - on directrix, not curve
        - PointOnCurve(<name>, G1) where G1 is a different curve
        - MidPoint constraints (midpoints of chords are not on the curve)
        """
        import re
        names = set()
        
        # Match PointOnCurve(name, G) exactly - second argument must be exactly the conic name
        # Avoid matching things like Asymptote(G), Directrix(G), G1, etc.
        for name in coords.keys():
            # Pattern: PointOnCurve(name, G) - spaces allowed, second arg must be exactly conic_name
            # Use word boundary to avoid matching G1 when looking for G
            pattern = rf'PointOnCurve\(\s*{re.escape(name)}\s*,\s*{re.escape(conic_name)}\s*\)'
            if re.search(pattern, fact_expr):
                names.add(name)
        
        # Match Intersection(*, G) = {A, B} or Intersection(G, *) = {A, B}
        # Only if one of the arguments is exactly the main conic
        inter_pattern = r'Intersection\(\s*([^,)]+)\s*,\s*([^)]+)\s*\)\s*=\s*\{([^}]+)\}'
        for m in re.finditer(inter_pattern, fact_expr):
            arg1 = m.group(1).strip()
            arg2 = m.group(2).strip()
            points_str = m.group(3)
            
            # Check if either argument is exactly the main conic name
            if arg1 == conic_name or arg2 == conic_name:
                for p in points_str.split(','):
                    p = p.strip()
                    if p in coords:
                        names.add(p)
        
        return names

    def _detect_moving_circle_locus(self, fact_expr: str, coords: Dict) -> Optional[Dict]:
        """
        Detect pattern: moving circle through fixed point A, externally tangent to fixed circle C.
        If foci on x-axis, convert to hyperbola params: |PC| - |PA| = R -> 2a = R.
        Returns hyperbola params dict or None.
        """
        if "IsOutTangent" not in fact_expr:
            return None
        import re
        # Parse fixed circle C explicitly from its expression (two common orderings)
        patterns = [
            r'Expression\(C\)\s*=\s*\(y\^2\s*\+\s*\(x\s*([+-])\s*(\d+\.?\d*)\)\^2\s*=\s*(\d+\.?\d*)\)',
            r'Expression\(C\)\s*=\s*\(\(x\s*([+-])\s*(\d+\.?\d*)\)\^2\s*\+\s*y\^2\s*=\s*(\d+\.?\d*)\)'
        ]
        cx = cy = R = None
        for pat in patterns:
            m = re.search(pat, fact_expr)
            if m:
                sign = m.group(1)
                val = float(m.group(2))
                cx = -val if sign == '+' else val
                cy = 0.0
                R = np.sqrt(float(m.group(3)))
                break
        if R is None or R <= 0:
            return None
        # pick A if present, else first point
        if 'A' in coords:
            ax, ay = coords['A']
        elif coords:
            ax, ay = next(iter(coords.values()))
        else:
            return None
        # Only handle foci on x-axis for now
        if abs(ay) > 1e-6 or abs(cy) > 1e-6:
            return None
        c = abs(cx - ax) / 2
        if c <= 0:
            return None
        a = R / 2
        if a <= 0 or c <= a:
            return None
        b_sq = c * c - a * a
        b = np.sqrt(b_sq)
        return {'a': a, 'b': b}
    
    def _process_ellipse(self, problem: Dict, idx: int, params: Dict,
                        coords: Dict, eccentricity: Optional[float], verbose: bool) -> Dict:
        """Process ellipse problem with SDF optimization."""
        
        fact_expr = problem.get('fact_expressions', '')
        point_names = self._point_constraint_names(fact_expr, coords, 'ellipse')
        # Create SDF with initial parameters
        center = torch.tensor([0.0, 0.0])
        # Ensure params has 'a' and 'b' keys
        if 'a' not in params or 'b' not in params:
            return {
                'index': idx,
                'success': False,
                'error': f"Ellipse params missing 'a' or 'b': {list(params.keys())}"
            }
        a = torch.tensor([params['a']])
        b = torch.tensor([params['b']])
        
        sdf = EllipseSDF(center, a, b)
        
        # Check if we have explicit numeric coefficients (not symbolic)
        has_explicit_coeffs = not params.get('symbolic', False) and not params.get('from_constraints', False)
        
        # Only apply optimization if we don't have explicit coefficients
        # or if constraints are compatible
        should_optimize = False
        constraints = []
        weights = []
        
        if not has_explicit_coeffs:
            # If we have eccentricity constraint for ellipse (must be < 1)
            if eccentricity and eccentricity < 1:
                constraints.append(lambda: GeometricConstraints.eccentricity_ellipse(
                    sdf.a, sdf.b, eccentricity
                ))
                weights.append(10.0)
                should_optimize = True
            
            # Collect positions for crowd penalty
            all_positions = [sdf.center]
            
            # Point on curve constraints
            for name, (px, py) in coords.items():
                if name in point_names and name not in ['F1', 'F2', 'F', 'O']:
                    point = torch.tensor([px, py])
                    constraints.append(lambda p=point: GeometricConstraints.point_on_curve(sdf, p))
                    weights.append(5.0)
                    should_optimize = True
                    all_positions.append(point)
            
            # Crowd regularization (Paper Section 3.3, Equation 2)
            # Prevents geometric elements from collapsing
            if len(all_positions) > 1:
                constraints.append(lambda pos=all_positions: GeometricConstraints.crowd_penalty(pos, tau=0.5))
                weights.append(3.0)  # λ_crowd = 3.0 (paper default)
            
            # Positive constraints
            constraints.append(lambda: GeometricConstraints.positive_constraint(sdf.a))
            constraints.append(lambda: GeometricConstraints.positive_constraint(sdf.b))
            weights.extend([1.0, 1.0])
        
        # Optimize only if needed and constraints are valid
        if should_optimize and len(constraints) > 2:
            opt_result = self.optimizer.optimize(sdf, constraints, weights, verbose)
            
            # Check if optimization produced valid result
            with torch.no_grad():
                a_opt = abs(sdf.a.item())
                b_opt = abs(sdf.b.item())
            
            # If optimization produced degenerate result, revert to original params
            if b_opt < 0.1 or a_opt < 0.1:
                sdf.a.data = torch.tensor([params['a']])
                sdf.b.data = torch.tensor([params['b']])
                opt_result = {'final_loss': 0.0, 'converged': True, 'note': 'reverted to explicit params'}
        else:
            opt_result = {'final_loss': 0.0, 'converged': True, 'note': 'using explicit params'}
        
        # Extract final parameters
        with torch.no_grad():
            a_final = abs(sdf.a.item())
            b_final = abs(sdf.b.item())
        
        # Determine major axis based on original coefficients
        major_axis = params.get('major_axis', 'x')
        
        # Visualize
        output_path = self.output_dir / 'ellipse' / f'problem_{idx:04d}.png'
        self._visualize_ellipse(sdf, problem, params, output_path, major_axis)
        
        return {
            'index': idx,
            'success': True,
            'conic_type': 'ellipse',
            'error': None,
            'params': {
                'a': a_final,
                'b': b_final,
                'major_axis': major_axis,
                'x_coef': params['x_coef'],
                'y_coef': params['y_coef']
            },
            'optimization': opt_result,
            'output_path': str(output_path),
            'answer': problem.get('answer_expressions', ''),
            'fact_expr': fact_expr,
            'coords': coords
        }
    
    def _process_hyperbola(self, problem: Dict, idx: int, params: Dict,
                          coords: Dict, eccentricity: Optional[float],
                          asymptote: Optional[float], verbose: bool) -> Dict:
        """Process hyperbola problem with SDF optimization."""
        
        fact_expr = problem.get('fact_expressions', '')
        point_names = self._point_constraint_names(fact_expr, coords, 'hyperbola')
        
        # Check if foci come from an ellipse (Focus(G) = Focus(H) where H is Ellipse)
        c_from_ellipse = None
        if 'Focus(G) = Focus(H)' in fact_expr or 'Focus(H) = Focus(G)' in fact_expr:
            # Find the ellipse expression
            ellipse_match = re.search(r'Expression\(\w+\)\s*=\s*\(x\^2/(\d+)\s*\+\s*y\^2/(\d+)\s*=\s*1\)', fact_expr)
            if ellipse_match:
                x_coef = float(ellipse_match.group(1))
                y_coef = float(ellipse_match.group(2))
                a_ell = np.sqrt(max(x_coef, y_coef))
                b_ell = np.sqrt(min(x_coef, y_coef))
                c_from_ellipse = np.sqrt(a_ell**2 - b_ell**2)
        
        # If we have eccentricity and c from ellipse, calculate a and b directly
        if eccentricity and eccentricity > 1 and c_from_ellipse:
            # For hyperbola: e = c/a, so a = c/e
            a_val = c_from_ellipse / eccentricity
            # c² = a² + b², so b² = c² - a²
            b_squared = c_from_ellipse**2 - a_val**2
            if b_squared > 0:
                b_val = np.sqrt(b_squared)
                params['a'] = a_val
                params['b'] = b_val
                params['a_squared'] = a_val**2
                params['b_squared'] = b_squared
        
        center = torch.tensor([0.0, 0.0])
        # Ensure params has 'a' and 'b' keys
        if 'a' not in params or 'b' not in params:
            return {
                'index': idx,
                'success': False,
                'error': f"Hyperbola params missing 'a' or 'b': {list(params.keys())}"
            }
        a = torch.tensor([params['a']])
        b = torch.tensor([params['b']])
        
        sdf = HyperbolaSDF(center, a, b)
        
        # Check if we already have explicit params from the above calculation
        has_explicit_params = c_from_ellipse is not None and eccentricity and eccentricity > 1
        
        constraints = []
        weights = []
        
        if not has_explicit_params:
            # Collect positions for crowd penalty
            all_positions = [sdf.center]
            
            # Eccentricity constraint
            if eccentricity and eccentricity > 1:
                constraints.append(lambda: GeometricConstraints.eccentricity_hyperbola(
                    sdf.a, sdf.b, eccentricity
                ))
                weights.append(10.0)
            
            # Asymptote slope constraint
            if asymptote:
                constraints.append(lambda: GeometricConstraints.asymptote_slope(
                    sdf.a, sdf.b, asymptote
                ))
                weights.append(10.0)
            
            # Focus constraint from coordinates
            focus_coords = [(n, c) for n, c in coords.items() if 'F' in n]
            if len(focus_coords) >= 2:
                f1 = focus_coords[0][1]
                f2 = focus_coords[1][1]
                c_target = abs(f1[0] - f2[0]) / 2 if f1[1] == f2[1] == 0 else None
                if c_target:
                    constraints.append(lambda ct=c_target: GeometricConstraints.focus_constraint_hyperbola(
                        sdf.a, sdf.b, ct
                    ))
                    weights.append(10.0)
            
            # Add extra points to crowd penalty
            for name, (px, py) in coords.items():
                if name in point_names and name not in ['F1', 'F2', 'F', 'O']:
                    all_positions.append(torch.tensor([px, py]))
            
            # Crowd regularization (Paper Section 3.3, Equation 2)
            if len(all_positions) > 1:
                constraints.append(lambda pos=all_positions: GeometricConstraints.crowd_penalty(pos, tau=0.5))
                weights.append(3.0)  # λ_crowd = 3.0
            
            # Positive constraints
            constraints.append(lambda: GeometricConstraints.positive_constraint(sdf.a))
            constraints.append(lambda: GeometricConstraints.positive_constraint(sdf.b))
            weights.extend([1.0, 1.0])
        
        if len(constraints) > 2:
            opt_result = self.optimizer.optimize(sdf, constraints, weights, verbose)
        else:
            opt_result = {'final_loss': 0.0, 'converged': True, 'note': 'using explicit params'}
        
        with torch.no_grad():
            a_final = abs(sdf.a.item())
            b_final = abs(sdf.b.item())
        
        output_path = self.output_dir / 'hyperbola' / f'problem_{idx:04d}.png'
        self._visualize_hyperbola(sdf, problem, params, output_path)
        
        return {
            'index': idx,
            'success': True,
            'conic_type': 'hyperbola',
            'error': None,
            'params': {
                'a': a_final,
                'b': b_final,
                'orientation': params.get('orientation', 'horizontal')
            },
            'optimization': opt_result,
            'output_path': str(output_path),
            'answer': problem.get('answer_expressions', ''),
            'fact_expr': fact_expr,
            'coords': coords
        }
    
    def _process_parabola(self, problem: Dict, idx: int, params: Dict,
                         coords: Dict, verbose: bool) -> Dict:
        """Process parabola problem with SDF optimization."""
        
        fact_expr = problem.get('fact_expressions', '')
        point_names = self._point_constraint_names(fact_expr, coords, 'parabola')
        vertex = torch.tensor([0.0, 0.0])
        p = torch.tensor([params['p']])
        direction = params.get('direction', 'right')
        
        sdf = ParabolaSDF(vertex, p, direction)
        # Keep vertex fixed at origin to avoid unintended translation during optimization
        sdf.vertex.requires_grad_(False)
        
        # 如果题目给出了显式的抛物线方程（非符号/约束推导），直接使用，不做优化
        has_explicit_params = not params.get('symbolic', False) and not params.get('from_constraints', False)
        
        if has_explicit_params:
            opt_result = {'final_loss': 0.0, 'converged': True, 'note': 'using explicit params'}
        else:
            # Collect positions for crowd penalty
            all_positions = [sdf.vertex]
            
            constraints = [
                lambda: GeometricConstraints.positive_constraint(sdf.p)
            ]
            weights = [1.0]
            
            # Point on curve constraints
            for name, (px, py) in coords.items():
                if name in point_names and name not in ['F', 'O']:
                    point = torch.tensor([px, py])
                    constraints.append(lambda pt=point: GeometricConstraints.point_on_curve(sdf, pt))
                    weights.append(5.0)
                    all_positions.append(point)
            
            # Crowd regularization (Paper Section 3.3, Equation 2)
            if len(all_positions) > 1:
                constraints.append(lambda pos=all_positions: GeometricConstraints.crowd_penalty(pos, tau=0.5))
                weights.append(3.0)  # λ_crowd = 3.0
            
            if len(constraints) > 1:
                opt_result = self.optimizer.optimize(sdf, constraints, weights, verbose)
            else:
                opt_result = {'final_loss': 0.0, 'converged': True}
        
        with torch.no_grad():
            p_final = abs(sdf.p.item())
        
        output_path = self.output_dir / 'parabola' / f'problem_{idx:04d}.png'
        self._visualize_parabola(sdf, problem, params, output_path)
        
        return {
            'index': idx,
            'success': True,
            'conic_type': 'parabola',
            'error': None,
            'params': {'p': p_final, 'direction': direction},
            'optimization': opt_result,
            'output_path': str(output_path),
            'answer': problem.get('answer_expressions', ''),
            'fact_expr': fact_expr,
            'coords': coords
        }
    
    def _process_circle(self, problem: Dict, idx: int, params: Dict,
                        coords: Dict, verbose: bool) -> Dict:
        """Process circle problem with SDF."""
        
        fact_expr = problem.get('fact_expressions', '')
        point_names = self._point_constraint_names(fact_expr, coords, 'circle')
        # Get center and radius
        if params.get('from_diameter'):
            # Compute circle from diameter endpoints
            # Pattern: IsDiameter(LineSegmentOf(A, B), C) where C is the circle
            fact_expr = problem.get('fact_expressions', '')
            coords = self.parser.parse_coordinates(fact_expr)
            
            # Find the two points that form the diameter
            diameter_match = re.search(r'IsDiameter\(LineSegmentOf\((\w+),\s*(\w+)\)', fact_expr)
            if diameter_match:
                pt1_name = diameter_match.group(1)
                pt2_name = diameter_match.group(2)
                if pt1_name in coords and pt2_name in coords:
                    x1, y1 = coords[pt1_name]
                    x2, y2 = coords[pt2_name]
                    # Center = midpoint, radius = half of distance
                    params['center'] = ((x1 + x2) / 2, (y1 + y2) / 2)
                    params['radius'] = np.sqrt((x2 - x1)**2 + (y2 - y1)**2) / 2
                else:
                    result = {
                        'index': idx,
                        'success': False,
                        'error': 'Circle from diameter: missing point coordinates'
                    }
                    return result
            else:
                result = {
                    'index': idx,
                    'success': False,
                    'error': 'Circle from diameter: cannot parse diameter pattern'
                }
                return result
        
        center = torch.tensor(list(params.get('center', (0.0, 0.0))))
        radius = torch.tensor([params.get('radius', 1.0)])
        
        sdf = CircleSDF(center, radius)
        
        # No optimization needed for explicit circles
        opt_result = {'final_loss': 0.0, 'converged': True}
        
        with torch.no_grad():
            cx = sdf.center[0].item()
            cy = sdf.center[1].item()
            r = abs(sdf.radius.item())
        
        output_path = self.output_dir / 'circle' / f'problem_{idx:04d}.png'
        self._visualize_circle(sdf, problem, params, output_path)
        
        return {
            'index': idx,
            'success': True,
            'conic_type': 'circle',
            'error': None,
            'params': {'center': (cx, cy), 'radius': r},
            'optimization': opt_result,
            'output_path': str(output_path),
            'answer': problem.get('answer_expressions', ''),
            'fact_expr': fact_expr,
            'coords': {k:v for k,v in coords.items() if k in point_names}
        }
    
    def _visualize_circle(self, sdf: CircleSDF, problem: Dict, params: Dict,
                         output_path: Path):
        """Visualize circle using SDF zero-level set."""
        
        with torch.no_grad():
            cx = sdf.center[0].item()
            cy = sdf.center[1].item()
            r = abs(sdf.radius.item())
        
        # Set up plot range
        margin = r + 2
        xlim = (cx - margin, cx + margin)
        ylim = (cy - margin, cy + margin)
        
        # Create renderer
        renderer = SDFRenderer(resolution=400, xlim=xlim, ylim=ylim)
        
        # Create figure with info panel
        fig, (ax, ax_info) = plt.subplots(2, 1, figsize=(10, 12),
                                          gridspec_kw={'height_ratios': [0.6, 0.4]})
        
        # Render SDF field and zero-level set
        renderer.render_sdf_field(sdf, ax, show_field=True, field_alpha=0.15)
        
        # Mark center
        ax.plot(cx, cy, 'ro', markersize=10, label='Center')
        ax.annotate('C', (cx, cy), textcoords="offset points", xytext=(10, 10), fontsize=12)
        
        # Draw radius line
        ax.plot([cx, cx + r], [cy, cy], 'g--', linewidth=2, label=f'r = {r:.2f}')
        
        # Plot any additional points from constraints
        for name, (px, py) in params.get('coords', {}).items():
            ax.plot(px, py, 'go', markersize=8)
            ax.annotate(name, (px, py), textcoords="offset points", xytext=(5, 5), fontsize=10)
        
        ax.set_xlabel('x')
        ax.set_ylabel('y')
        ax.set_title('Circle - SDF Zero-Level Set')
        ax.legend(loc='upper right')
        ax.set_aspect('equal')
        ax.grid(True, alpha=0.3)
        
        # Info panel
        ax_info.axis('off')
        
        text = problem.get('text', '')
        wrapped_text = self._wrap_text(text, width=60)
        
        info_text = f"""PROBLEM
{'─' * 50}
{wrapped_text}

EQUATION (SDF Zero-Level Set)
{'─' * 50}
(x - {cx:.2f})² + (y - {cy:.2f})² = {r**2:.2f}

SDF PARAMETERS
{'─' * 50}
center: ({cx:.4f}, {cy:.4f})
radius: {r:.4f}

EXPECTED ANSWER: {problem.get('answer_expressions', 'N/A')}
QUERY: {problem.get('query_expressions', 'N/A')}"""
        
        ax_info.text(0, 1, info_text, transform=ax_info.transAxes,
                    fontsize=10, verticalalignment='top', fontfamily='monospace',
                    wrap=True)
        
        plt.tight_layout()
        output_path.parent.mkdir(parents=True, exist_ok=True)
        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
        plt.close()
    
    def _wrap_text(self, text: str, width: int = 50) -> str:
        """Wrap text to specified width."""
        words = text.split()
        lines = []
        current_line = []
        current_len = 0
        
        for word in words:
            if current_len + len(word) + 1 <= width:
                current_line.append(word)
                current_len += len(word) + 1
            else:
                if current_line:
                    lines.append(' '.join(current_line))
                current_line = [word]
                current_len = len(word)
        
        if current_line:
            lines.append(' '.join(current_line))
        
        return '\n'.join(lines)
    
    def _visualize_ellipse(self, sdf: EllipseSDF, problem: Dict, params: Dict,
                          output_path: Path, major_axis: str):
        """Visualize ellipse using SDF zero-level set, including related shapes."""
        
        with torch.no_grad():
            a = abs(sdf.a.item())
            b = abs(sdf.b.item())
        
        # Ensure minimum b value for visualization
        b_viz = max(b, 0.1)
        
        fact_expr = problem.get('fact_expressions', '')
        
        # Check if there's also a hyperbola in the problem
        hyperbola_params = self.parser.parse_hyperbola(fact_expr)
        has_hyperbola = hyperbola_params is not None and 'a' in hyperbola_params and 'b' in hyperbola_params
        
        # Determine plot limits - ensure all curves visible
        if has_hyperbola:
            a_hyp = hyperbola_params['a']
            b_hyp = hyperbola_params['b']
            max_dim = max(a, b_viz, a_hyp, b_hyp) * 1.8 + 1
        else:
            max_dim = max(a, b_viz) * 1.3
        
        # Use vertical layout: plot on top, info below
        fig = plt.figure(figsize=(10, 14), dpi=120)
        
        # Main plot takes up top 60%
        ax_main = fig.add_axes([0.1, 0.4, 0.8, 0.55])
        
        # Create renderer with appropriate limits
        renderer = SDFRenderer(
            resolution=500,
            xlim=(-max_dim, max_dim),
            ylim=(-max_dim, max_dim)
        )
        
        # Render SDF field and zero-level set
        renderer.render_sdf_field(sdf, ax_main, show_field=True)
        
        # If there's a hyperbola, also draw it
        if has_hyperbola:
            center = torch.tensor([0.0, 0.0])
            a_hyp_t = torch.tensor([hyperbola_params['a']])
            b_hyp_t = torch.tensor([hyperbola_params['b']])
            hyp_sdf = HyperbolaSDF(center, a_hyp_t, b_hyp_t)
            
            # Draw hyperbola zero-level set in a different color
            with torch.no_grad():
                grid_flat = renderer.grid.reshape(-1, 2)
                hyp_distances = hyp_sdf(grid_flat).reshape(renderer.resolution, renderer.resolution)
                hyp_distances_np = hyp_distances.cpu().numpy()
            
            ax_main.contour(renderer.xx.numpy(), renderer.yy.numpy(), hyp_distances_np,
                           levels=[0], colors=['#E74C3C'], linewidths=2.5, linestyles='-')
            
            # Asymptotes for hyperbola
            slope_hyp = hyperbola_params['b'] / hyperbola_params['a']
            x_asym = np.linspace(-max_dim, max_dim, 100)
            ax_main.plot(x_asym, slope_hyp * x_asym, '--', color='#C73E1D', linewidth=1.5, alpha=0.5)
            ax_main.plot(x_asym, -slope_hyp * x_asym, '--', color='#C73E1D', linewidth=1.5, alpha=0.5)
            
            # Add to legend
            from matplotlib.lines import Line2D
            ellipse_line = Line2D([0], [0], color='#2E86AB', linewidth=2.5, 
                                  label=f'Ellipse (x²/{params["x_coef"]:.0f} + y²/{params["y_coef"]:.0f} = 1)')
            hyperbola_line = Line2D([0], [0], color='#E74C3C', linewidth=2.5, 
                                    label=f'Hyperbola (x²/{hyperbola_params["a"]:.2f}² - y²/{hyperbola_params["b"]:.2f}² = 1)')
        
        # Calculate and plot foci
        c = np.sqrt(abs(a**2 - b**2)) if a > b else np.sqrt(abs(b**2 - a**2))
        if major_axis == 'x':
            ax_main.plot([c, -c], [0, 0], 'ro', markersize=12, 
                        label='Shared Foci' if has_hyperbola else 'Foci', zorder=5)
            ax_main.annotate('$F_1$', (-c, 0), xytext=(-c-0.4, 0.4), fontsize=14, fontweight='bold')
            ax_main.annotate('$F_2$', (c, 0), xytext=(c+0.2, 0.4), fontsize=14, fontweight='bold')
        else:
            ax_main.plot([0, 0], [c, -c], 'ro', markersize=12, 
                        label='Shared Foci' if has_hyperbola else 'Foci', zorder=5)
            ax_main.annotate('$F_1$', (0, -c), xytext=(0.3, -c-0.4), fontsize=14, fontweight='bold')
            ax_main.annotate('$F_2$', (0, c), xytext=(0.3, c+0.2), fontsize=14, fontweight='bold')
        
        # Plot additional points
        coords = self.parser.parse_coordinates(problem.get('fact_expressions', ''))
        for name, (px, py) in coords.items():
            if name not in ['F1', 'F2', 'F', 'O']:
                ax_main.plot(px, py, 'go', markersize=10, zorder=6)
                ax_main.annotate(f'${name}$', (px, py), xytext=(px+0.3, py+0.3), fontsize=13, fontweight='bold')
        
        # Styling
        ax_main.axhline(y=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.axvline(x=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.grid(True, alpha=0.3, linestyle='--')
        ax_main.set_xlim(-max_dim, max_dim)
        ax_main.set_ylim(-max_dim, max_dim)
        ax_main.set_xlabel('x', fontsize=14)
        ax_main.set_ylabel('y', fontsize=14)
        
        if has_hyperbola:
            ax_main.set_title('Ellipse & Hyperbola - SDF Zero-Level Sets', fontsize=16, fontweight='bold', pad=10)
            handles, labels = ax_main.get_legend_handles_labels()
            handles.extend([ellipse_line, hyperbola_line])
            ax_main.legend(handles=handles, loc='upper right', fontsize=10)
        else:
            ax_main.set_title('Ellipse - SDF Zero-Level Set', fontsize=16, fontweight='bold', pad=10)
            ax_main.legend(loc='upper right', fontsize=11)
        
        ax_main.set_aspect('equal')
        ax_main.tick_params(labelsize=11)
        
        # Info panel at bottom
        ax_info = fig.add_axes([0.05, 0.02, 0.9, 0.35])
        ax_info.axis('off')
        
        x_coef = params['x_coef']
        y_coef = params['y_coef']
        
        # Wrap problem text
        problem_text = self._wrap_text(problem.get('text', ''), width=70)
        
        if has_hyperbola:
            equations_text = f"""Ellipse: x²/{np.sqrt(x_coef):.2f}² + y²/{np.sqrt(y_coef):.2f}² = 1  (Blue)
Hyperbola: x²/{hyperbola_params['a']:.2f}² - y²/{hyperbola_params['b']:.2f}² = 1  (Red)"""
        else:
            equations_text = f"x²/{np.sqrt(x_coef):.2f}² + y²/{np.sqrt(y_coef):.2f}² = 1"
        
        info_text = f"""PROBLEM
{'─'*70}
{problem_text}

EQUATIONS (SDF Zero-Level Sets)
{'─'*70}
{equations_text}

SDF PARAMETERS (Ellipse)
{'─'*70}
a (semi-major): {a:.4f}    b (semi-minor): {b:.4f}    c (focal dist): {c:.4f}
eccentricity: {c/max(a,b):.4f}    major_axis: {major_axis}

EXPECTED ANSWER: {problem.get('answer_expressions', '')}
QUERY: {problem.get('query_expressions', '')}
"""
        
        ax_info.text(0.0, 1.0, info_text, transform=ax_info.transAxes,
                    fontsize=10, verticalalignment='top', family='monospace',
                    bbox=dict(boxstyle='round,pad=0.5', facecolor='#E8F4F8', alpha=0.9, edgecolor='#CCCCCC'))
        
        plt.savefig(output_path, bbox_inches='tight', dpi=120, facecolor='white')
        plt.close(fig)
    
    def _visualize_hyperbola(self, sdf: HyperbolaSDF, problem: Dict, params: Dict,
                            output_path: Path):
        """Visualize hyperbola using SDF zero-level set, including related shapes."""
        
        with torch.no_grad():
            a = abs(sdf.a.item())
            b = abs(sdf.b.item())
        
        fact_expr = problem.get('fact_expressions', '')
        
        # Check if there are other shapes in the problem
        ellipse_params = self.parser.parse_ellipse(fact_expr)
        line_params = self.parser.parse_line(fact_expr)
        has_ellipse = ellipse_params is not None and 'a' in ellipse_params and 'b' in ellipse_params
        has_line = line_params is not None and (line_params.get('a') is not None or line_params.get('slope') is not None)
        
        # If line has slope but no explicit equation, try to construct it
        if has_line and line_params.get('slope') is not None and line_params.get('a') is None:
            # Check if line passes through a focus
            slope = line_params['slope']
            # Find focus coordinates
            if 'LeftFocus' in fact_expr or 'RightFocus' in fact_expr:
                # Line passes through focus
                c_hyp = np.sqrt(a**2 + b**2)
                if 'LeftFocus' in fact_expr:
                    focus_x = -c_hyp
                else:
                    focus_x = c_hyp
                # Line: y - 0 = slope * (x - focus_x) => slope*x - y - slope*focus_x = 0
                line_params['a'] = slope
                line_params['b'] = -1.0
                line_params['c'] = -slope * focus_x
                line_params['equation'] = f'y = {slope:.2f}(x - {focus_x:.2f})'
        
        # Determine plot limits
        if has_ellipse:
            a_ell = ellipse_params['a']
            b_ell = ellipse_params['b']
            max_dim = max(a, b, a_ell, b_ell) * 1.5 + 1
        else:
            max_dim = max(a, b) * 2.5 + 2
        
        # Use vertical layout
        fig = plt.figure(figsize=(10, 14), dpi=120)
        ax_main = fig.add_axes([0.1, 0.4, 0.8, 0.55])
        
        renderer = SDFRenderer(
            resolution=500,
            xlim=(-max_dim, max_dim),
            ylim=(-max_dim, max_dim)
        )
        
        # Render hyperbola SDF field
        renderer.render_sdf_field(sdf, ax_main, show_field=True)
        
        # If there's an ellipse, also draw it
        if has_ellipse:
            center = torch.tensor([0.0, 0.0])
            a_ell_t = torch.tensor([ellipse_params['a']])
            b_ell_t = torch.tensor([ellipse_params['b']])
            ellipse_sdf = EllipseSDF(center, a_ell_t, b_ell_t)
            
            # Draw ellipse zero-level set in a different color
            with torch.no_grad():
                grid_flat = renderer.grid.reshape(-1, 2)
                ell_distances = ellipse_sdf(grid_flat).reshape(renderer.resolution, renderer.resolution)
                ell_distances_np = ell_distances.cpu().numpy()
            
            ax_main.contour(renderer.xx.numpy(), renderer.yy.numpy(), ell_distances_np,
                           levels=[0], colors=['#27AE60'], linewidths=2.5, linestyles='-')
            
            # Add ellipse to legend
            from matplotlib.lines import Line2D
            ellipse_line = Line2D([0], [0], color='#27AE60', linewidth=2.5, label=f'Ellipse (x²/{ellipse_params["x_coef"]:.0f} + y²/{ellipse_params["y_coef"]:.0f} = 1)')
            hyperbola_line = Line2D([0], [0], color='#2E86AB', linewidth=2.5, label=f'Hyperbola (x²/{a:.2f}² - y²/{b:.2f}² = 1)')
        
        # Draw line if present (only if we have complete line equation)
        if has_line and line_params.get('a') is not None and line_params.get('b') is not None:
            from matplotlib.lines import Line2D
            line_a = line_params['a']
            line_b = line_params['b']
            line_c = line_params.get('c', 0)
            
            # Line: ax + by + c = 0 => y = (-ax - c) / b or x = (-by - c) / a
            x_line = np.linspace(-max_dim, max_dim, 100)
            if abs(line_b) > 1e-6:
                y_line = (-line_a * x_line - line_c) / line_b
                ax_main.plot(x_line, y_line, '-', color='#9B59B6', linewidth=2.5, 
                            label=f'Line ({line_params["equation"]} = 0)', zorder=4)
            else:
                # Vertical line
                x_val = -line_c / line_a if abs(line_a) > 1e-6 else 0
                ax_main.axvline(x=x_val, color='#9B59B6', linewidth=2.5,
                               label=f'Line (x = {x_val:.2f})', zorder=4)
        
        # Foci (shared between hyperbola and ellipse if Focus(G) = Focus(H))
        c = np.sqrt(a**2 + b**2)
        ax_main.plot([c, -c], [0, 0], 'ro', markersize=12, label='Shared Foci' if has_ellipse else 'Foci', zorder=5)
        ax_main.annotate('$F_1$', (-c, 0), xytext=(-c-0.4, 0.6), fontsize=14, fontweight='bold')
        ax_main.annotate('$F_2$', (c, 0), xytext=(c+0.2, 0.6), fontsize=14, fontweight='bold')
        
        # Asymptotes
        slope = b / a
        x_asym = np.linspace(-max_dim, max_dim, 100)
        ax_main.plot(x_asym, slope * x_asym, '--', color='#C73E1D', linewidth=2, 
                    alpha=0.7, label='Asymptotes')
        ax_main.plot(x_asym, -slope * x_asym, '--', color='#C73E1D', linewidth=2, alpha=0.7)
        
        # Plot additional points
        coords = self.parser.parse_coordinates(problem.get('fact_expressions', ''))
        for name, (px, py) in coords.items():
            if name not in ['F1', 'F2', 'F', 'O']:
                ax_main.plot(px, py, 'go', markersize=10, zorder=6)
                ax_main.annotate(f'${name}$', (px, py), xytext=(px+0.3, py+0.3), fontsize=13, fontweight='bold')
        
        ax_main.axhline(y=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.axvline(x=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.grid(True, alpha=0.3, linestyle='--')
        ax_main.set_xlim(-max_dim, max_dim)
        ax_main.set_ylim(-max_dim, max_dim)
        ax_main.set_xlabel('x', fontsize=14)
        ax_main.set_ylabel('y', fontsize=14)
        
        # Set title based on what shapes are present
        title_parts = ['Hyperbola']
        if has_ellipse:
            title_parts.append('Ellipse')
        if has_line:
            title_parts.append('Line')
        
        if len(title_parts) > 1:
            ax_main.set_title(' & '.join(title_parts) + ' - SDF Zero-Level Sets', fontsize=16, fontweight='bold', pad=10)
            handles, labels = ax_main.get_legend_handles_labels()
            if has_ellipse:
                handles.extend([ellipse_line, hyperbola_line])
            ax_main.legend(handles=handles, loc='upper right', fontsize=10)
        else:
            ax_main.set_title('Hyperbola - SDF Zero-Level Set', fontsize=16, fontweight='bold', pad=10)
            ax_main.legend(loc='upper right', fontsize=11)
        
        ax_main.set_aspect('equal')
        ax_main.tick_params(labelsize=11)
        
        # Info panel at bottom
        ax_info = fig.add_axes([0.05, 0.02, 0.9, 0.35])
        ax_info.axis('off')
        
        problem_text = self._wrap_text(problem.get('text', ''), width=70)
        
        equations_parts = [f"Hyperbola: x²/{a:.2f}² - y²/{b:.2f}² = 1  (Blue)"]
        if has_ellipse:
            equations_parts.append(f"Ellipse: x²/{ellipse_params['x_coef']:.0f} + y²/{ellipse_params['y_coef']:.0f} = 1  (Green)")
        if has_line:
            equations_parts.append(f"Line: {line_params.get('equation', 'slope defined')} = 0  (Purple)")
        
        equations_text = '\n'.join(equations_parts)
        
        info_text = f"""PROBLEM
{'─'*70}
{problem_text}

EQUATIONS (SDF Zero-Level Sets)
{'─'*70}
{equations_text}

SDF PARAMETERS (Hyperbola)
{'─'*70}
a: {a:.4f}    b: {b:.4f}    c: {c:.4f}
eccentricity: {c/a:.4f}    asymptote slope: ±{slope:.4f}

EXPECTED ANSWER: {problem.get('answer_expressions', '')}
QUERY: {problem.get('query_expressions', '')}
"""
        
        ax_info.text(0.0, 1.0, info_text, transform=ax_info.transAxes,
                    fontsize=10, verticalalignment='top', family='monospace',
                    bbox=dict(boxstyle='round,pad=0.5', facecolor='#E8F4F8', alpha=0.9, edgecolor='#CCCCCC'))
        
        plt.savefig(output_path, bbox_inches='tight', dpi=120, facecolor='white')
        plt.close(fig)
    
    def _visualize_parabola(self, sdf: ParabolaSDF, problem: Dict, params: Dict,
                           output_path: Path):
        """Visualize parabola using SDF zero-level set."""
        
        with torch.no_grad():
            p = abs(sdf.p.item())
        
        direction = params.get('direction', 'right')
        
        # Adjust limits based on direction and p value
        extent = max(p * 8, 6)
        if direction == 'right':
            xlim = (-p * 2, extent)
            ylim = (-extent * 0.8, extent * 0.8)
        elif direction == 'left':
            xlim = (-extent, p * 2)
            ylim = (-extent * 0.8, extent * 0.8)
        else:  # up
            xlim = (-extent * 0.8, extent * 0.8)
            ylim = (-p * 2, extent)
        
        # Use vertical layout
        fig = plt.figure(figsize=(10, 14), dpi=120)
        ax_main = fig.add_axes([0.1, 0.4, 0.8, 0.55])
        
        # Increase resolution slightly to sharpen zero-level near the vertex
        renderer = SDFRenderer(resolution=600, xlim=xlim, ylim=ylim)
        renderer.render_sdf_field(sdf, ax_main, show_field=True)
        
        # Focus and directrix
        if direction == 'right':
            focus = (p, 0)
            ax_main.plot(p, 0, 'ro', markersize=12, label='Focus', zorder=5)
            ax_main.annotate('$F$', (p, 0), xytext=(p+0.4, 0.4), fontsize=14, fontweight='bold')
            ax_main.axvline(x=-p, color='#2ECC71', linestyle='--', linewidth=2, 
                           alpha=0.8, label='Directrix')
            equation = f"y² = {4*p:.2f}x"
        elif direction == 'left':
            focus = (-p, 0)
            ax_main.plot(-p, 0, 'ro', markersize=12, label='Focus', zorder=5)
            ax_main.annotate('$F$', (-p, 0), xytext=(-p-0.6, 0.4), fontsize=14, fontweight='bold')
            ax_main.axvline(x=p, color='#2ECC71', linestyle='--', linewidth=2,
                           alpha=0.8, label='Directrix')
            equation = f"y² = -{4*p:.2f}x"
        else:  # up
            focus = (0, p)
            ax_main.plot(0, p, 'ro', markersize=12, label='Focus', zorder=5)
            ax_main.annotate('$F$', (0, p), xytext=(0.4, p+0.4), fontsize=14, fontweight='bold')
            ax_main.axhline(y=-p, color='#2ECC71', linestyle='--', linewidth=2,
                           alpha=0.8, label='Directrix')
            equation = f"x² = {4*p:.2f}y"
        
        # Plot additional points with staggered labels to reduce overlaps
        coords = self.parser.parse_coordinates(problem.get('fact_expressions', ''))
        for idx, (name, (px, py)) in enumerate(coords.items()):
            if name not in ['F', 'O']:
                ax_main.plot(px, py, 'go', markersize=10, zorder=6)
                offset_y = 0.3 + 0.25 * idx
                ax_main.annotate(f'${name}$', (px, py), xytext=(px + 0.3, py + offset_y),
                                 fontsize=13, fontweight='bold')
        
        ax_main.axhline(y=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.axvline(x=0, color='black', linewidth=0.8, alpha=0.6)
        ax_main.grid(True, alpha=0.3, linestyle='--')
        ax_main.set_xlim(xlim)
        ax_main.set_ylim(ylim)
        ax_main.set_xlabel('x', fontsize=14)
        ax_main.set_ylabel('y', fontsize=14)
        ax_main.set_title('Parabola - SDF Zero-Level Set', fontsize=16, fontweight='bold', pad=10)
        ax_main.set_aspect('equal')
        ax_main.legend(loc='upper right', fontsize=11)
        ax_main.tick_params(labelsize=11)
        
        # Info panel at bottom
        ax_info = fig.add_axes([0.05, 0.02, 0.9, 0.35])
        ax_info.axis('off')
        
        problem_text = self._wrap_text(problem.get('text', ''), width=70)
        
        info_text = f"""PROBLEM
{'─'*70}
{problem_text}

EQUATION (SDF Zero-Level Set)
{'─'*70}
{equation}

SDF PARAMETERS
{'─'*70}
p (focal param): {p:.4f}    focus: {focus}
directrix: {'x = ' + f'{-p:.2f}' if direction in ['right', 'left'] else 'y = ' + f'{-p:.2f}'}
direction: {direction}

EXPECTED ANSWER: {problem.get('answer_expressions', '')}
QUERY: {problem.get('query_expressions', '')}
"""
        
        ax_info.text(0.0, 1.0, info_text, transform=ax_info.transAxes,
                    fontsize=10, verticalalignment='top', family='monospace',
                    bbox=dict(boxstyle='round,pad=0.5', facecolor='#E8F4F8', alpha=0.9, edgecolor='#CCCCCC'))
        
        plt.savefig(output_path, bbox_inches='tight', dpi=120, facecolor='white')
        plt.close(fig)
    
    def process_batch(self, problems: List[Dict], max_problems: int = None,
                     verbose: bool = False) -> List[Dict]:
        """Process a batch of problems."""
        if max_problems:
            problems = problems[:max_problems]
        
        results = []
        stats = {'total': len(problems), 'success': 0, 'failed': 0}
        type_stats = {'ellipse': 0, 'hyperbola': 0, 'parabola': 0, 'circle': 0}
        reason_counts: Dict[str, int] = {}
        
        print(f"\n{'='*60}")
        print(f"SDF-Based Processing: {len(problems)} problems")
        print(f"{'='*60}\n")
        
        for idx, problem in enumerate(tqdm(problems, desc="Processing")):
            result = self.process_problem(problem, idx, verbose)
            results.append(result)
            
            if result['success']:
                stats['success'] += 1
                ctype = result.get('conic_type')
                if ctype in type_stats:
                    type_stats[ctype] += 1
            else:
                stats['failed'] += 1
                for reason in result.get('validation_reasons', []):
                    reason_counts[reason] = reason_counts.get(reason, 0) + 1
        
        # Save summary
        summary = {
            'stats': stats,
            'type_stats': type_stats,
            'reason_counts': reason_counts,
            'results': results
        }
        with open(self.output_dir / 'summary.json', 'w') as f:
            json.dump(summary, f, indent=2, default=str)
        
        print(f"\n{'='*60}")
        print("PROCESSING COMPLETE")
        print(f"{'='*60}")
        print(f"Success: {stats['success']} / {stats['total']} ({100*stats['success']/stats['total']:.1f}%)")
        print(f"By type: {type_stats}")
        print(f"Output: {self.output_dir}")
        
        return results


def main():
    parser = argparse.ArgumentParser(description='SDF-Based Geometry Solver')
    parser.add_argument('--input', '-i', type=str, default='test_en.json')
    parser.add_argument('--output', '-o', type=str, default='sdf_output')
    parser.add_argument('--max', '-m', type=int, default=None)
    parser.add_argument('--verbose', '-v', action='store_true')
    
    args = parser.parse_args()
    
    with open(args.input, 'r', encoding='utf-8') as f:
        problems = json.load(f)
    
    print(f"Loaded {len(problems)} problems")
    
    processor = SDFBatchProcessor(output_dir=args.output)
    processor.process_batch(problems, max_problems=args.max, verbose=args.verbose)


if __name__ == "__main__":
    main()