Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+src/__pycache__/sdf_geo_solver.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+__pycache__/
+*.pyc
+*.egg-info/
+.env

README.md

@@ -0,0 +1,250 @@
+# Image_SDF
+
+**Automatic Diagram Generation for Analytic Geometry Problems using Signed Distance Fields**
+
+<p align="center">
+  <img src="results/test/ellipse/problem_2063.png" width="600" alt="Example Output">
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.9%2B-blue.svg" alt="Python">
+  <img src="https://img.shields.io/badge/PyTorch-2.0%2B-ee4c2c.svg" alt="PyTorch">
+  <img src="https://img.shields.io/badge/Accuracy-96.7%25-brightgreen.svg" alt="Accuracy">
+  <img src="https://img.shields.io/badge/Problems-10,861-orange.svg" alt="Problems">
+  <img src="https://img.shields.io/badge/License-MIT-green.svg" alt="License">
+</p>
+
+---
+
+## Introduction
+
+**Image_SDF** is an automatic system that converts mathematical geometry problem text into accurate visualizations. By leveraging **Signed Distance Fields (SDF)** combined with differentiable optimization, the system can automatically generate precise conic section diagrams from symbolic geometric expressions.
+
+Traditional geometry diagram generation often relies on manual drawing or rule-based methods. This system takes a different approach: it models geometric constraints as differentiable loss functions and uses gradient-based optimization to find curve parameters that satisfy all constraints, ultimately rendering high-quality geometric diagrams.
+
+### Key Features
+
+- **Fully Automated**: Generate PNG diagrams directly from JSON-formatted geometry problems without manual intervention
+- **High Accuracy**: Achieves **96.7%** validation pass rate on parseable problems
+- **Large-Scale Validation**: Tested on **10,861** geometry problems across 3 datasets
+- **Rigorous Verification**: Multi-dimensional geometric property validation including focus position, eccentricity, and asymptote slope
+
+---
+
+## Supported Curve Types
+
+The system supports four classical conic sections, each with complete SDF representation and constraint validation:
+
+| Curve Type | Standard Form | Validated Properties |
+|------------|---------------|---------------------|
+| **Ellipse** | x²/a² + y²/b² = 1 | Focus distance c²=a²-b², eccentricity, points on curve |
+| **Hyperbola** | x²/a² - y²/b² = 1 | Focus distance c²=a²+b², asymptote slope, eccentricity |
+| **Parabola** | y² = 4px | Focus position, directrix equation, points on curve |
+| **Circle** | (x-h)² + (y-k)² = r² | Center position, radius, points on curve |
+
+---
+
+## How It Works
+
+The system follows a four-stage pipeline:
+
+```
+Text Parsing → SDF Construction → Constraint Optimization → Diagram Rendering
+```
+
+### 1. Text Parsing
+
+Extract geometric parameters from mathematical expressions. For example:
+
+```
+Input:  "ellipse x²/4 + y²/9 = 1"
+Output: Ellipse(a=2, b=3, center=(0,0))
+```
+
+The parser supports various expression formats including fractions, radicals, and LaTeX-formatted mathematical expressions.
+
+### 2. SDF Construction
+
+Build a signed distance field function for each curve type. The SDF value represents the signed distance from any point in space to the curve boundary:
+- Positive: point is outside the curve
+- Negative: point is inside the curve
+- Zero: point is exactly on the curve
+
+### 3. Constraint Optimization
+
+Optimize curve parameters via gradient descent to satisfy all geometric constraints:
+
+```python
+# Total loss = point constraint + focus constraint + eccentricity constraint + crowd penalty
+L_total = λ₁·L_point + λ₂·L_focus + λ₃·L_ecc + λ₄·L_crowd
+```
+
+Using the AdamW optimizer, convergence typically occurs within 100-200 iterations.
+
+### 4. Diagram Rendering
+
+Extract the zero-level set of the SDF (i.e., the curve itself) and render in Chinese Gaokao (高考) analytic geometry style: white background, black curves, arrow axes through origin with O/x/y labels, feature point annotations (foci, vertices), and auxiliary elements (asymptotes, directrix) as dashed lines. No problem text, grid, or legend is included in the output.
+
+---
+
+## Datasets and Results
+
+The system has been fully tested on three datasets:
+
+| Dataset | Total Problems | Parseable | Successful | Parseable Accuracy |
+|---------|----------------|-----------|------------|-------------------|
+| dev | 1,035 | 809 | 788 | **97.4%** |
+| test | 2,069 | 1,649 | 1,596 | **96.8%** |
+| train | 7,757 | 6,052 | 5,849 | **96.6%** |
+| **Total** | **10,861** | **8,510** | **8,233** | **96.7%** |
+
+> **Note**: "Parseable" refers to problems with explicit geometric expressions (e.g., x²/4 + y²/9 = 1) rather than implicit or parametric forms. Approximately 22% of problems cannot be parsed due to overly complex or incomplete expressions.
+
+### Curve Type Distribution
+
+| Type | Dev | Test | Train | Total |
+|------|-----|------|-------|-------|
+| Ellipse | 220 | 467 | 1,734 | 2,421 |
+| Hyperbola | 293 | 565 | 2,025 | 2,883 |
+| Parabola | 262 | 532 | 2,000 | 2,794 |
+| Circle | 13 | 32 | 90 | 135 |
+
+---
+
+## Installation and Usage
+
+### Requirements
+
+- Python >= 3.9
+- PyTorch >= 2.0.0
+- NumPy >= 1.24.0
+- Matplotlib >= 3.7.0
+- tqdm >= 4.65.0
+
+### Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### Running Examples
+
+```bash
+# Process test dataset
+python src/main.py --input data/test_en.json --output results/test/
+
+# Process dev dataset
+python src/main.py --input data/dev_en.json --output results/dev/
+
+# Process train dataset (~30 minutes)
+python src/main.py --input data/train_en.json --output results/train/
+
+# Process only first 100 problems with verbose output
+python src/main.py -i data/test_en.json -o results/test/ -m 100 -v
+```
+
+### Command Line Arguments
+
+| Argument | Description | Default |
+|----------|-------------|---------|
+| `-i, --input` | Input JSON file path | `data/test_en.json` |
+| `-o, --output` | Output directory | `results/` |
+| `-m, --max` | Maximum number of problems to process | All |
+| `-v, --verbose` | Enable verbose output | False |
+
+### Python API
+
+```python
+from src.sdf_geo import SDFBatchProcessor
+
+# Create processor
+processor = SDFBatchProcessor(output_dir='results/')
+
+# Batch processing
+results = processor.process_batch('data/test_en.json', max_problems=100)
+
+# Calculate success rate
+success_rate = sum(r['success'] for r in results) / len(results)
+print(f"Success rate: {success_rate:.1%}")
+```
+
+---
+
+## Project Structure
+
+```
+Image_SDF/
+├── data/
+│   ├── dev_en.json          # Dev set (1,035 problems)
+│   ├── test_en.json         # Test set (2,069 problems)
+│   └── train_en.json        # Train set (7,757 problems)
+├── results/
+│   ├── dev/                 # Dev set results
+│   ├── test/                # Test set results
+│   └── train/               # Train set results
+├── samples/                 # Sample images (3 per curve type per dataset)
+├── src/
+│   ├── main.py              # CLI entry point
+│   └── sdf_geo/             # Core modules
+│       ├── primitives.py    # SDF geometric primitives
+│       ├── constraints.py   # Differentiable constraint functions
+│       ├── parser.py        # Expression parser
+│       ├── optimizer.py     # Gradient optimizer
+│       ├── processor.py     # Batch processing, validation & visualization
+│       └── renderer.py      # SDF field evaluation & curve rendering
+├── create_samples.py        # Generate sample images from results
+├── requirements.txt
+└── README.md
+```
+
+---
+
+## Output Format
+
+Each problem generates a PNG image in Chinese Gaokao (高考) analytic geometry style, containing:
+
+- **Geometric Curve**: Black curve rendered from the SDF zero-level set on white background
+- **Feature Point Annotations**: Foci (F₁, F₂), vertices, center, marked as small black dots with labels
+- **Coordinate System**: Arrow axes through origin with O, x, y labels (no grid)
+- **Auxiliary Elements**: Asymptotes and directrix rendered as dashed lines
+
+Results are organized by curve type:
+
+```
+results/test/
+├── summary.json        # Statistics summary
+├── circle/             # Circle diagrams
+├── ellipse/            # Ellipse diagrams
+├── hyperbola/          # Hyperbola diagrams
+└── parabola/           # Parabola diagrams
+```
+
+---
+
+## Validation Standards
+
+The system employs multi-dimensional geometric property validation to ensure mathematical correctness of generated diagrams:
+
+| Validation Item | Tolerance | Description |
+|-----------------|-----------|-------------|
+| Point on curve | 0.03 | SDF(p) ≈ 0 |
+| Eccentricity | 0.05 | \|e_calculated - e_target\| < tol |
+| Focus position | 0.05 | \|c_calculated - c_given\| < tol |
+| Asymptote slope | 0.05 | \|b/a - slope\| < tol |
+
+---
+
+## Methodology
+
+This implementation is based on the methodology described in:
+
+> **GeoSDF: Plane Geometry Diagram Synthesis via Signed Distance Field**  
+> arXiv:2506.13492
+
+The core ideas of using signed distance fields for geometric representation and differentiable optimization for constraint satisfaction are derived from this work.
+
+---
+
+## License
+
+MIT License

annotations/samples.json

@@ -0,0 +1,1009 @@
+[
+  {
+    "dataset": "dev",
+    "index": 6,
+    "conic_type": "circle",
+    "image_path": "samples/dev/circle/problem_0006.png",
+    "problem": {
+      "text": "Given the circle $(x+1)^{2}+y^{2}=36$ with center $M$, let $A$ be any point on the circle, and let $N(1 , 0)$. The perpendicular bisector of segment $AN$ intersects $MA$ at point $P$. Then the trajectory equation of the moving point $P$ is?",
+      "fact_expressions": "G: Circle;Expression(G) = (y^2 + (x + 1)^2 = 36);Center(G) = M;M: Point;A: Point;PointOnCurve(A, G);N: Point;Coordinate(N) = (1, 0);Intersection(PerpendicularBisector(LineSegmentOf(A,N)),LineSegmentOf(M,A)) = P;P: Point",
+      "query_expressions": "LocusEquation(P)",
+      "answer_expressions": "x^2/9+y^2/8=1",
+      "process": "Since the circle $(x+2)^{2}+y^{2}=36$ has center $M(-1,0)$ and radius $r=6$, let point $P(x,y)$. Since the perpendicular bisector of segment $AN$ intersects $MA$ at point $P$, we have $|PN|=|PA|$. Therefore, $|PM|+|PN|=|PM|+|PA|=|MA|=6>|MN|=2$. Hence, the trajectory of point $P$ is an ellipse with foci at $M(-1,0)$ and $N(1,0)$, and major axis length $2a=6$, so $b=\\sqrt{a^{2}-c^{2}}=\\sqrt{9-1}=2\\sqrt{2}$. Thus, the equation of the trajectory of moving point $P$ is $\\frac{x^{2}}{9}+\\frac{y^{2}}{8}=1$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          1.0,
+          0.0
+        ],
+        "radius": 6.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 441,
+    "conic_type": "circle",
+    "image_path": "samples/dev/circle/problem_0441.png",
+    "problem": {
+      "text": "A moving circle is externally tangent to the circle $Q_{1}$: $(x+3)^{2}+y^{2}=1$ and internally tangent to the circle $Q_{2}$: $(x-3)^{2}+y^{2}=81$. Then, the trajectory equation of the center of this moving circle is?",
+      "fact_expressions": "G: Circle;IsOutTangent(G,Q1) = True;Q1: Circle;Expression(Q1) = ((x+3)^2+y^2=1);Q2: Circle;Expression(Q2) = ((x-3)^2+y^2=81);IsInTangent(G,Q2) = True",
+      "query_expressions": "LocusEquation(Center(G))",
+      "answer_expressions": "x^2/25+y^2/16=1",
+      "process": "Let the center of the moving circle be Q(x, y), with radius R. Since the moving circle is externally tangent to the circle Q_{1}:(x+3)^{2}+y^{2}=1 and internally tangent to the circle Q_{2}:(x-3)^{2}+y^{2}=81, we have |QQ_{1}| = R + 1, |QQ_{2}| = 9 - R. Therefore, |QQ_{1}| + |QQ_{2}| = 10 > 6 = |Q_{1}Q_{2}|. Thus, the locus of the center of the moving circle is an ellipse with foci at Q_{1} and Q_{2}. Hence, 2a = 10, a = 5, c = 3, b^{2} = 16. Therefore, the equation of the locus of the center of the moving circle is \\frac{x^{2}}{25}+\\frac{y^{2}}{16}=1."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          -3.0,
+          0.0
+        ],
+        "radius": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 669,
+    "conic_type": "circle",
+    "image_path": "samples/dev/circle/problem_0669.png",
+    "problem": {
+      "text": "Given the circle $C$: $x^{2}+y^{2}=25$, draw a line $l$ through point $M(-2,3)$ intersecting the circle $C$ at points $A$ and $B$. Tangents to the circle are drawn at points $A$ and $B$, respectively. When the two tangents intersect at point $N$, what is the trajectory equation of point $N$?",
+      "fact_expressions": "C: Circle;Expression(C) = (x^2 + y^2 = 25);M: Point;l: Line;Coordinate(M) = (-2, 3);PointOnCurve(M, l);A: Point;B: Point;Intersection(l, C) = {A, B};L1: Line;L2: Line;TangentOnPoint(A,C)=L1;TangentOnPoint(B,C)=L2;N: Point;Intersection(L1, L2) = N",
+      "query_expressions": "LocusEquation(N)",
+      "answer_expressions": "2*x-3*y+25=0",
+      "process": "Consider the following problem: Given a circle $ C: x^{2} + y^{2} = r^{2} $ ($ r > 0 $) and a point $ P(a, b) $. If point $ P $ lies inside $ C $, draw a line $ l $ through $ P $ intersecting $ C $ at points $ A $ and $ B $. Tangents to $ C $ are drawn at points $ A $ and $ B $ respectively. When these two tangents intersect at point $ Q $, find the locus equation of point $ Q $. The center of circle $ C: x^{2} + y^{2} = r^{2} $ is $ (0, 0) $. Let $ A(x_{1}, y_{1}) $, $ B(x_{2}, y_{2}) $, $ Q(x_{0}, y_{0}) $. Since $ AQ $ is tangent to circle $ C $, we have $ AQ \\perp CA $. Therefore, $ (x_{1} - x_{0})(x_{1} - 0) + (y_{1} - y_{0})(y_{1} - 0) = 0 $, that is, $ x^{2}_{1} - x_{0}x_{1} + y^{2}_{1} - y_{0}y_{1} = 0 $. Since $ x^{2} + y^{2} = r^{2} $, it follows that $ x_{0}x_{1} + y_{0}y_{1} = r^{2} $. Similarly, $ x_{0}x_{2} + y_{0}y_{2} = r^{2} $. Hence, the equation of the line passing through points $ A $ and $ B $ is $ xx_{0} + yy_{0} = r^{2} $. Since line $ AB $ passes through point $ (a, b) $, substituting gives $ ax_{0} + by_{0} = r^{2} $. Therefore, the locus equation of point $ Q $ is: $ ax + by = r^{2} $. According to the problem, the locus equation of point $ N $ is $ 2x - 3y + 25 = 0 $."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          0.0,
+          0.0
+        ],
+        "radius": 5.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 1,
+    "conic_type": "ellipse",
+    "image_path": "samples/dev/ellipse/problem_0001.png",
+    "problem": {
+      "text": "Given the ellipse $\\frac{x^{2}}{4}+y^{2}=1$ with left and right foci $F_{1}$, $F_{2}$, point $P$ is a moving point on the ellipse. Then the range of values of $\\overrightarrow{P F_{1}} \\cdot \\overrightarrow{P F_{2}}$ is?",
+      "fact_expressions": "G: Ellipse;P: Point;F1: Point;F2: Point;Expression(G) = (x^2/4 + y^2 = 1);LeftFocus(G) = F1;RightFocus(G) = F2;PointOnCurve(P, G)",
+      "query_expressions": "Range(DotProduct(VectorOf(P, F1), VectorOf(P, F2)))",
+      "answer_expressions": "[-2, 1]",
+      "process": "Let P(x,y) be an arbitrary point on the ellipse, then \\overrightarrow{PF_{1}}=(-\\sqrt{3}-x,-y), \\overrightarrow{PF_{2}}=(\\sqrt{3}-x,-y). Therefore, \\overrightarrow{PF_{1}}\\cdot\\overrightarrow{PF_{2}}=(-\\sqrt{3}-x,-y)\\cdot(\\sqrt{3}-x,-y)=x^{2}+y^{2}-3=x^{2}+1-\\frac{x^{2}}{4}=\\frac{3}{4}x^{2}-2. Since P lies on the ellipse, -2\\leqslant x \\leqslant 2, so -2\\leqslant \\frac{3}{4}x^{2}-2 \\leqslant 1, that is, the range of \\overrightarrow{PF_{1}}\\cdot\\overrightarrow{PF_{2}} is [-2,1]."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.0,
+        "major_axis": "x",
+        "x_coef": 4.0,
+        "y_coef": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 524,
+    "conic_type": "ellipse",
+    "image_path": "samples/dev/ellipse/problem_0524.png",
+    "problem": {
+      "text": "Point $P$ lies on the ellipse $\\frac{x^{2}}{16}+\\frac{y^{2}}{9}=1$. What are the maximum and minimum distances from point $P$ to the line $3x-4y=24$?",
+      "fact_expressions": "G: Ellipse;H: Line;P: Point;Expression(G) = (x^2/16 + y^2/9 = 1);Expression(H) = (3*x - 4*y = 24);PointOnCurve(P, G)",
+      "query_expressions": "Max(Distance(P,H));Min(Distance(P,H))",
+      "answer_expressions": "12*(2+sqrt(2))/5\n12*(2-sqrt(2))/5",
+      "process": "Let the coordinates of point P be (4\\cos\\theta,3\\sin\\theta). The distance d from point P to the line 3x-4y=24 reaches its maximum when \\cos(\\theta+\\frac{\\pi}{4})=-1, and reaches its minimum when \\cos(\\theta+\\frac{\\pi}{4})=1, with the minimum value being \\frac{12(2-}{"
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 4.0,
+        "b": 3.0,
+        "major_axis": "x",
+        "x_coef": 16.0,
+        "y_coef": 9.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 1034,
+    "conic_type": "ellipse",
+    "image_path": "samples/dev/ellipse/problem_1034.png",
+    "problem": {
+      "text": "Given the ellipse $\\frac{x^{2}}{25}+\\frac{y^{2}}{9}=1$, the left and right foci are denoted as $F_{1}$ and $F_{2}$ respectively. A line passing through $F_{1}$ and perpendicular to the major axis intersects the ellipse at points $A$ and $B$. Find the radius of the incircle of triangle $ABF_{2}$.",
+      "fact_expressions": "G: Ellipse;H:Line;A: Point;B: Point;F1: Point;F2: Point;Expression(G) = (x^2/25 + y^2/9 = 1);LeftFocus(G)=F1;RightFocus(G)=F2;PointOnCurve(F1,H);IsPerpendicular(H,MajorAxis(G));Intersection(H,G) = {A, B}",
+      "query_expressions": "Radius(InscribedCircle(TriangleOf(A,B,F2)))",
+      "answer_expressions": "36/25",
+      "process": "According to the problem, let the inradius of $\\triangle ABF_{2}$ be $r$, and the perimeter of the triangle be $4a$. Then, derive the expression for the area of the triangle, use $AF_{1}, BF_{1}$ to find the area of $\\triangle ABF_{2}$, and then determine the inradius. [Detailed Solution] According to the problem, let the inradius of $\\triangle ABF_{2}$ be $r$; the equation of the ellipse is $\\frac{x^{2}}{25}+\\frac{y^{2}}{9}=1$, and the perimeter of the triangle is $20$. Hence, $S=\\frac{1}{2}\\times20\\times r=10r$. The line passing through $F_1$ and perpendicular to the major axis intersects the ellipse at points $A$ and $B$. Then, $AB=2\\sqrt{9(1-\\frac{16}{25})}=\\frac{18}{5}$. Therefore, $S=\\frac{1}{2}\\times8\\times\\frac{18}{5}=\\frac{72}{5}$. Thus, $10r=\\frac{72}{5}$, solving gives $r=\\frac{36}{25}$. Therefore, the inradius is $\\frac{36}{25}$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 5.0,
+        "b": 3.0,
+        "major_axis": "x",
+        "x_coef": 25.0,
+        "y_coef": 9.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 0,
+    "conic_type": "hyperbola",
+    "image_path": "samples/dev/hyperbola/problem_0000.png",
+    "problem": {
+      "text": "From the left focus $F_{1}$ of the hyperbola $\\frac{x^{2}}{16}-\\frac{y^{2}}{25}=1$, draw a tangent to the circle $x^{2}+y^{2}=16$, with the point of tangency $T$. Extend $F_{1} T$ to intersect the right branch of the hyperbola at point $P$. Let $M$ be the midpoint of segment $F_{1} P$, and let $O$ be the origin. Then $|M O|-|M T|$=?",
+      "fact_expressions": "G: Hyperbola;H: Circle;F1: Point;Z: Line;T: Point;P: Point;M: Point;Expression(G) = (x^2/16 - y^2/25 = 1);LeftFocus(G) = F1;Expression(H) = (x^2 + y^2 = 16);TangentOfPoint(F1, H) = Z;TangentPoint(Z, H) = T;Intersection(OverlappingLine(LineSegmentOf(F1, T)), RightPart(G)) = P;MidPoint(LineSegmentOf(F1, P)) = M;O: Origin",
+      "query_expressions": "Abs(LineSegmentOf(M, O)) - Abs(LineSegmentOf(M, T))",
+      "answer_expressions": "1",
+      "process": "Let F' be the right focus of the hyperbola, connect PF'. Since M and O are the midpoints of F_{1}P and F_{1}F' respectively, then |MO| = \\frac{1}{2}|PF'|. By the definition of the hyperbola, |F_{1}P| - |PF'| = 8. Hence, |MO| - |MT| = \\frac{1}{2}|PF| - |MF_{1}| + |F_{1}T| = \\frac{1}{2}(|PF'| - |F_{1}P|) + |F_{1}T| = -4 + 5 = 1"
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 4.0,
+        "b": 5.0,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 537,
+    "conic_type": "hyperbola",
+    "image_path": "samples/dev/hyperbola/problem_0537.png",
+    "problem": {
+      "text": "Given fixed points $A(-5,0)$, $B(5,4)$, and point $P$ being any point on the right branch of the hyperbola $C$: $\\frac{x^{2}}{16}-\\frac{y^{2}}{9}=1$, then the maximum value of $|PB|-|PA|$ is?",
+      "fact_expressions": "C: Hyperbola;A: Point;B: Point;P: Point;Expression(C) = (x^2/16 - y^2/9 = 1);Coordinate(A) = (-5, 0);Coordinate(B) = (5, 4);PointOnCurve(P, RightPart(C))",
+      "query_expressions": "Max(-Abs(LineSegmentOf(P, A)) + Abs(LineSegmentOf(P, B)))",
+      "answer_expressions": "-4",
+      "process": "According to the given conditions, a=4, b=3, so c=\\sqrt{a^{2}+b^{2}}=5; therefore, A(-5,0) is the left focus of the hyperbola, and let the right focus be F(5,0). Thus, |PB|-|PA|=|PB|-(|PF|+2a)=|PB|-|PF|-8\\leqslant|BF|-8=4-8=-4, with equality if and only if points P, F, and B are collinear."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 4.0,
+        "b": 3.0,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "A": [
+          -5.0,
+          0.0
+        ],
+        "B": [
+          5.0,
+          4.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 1033,
+    "conic_type": "hyperbola",
+    "image_path": "samples/dev/hyperbola/problem_1033.png",
+    "problem": {
+      "text": "Given that line $l$ passes through point $P(2, 1)$ and intersects the hyperbola $x^{2}-\\frac{y^{2}}{4}=1$ at points $A$ and $B$, if $P$ is the midpoint of $AB$, then what is the equation of line $l$?",
+      "fact_expressions": "l: Line;P: Point;Coordinate(P) = (2, 1);PointOnCurve(P, l);G: Hyperbola;Expression(G) = (x^2 - y^2/4 = 1);Intersection(l, G) = {A, B};A: Point;B: Point;MidPoint(LineSegmentOf(A, B)) = P",
+      "query_expressions": "Expression(l)",
+      "answer_expressions": "8*x-y-15=0",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 1.0,
+        "b": 2.0,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "P": [
+          2.0,
+          1.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 2,
+    "conic_type": "parabola",
+    "image_path": "samples/dev/parabola/problem_0002.png",
+    "problem": {
+      "text": "The coordinates of the focus of the parabola $y^{2}=4 x$ are?",
+      "fact_expressions": "G: Parabola;Expression(G) = (y^2 = 4*x)",
+      "query_expressions": "Coordinate(Focus(G))",
+      "answer_expressions": "(1, 0)",
+      "process": "The focus of the parabola y^{2}=4x lies on the x-axis, and p=2, \\therefore\\frac{p}{2}=1, so the focus coordinates of the parabola y^{2}=4x are (1,0)."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 1.0,
+        "direction": "right"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 508,
+    "conic_type": "parabola",
+    "image_path": "samples/dev/parabola/problem_0508.png",
+    "problem": {
+      "text": "Given the parabola $y^{2}=4x$ with focus $F$, $A(-1,0)$, and point $P$ being a moving point on the parabola, when the value of $|PF|$ is minimized, $|PF|=$?",
+      "fact_expressions": "G: Parabola;A: Point;P: Point;F: Point;Expression(G) = (y^2 = 4*x);Coordinate(A) = (-1, 0);Focus(G) = F;PointOnCurve(P, G);WhenMin(Abs(LineSegmentOf(P, F)))",
+      "query_expressions": "Abs(LineSegmentOf(P, F))",
+      "answer_expressions": "2",
+      "process": "The equation of the directrix of the parabola is x = -1. Let the distance from P to the directrix be |PQ|, then |PQ| = |PF|, \\therefore \\frac{|PF|}{|PA|} = \\frac{|PQ|}{|PA|} = \\sin\\angle PAQ. Therefore, when PA is tangent to the parabola y^{2} = 4x, \\angle PAQ is minimized, i.e., \\frac{|PF|}{|PA|} reaches its minimum value. Suppose the line passing through point A, y = kx + k, is tangent to the parabola (k \\neq 0). Substituting into the parabola equation gives k^{2}x^{2} + (2k^{2} - 4)x + k^{2} = 0. \\therefore \\Delta = (2k^{2} - 4)^{2} - 4k^{4} = 0. Solving yields k = \\pm 1. Then we have x^{2} - 2x + 1 = 0, solving gives x = 1. Substituting x = 1 into y^{2} = 4x gives y = \\pm 2. \\therefore P(1,2) or P(1,-2), \\therefore |PF| = 2."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 1.0,
+        "direction": "right"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "A": [
+          -1.0,
+          0.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "dev",
+    "index": 1030,
+    "conic_type": "parabola",
+    "image_path": "samples/dev/parabola/problem_1030.png",
+    "problem": {
+      "text": "Given point $P(1,-1)$ and parabola $C$: $y=\\frac{1}{4} x^{2}$, a line passing through the focus of parabola $C$ with slope $k$ intersects parabola $C$ at points $A$ and $B$. If $\\overrightarrow{P A} \\cdot \\overrightarrow{P B}=0$, then $k=?$",
+      "fact_expressions": "P: Point;Coordinate(P) = (1, -1);C: Parabola;Expression(C) = (y = x^2/4);G: Line;PointOnCurve(Focus(C), G);k: Number;Slope(G) = k;A: Point;B: Point;Intersection(G, C) = {A, B};DotProduct(VectorOf(P, A), VectorOf(P, B)) = 0",
+      "query_expressions": "k",
+      "answer_expressions": "1/2",
+      "process": "Let the parabola C: y = \\frac{1}{4}x^{2} have focus F; then the coordinates of F are (0,1). Thus, the equation of line AB is y = kx + 1. Let points A(x_{1},y_{1}) and B(x_{2},y_{2}). Substituting the equation of line AB into the equation of parabola C and simplifying yields x^{2} - 4kx - 4 = 0. Then x_{1} + x_{2} = 4k, x_{1}x_{2} = -4. From \\overrightarrow{PA} \\cdot \\overrightarrow{PB} = 0, we obtain (x_{1}-1)(x_{2}-1) + (y_{1}+1)(y_{2}+1) = 0, that is, (x_{1}-1)(x_{2}-1) + (kx_{1}+2)(kx_{2}+2) = 0, which simplifies to (k^{2}+1)x_{1}x_{2} + (2k-1)(x_{1}+x_{2}) + 5 = 0. Therefore, -4(k^{2}+1) + 4k(2k-1) + 5 = (2k-1)^{2} = 0. Solving gives k = \\frac{1}{2}."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 1.0,
+        "direction": "up"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "P": [
+          1.0,
+          -1.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 4,
+    "conic_type": "circle",
+    "image_path": "samples/test/circle/problem_0004.png",
+    "problem": {
+      "text": "The product of the slopes of the lines connecting a moving point $P$ to fixed points $A(-1,0)$ and $B(1,0)$ is $-1$. Then, what is the trajectory equation of point $P$?",
+      "fact_expressions": "P: Point;Slope(LineSegmentOf(P, A))*Slope(LineSegmentOf(P, B)) = -1;A: Point;Coordinate(A) = (-1, 0);B: Point;Coordinate(B) = (1, 0)",
+      "query_expressions": "LocusEquation(P)",
+      "answer_expressions": "(x^2+y^2=1)&Negation(x=pm*1)",
+      "process": "Let P(x,y), then k_{PA}=\\frac{y-0}{x+1}, k_{PB}=\\frac{y-0}{x-1}. Since the product of the slopes of the lines joining the moving point P and the fixed points A(-1,0), B(1,0) is -1, \\therefore k_{PA} \\cdot k_{PB} = -1, \\therefore \\frac{y^{2}}{x^{2}-1} = -1, that is, x^{2} + y^{2} = 1, and x \\neq \\pm 1. In conclusion, the trajectory equation of point P is x^{2} + y^{2} = 1 (x \\neq \\pm 1)."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          0.0,
+          0.0
+        ],
+        "radius": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 1202,
+    "conic_type": "circle",
+    "image_path": "samples/test/circle/problem_1202.png",
+    "problem": {
+      "text": "Given a line $ l $ with slope $ 1 $ and positive $ y $-intercept $ b $ that intersects the circle $ C: x^{2} + y^{2} = 4 $ at points $ A $ and $ B $, and $ O $ is the origin. If the area of $ \\triangle AOB $ is $ \\sqrt{3} $, then $ b = $?",
+      "fact_expressions": "l: Line;C: Circle;A: Point;O: Origin;B: Point;b: Number;Expression(C) = (x^2 + y^2 = 4);Slope(l)=1;b>0;Intercept(l,yAxis)=b;Intersection(l, C) = {A, B};Area(TriangleOf(A, O, B)) = sqrt(3)",
+      "query_expressions": "b",
+      "answer_expressions": "{sqrt(6),sqrt(2)}",
+      "process": "According to the problem, the equation of line $ l $ is $ y = x + b $, the center of circle $ C $ is $ C(0,0) $, and the radius is $ r = 2 $. Using the point-to-line distance formula, $ \\frac{1}{2} \\cdot 2\\sqrt{4 - \\frac{b^{2}}{2}} \\cdot \\frac{|b|}{\\sqrt{3}} = \\sqrt{3} $. Given $ b > 0 $, solving yields $ b = \\sqrt{6} $ or $ \\sqrt{2} $."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          0.0,
+          0.0
+        ],
+        "radius": 2.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 1992,
+    "conic_type": "circle",
+    "image_path": "samples/test/circle/problem_1992.png",
+    "problem": {
+      "text": "Given that the moving circle $P$ is externally tangent to the fixed circle $C$: $(x+2)^{2}+y^{2}=1$, and also tangent to the line $x=1$, what is the equation of the locus of the center $P$ of the moving circle?",
+      "fact_expressions": "P: Circle;G: Line;C:Circle;P1:Point;Expression(C)=((x+2)^2+y^2=1);Expression(G) = (x = 1);IsOutTangent(P,C);IsTangent(P,G);Center(P)=P1",
+      "query_expressions": "LocusEquation(P1)",
+      "answer_expressions": "y^2=-8*x",
+      "process": "Let the distance from the center P of a circle to the line x=1 be equal to r, and let P(x,y). According to the given condition, we have PC = 1 + r, that is, \\sqrt{(x+2)^{2}+y^{2}} = 1 + r. Simplifying yields y^{2} = -8x."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          -2.0,
+          0.0
+        ],
+        "radius": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 1,
+    "conic_type": "ellipse",
+    "image_path": "samples/test/ellipse/problem_0001.png",
+    "problem": {
+      "text": "An ellipse $\\frac{x^{2}}{k^{2}}+y^{2}=1$ $(k>0)$ has a focus at $(3 , 0)$, then $k=$?",
+      "fact_expressions": "G: Ellipse;Expression(G) = (y^2 + x^2/k^2 = 1);k: Number;k>0;Coordinate(OneOf(Focus(G))) = (3,0)",
+      "query_expressions": "k",
+      "answer_expressions": "sqrt(10)",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.0,
+        "major_axis": "x",
+        "x_coef": 4.0,
+        "y_coef": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 1083,
+    "conic_type": "ellipse",
+    "image_path": "samples/test/ellipse/problem_1083.png",
+    "problem": {
+      "text": "The equation of a hyperbola that shares the same foci with the ellipse $x^{2}+4 y^{2}=16$ and has an asymptote given by $x+ \\sqrt {3} y=0$ is?",
+      "fact_expressions": "G: Hyperbola;H: Ellipse;Expression(H)=(x^2 + 4*y^2 = 16);Focus(H) = Focus(G);Expression(OneOf(Asymptote(G))) = (x + sqrt(3)*y = 0)",
+      "query_expressions": "Expression(G)",
+      "answer_expressions": "x^2/9-y^2/3=1",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 4.0,
+        "b": 2.0,
+        "major_axis": "x",
+        "x_coef": 16.0,
+        "y_coef": 4.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 2067,
+    "conic_type": "ellipse",
+    "image_path": "samples/test/ellipse/problem_2067.png",
+    "problem": {
+      "text": "Given that the foci of the ellipse $\\frac{x^{2}}{9}+\\frac{y^{2}}{2}=1$ are $F_{1}$ and $F_{2}$ respectively, and point $P$ lies on the ellipse. If $|P F_{1}|=4$, then the area of triangle $F_{1} P F_{2}$ is?",
+      "fact_expressions": "G: Ellipse;Expression(G) = (x^2/9 + y^2/2 = 1);F1: Point;F2: Point;Focus(G) = {F1, F2};P: Point;PointOnCurve(P, G);Abs(LineSegmentOf(P, F1)) = 4",
+      "query_expressions": "Area(TriangleOf(F1, P, F2))",
+      "answer_expressions": "2*sqrt(3)",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 3.0,
+        "b": 1.4142135623730951,
+        "major_axis": "x",
+        "x_coef": 9.0,
+        "y_coef": 2.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 0,
+    "conic_type": "hyperbola",
+    "image_path": "samples/test/hyperbola/problem_0000.png",
+    "problem": {
+      "text": "If the two foci of a hyperbola are $F_{1}(-3,0)$, $F_{2}(3,0)$, and one asymptote has equation $y=\\sqrt{2} x$, then the equation of this hyperbola is?",
+      "fact_expressions": "G: Hyperbola;F1: Point;F2: Point;Coordinate(F1) = (-3, 0);Coordinate(F2) = (3, 0);Focus(G)={F1,F2};Expression(OneOf(Asymptote(G))) = (y = sqrt(2)*x)",
+      "query_expressions": "Expression(G)",
+      "answer_expressions": "x^2/3-y^2/6=1",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 1.732385540716972,
+        "b": 2.4497476064802375,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 2.601017381791051e-06,
+        "converged": true,
+        "iterations": 91
+      },
+      "coords": {
+        "F1": [
+          -3.0,
+          0.0
+        ],
+        "F2": [
+          3.0,
+          0.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 969,
+    "conic_type": "hyperbola",
+    "image_path": "samples/test/hyperbola/problem_0969.png",
+    "problem": {
+      "text": "Given that $P$ is an intersection point of the ellipse $\\frac{x^{2}}{a_{1}^{2}}+\\frac{y^{2}}{b_{1}^{2}}=1$ $(a_{1}>b_{1}>0)$ and the hyperbola $\\frac{x^{2}}{a_{2}^{2}}-\\frac{y^{2}}{b_{2}^{2}}=1$ $(a_{2}>0, b_{2}>0)$, $F_{1}$, $F_{2}$ are the common foci of the ellipse and the hyperbola, $e_{1}$, $e_{2}$ are the eccentricities of the ellipse and the hyperbola respectively, and if $\\angle F_{1} P F_{2}=\\frac{\\pi}{3}$, then the minimum value of $e_{1} \\cdot e_{2}$ is?",
+      "fact_expressions": "G: Hyperbola;H: Ellipse;a2: Number;b2: Number;a1: Number;b1: Number;F1: Point;P: Point;F2: Point;a2>0;b2>0;Expression(G) = (-y^2/b2^2 + x^2/a2^2 = 1);a1>b1;b1>0;Expression(H) = (y^2/b1^2 + x^2/a1^2 = 1);OneOf(Intersection(H, G)) = P;Focus(G) = {F1, F2};Focus(H) = {F1, F2};Focus(G) = Focus(H);e1: Number;e2: Number;Eccentricity(H) = e1;Eccentricity(G) = e2;AngleOf(F1, P, F2) = pi/3",
+      "query_expressions": "Min(e1*e2)",
+      "answer_expressions": "sqrt(3)/2",
+      "process": "By the symmetry of the ellipse and hyperbola, assume without loss of generality that point P lies in the first quadrant, so |PF_{1}| > |PF_{2}|. Since the ellipse and hyperbola share common foci, let the semi-focal length of the ellipse and hyperbola be c. By the definitions of the ellipse and hyperbola, we have: |PF_{1}| + |PF_{2}| = 2a_{1}, |PF_{1}| - |PF_{2}| = 2a_{2}. Solving gives |PF_{1}| = a_{1} + a_{2}, |PF_{2}| = a_{1} - a_{2}. In triangle F_{1}PF_{2}, by the law of cosines, we obtain: |F_{1}F_{2}|^{2} = |PF_{1}|^{2} + |PF_{2}|^{2} - 2|PF_{1}||PF_{2}|\\cos\\frac{\\pi}{3}, that is, 4c^{2} = (a_{1}+a_{2})^{2} + (a_{1}-a_{2})^{2} - (a_{1}+a_{2})(a_{1}-a_{2}). Simplifying yields 4c^{2} = a_{1}^{2} + 3a_{2}^{2}, so \\frac{1}{e_{1}^{2}} + 3\\frac{1}{e_{2}^{2}} = 4. Also, \\frac{1}{e_{1}^{2}} + 3\\frac{1}{e_{2}^{2}} \\geqslant \\frac{2\\sqrt{3}}{e_{1}e_{2}}, therefore e_{1}e_{2} \\geqslant \\frac{\\sqrt{3}}{2}."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.5,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 2065,
+    "conic_type": "hyperbola",
+    "image_path": "samples/test/hyperbola/problem_2065.png",
+    "problem": {
+      "text": "Through the right focus $F$ of the hyperbola $\\frac{x^{2}}{a^{2}}-\\frac{y^{2}}{b^{2}}=1$ $(a>0, b>0)$, draw a perpendicular line to the asymptote $y=\\frac{b}{a}x$, with foot of perpendicular at $M$. This line intersects the left and right branches of the hyperbola at points $A$ and $B$ respectively. Find the range of values for the eccentricity of the hyperbola?",
+      "fact_expressions": "G: Hyperbola;b: Number;a: Number;F: Point;A: Point;B: Point;M:Point;a>0;b>0;Expression(G) = (-y^2/b^2 + x^2/a^2 = 1);RightFocus(G) = F;L:Line;OneOf(Asymptote(G))=L;Expression(L)=(y=(b/a)*x);L1:Line;IsPerpendicular(L,L1);FootPoint(L,L1)=M;PointOnCurve(F, L1);Intersection(L1,LeftPart(G)) = A;Intersection(L1,RightPart(G)) = B",
+      "query_expressions": "Range(Eccentricity(G))",
+      "answer_expressions": "(sqrt(2),+oo)",
+      "process": "Since line AB intersects both the left and right branches of the hyperbola, line AB must intersect the asymptote y=-\\frac{b}{a}x in the second quadrant. Therefore, the slope of line AB must be greater than the slope of the asymptote y=-\\frac{b}{a}x, that is, -\\frac{a}{b}>-\\frac{b}{a}, which implies b^{2}>a^{2}. Since b^{2}=c^{2}-a^{2}, it follows that c^{2}>2a^{2}. The eccentricity of the hyperbola e=\\frac{c}{a}>\\sqrt{2}. Therefore, the range of values for the eccentricity of the hyperbola is (\\sqrt{2},+\\infty)."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.5,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 2,
+    "conic_type": "parabola",
+    "image_path": "samples/test/parabola/problem_0002.png",
+    "problem": {
+      "text": "Given any point $P$ on the parabola $y^{2}=4 x$, let $d$ be the distance from point $P$ to the $y$-axis. For a given point $A(4,5)$, what is the minimum value of $|P A|+d$?",
+      "fact_expressions": "G: Parabola;A: Point;P: Point;Expression(G) = (y^2 = 4*x);Coordinate(A) = (4, 5);PointOnCurve(P,G);Distance(P, yAxis) = d;d:Number",
+      "query_expressions": "Min(d + Abs(LineSegmentOf(P, A)))",
+      "answer_expressions": "sqrt(34)-1",
+      "process": "The directrix of the parabola is x = -1. Extending the distance from P to the y-axis one unit further to the left gives the distance from P to the directrix. According to the definition of a parabola, the distance from P to the directrix equals the distance from P to the focus F(1,0). Therefore, |PA| + d = |PA| + |PF| - 1. Since A lies outside the parabola, the minimum value occurs when A, P, and F are collinear (i.e., P is the intersection point of segment AF and the parabola). The minimum value is |AF| - 1 = \\sqrt{(9+25)} - 1 = \\sqrt{34} - 1^{n}"
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 1.0,
+        "direction": "right"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "A": [
+          4.0,
+          5.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 1025,
+    "conic_type": "parabola",
+    "image_path": "samples/test/parabola/problem_1025.png",
+    "problem": {
+      "text": "The focus of the parabola $y^{2}=2 x$ is $F$. If $P(2, y)$ lies on the parabola, then $|PF|=$?",
+      "fact_expressions": "G: Parabola;F: Point;P: Point;y1: Number;Expression(G) = (y^2 = 2*x);Coordinate(P) = (2, y1);Focus(G) = F;PointOnCurve(P, G)",
+      "query_expressions": "Abs(LineSegmentOf(P, F))",
+      "answer_expressions": "5/2",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 0.5,
+        "direction": "right"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "test",
+    "index": 2068,
+    "conic_type": "parabola",
+    "image_path": "samples/test/parabola/problem_2068.png",
+    "problem": {
+      "text": "Let $F$ be the focus of the parabola $C$: $y^{2}=8 x$. A line passing through $F$ with an inclination angle of $30^{\\circ}$ intersects $C$ at points $A$ and $B$. Then $|A B|$=?",
+      "fact_expressions": "C: Parabola;Expression(C) = (y^2 = 8*x);F: Point;Focus(C) = F;G: Line;PointOnCurve(F, G);Inclination(G) = ApplyUnit(30, degree);A: Point;B: Point;Intersection(G, C) = {A, B}",
+      "query_expressions": "Abs(LineSegmentOf(A, B))",
+      "answer_expressions": "32",
+      "process": "From $ y^{2} = 8x $, we get $ 2p = 8 $, $ p = 4 $, then $ F(2,0) $. Therefore, the equation of the line passing through $ A $ and $ B $ is $ y = \\frac{\\sqrt{3}}{3}(x - 2) $. Solving the system  \n\\[\n\\begin{cases}\ny^{2} = 8x \\\\\ny = \\frac{\\sqrt{3}}{3}(x - 2)\n\\end{cases}\n\\]\nyields $ x^{2} - 28x + 4 = 0 $. Let $ A(x_{1}, y_{1}) $, $ B(x_{2}, y_{2}) $, then $ x_{1} + x_{2} = 28 $, and since $ |AB| = x_{1} + x_{2} + p = 28 + 4 = 32 $."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 2.0,
+        "direction": "right"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 85,
+    "conic_type": "circle",
+    "image_path": "samples/train/circle/problem_0085.png",
+    "problem": {
+      "text": "The two foci of the ellipse $x^{2}+k y^{2}=1$ lie on the circle $x^{2}+y^{2}=4$. Then the real number $k$=?",
+      "fact_expressions": "G: Ellipse;k: Real;H: Circle;Expression(G) = (k*y^2 + x^2 = 1);Expression(H) = (x^2 + y^2 = 4);PointOnCurve(Focus(G), H)",
+      "query_expressions": "k",
+      "answer_expressions": "1/5",
+      "process": "Since the two foci of the ellipse $x^{2}+ky^{2}=1$ lie on the circle $x^{2}+y^{2}=4$, we have $c=2$. Because $x^{2}+\\frac{y^{2}}{\\frac{1}{k}}=1$, when $0<k<1$, $a^{2}=\\frac{1}{k}$, $b^{2}=1$, and from $a^{2}=b^{2}+c^{2}$ we obtain $k=\\frac{1}{5}$. When $k>1$, $b^{2}=\\frac{1}{k}$, $a^{2}=1$, which does not hold. Therefore, $k=\\frac{1}{5}$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          0.0,
+          0.0
+        ],
+        "radius": 2.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 4027,
+    "conic_type": "circle",
+    "image_path": "samples/train/circle/problem_4027.png",
+    "problem": {
+      "text": "Given the circle $(x+2)^{2}+y^{2}=64$ with center $M$, let $A$ be any point on the circle, and let $N(2,0)$. The perpendicular bisector of segment $AN$ intersects $MA$ at point $P$. What is the equation of the locus of the moving point $P$?",
+      "fact_expressions": "G: Circle;Expression(G) = (y^2 + (x + 2)^2 = 64);M: Point;Center(G) = M;A: Point;PointOnCurve(A, G);N: Point;Coordinate(N) = (2, 0);P: Point;Intersection(PerpendicularBisector(LineSegmentOf(A, N)), LineSegmentOf(M, A)) = P",
+      "query_expressions": "LocusEquation(P)",
+      "answer_expressions": "x^2/16+y^2/12=1",
+      "process": "According to the problem, the circle $(x+2)^{2}+y^{2}=64$ has center $M(-2,0)$, and point $N(2,0)$. The perpendicular bisector of segment $AN$ intersects $MA$ at point $P$. Therefore, $P$ lies on the perpendicular bisector of $AN$, so $PA=PN$. Also, since $|AM|=8$, the point $P$ satisfies $|PM|+|PN|=8>4$. According to the definition of an ellipse, the locus of point $P$ is an ellipse with foci $M$ and $N$, where $2a=8$, $2c=4$, giving $a=4$, $c=2$, so $b=\\sqrt{a^{2}-c^{2}}=\\sqrt{12}$. Thus, the equation of the ellipse is $\\frac{x^{2}}{16}+\\frac{y^{2}}{12}=1$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          2.0,
+          0.0
+        ],
+        "radius": 8.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 7579,
+    "conic_type": "circle",
+    "image_path": "samples/train/circle/problem_7579.png",
+    "problem": {
+      "text": "If from any point $P$ on the circle $x^{2}+y^{2}=1$, a perpendicular line segment is drawn to the $y$-axis, then the trajectory equation of the midpoint $M$ of this line segment is?",
+      "fact_expressions": "G: Circle;H: LineSegment;Expression(G) = (x^2 + y^2 = 1);PointOnCurve(P,G);IsPerpendicular(H,yAxis);M:Point;MidPoint(H)=M;P:Point",
+      "query_expressions": "LocusEquation(M)",
+      "answer_expressions": "4*x^2+y^2=1",
+      "process": "Let the coordinates of point M be (x, y) and the coordinates of point P be (x_{0}, y_{0}). Then from the given conditions, we have x = \\frac{x_{0}}{2}, y = y_{0}. Since P(x_{0}, y_{0}) lies on the circle x^{2} + y^{2} = 1, it follows that x_{0}^{2} + y_{0}^{2} = 1. Substituting x_{0} = 2x, y_{0} = y into the equation x_{0}^{2} + y_{0}^{2} = 1, we obtain 4x^{2} + y^{2} = 1. Therefore, the trajectory equation of point M is 4x^{2} + y^{2} = 1."
+    },
+    "sdf_annotation": {
+      "params": {
+        "center": [
+          0.0,
+          0.0
+        ],
+        "radius": 1.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 0,
+    "conic_type": "ellipse",
+    "image_path": "samples/train/ellipse/problem_0000.png",
+    "problem": {
+      "text": "The eccentricity of the ellipse $\\frac{x^{2}}{2}+\\frac{y^{2}}{3}=1$ is?",
+      "fact_expressions": "G: Ellipse;Expression(G) = (x^2/2 + y^2/3 = 1)",
+      "query_expressions": "Eccentricity(G)",
+      "answer_expressions": "sqrt(3)/3",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 1.7320508075688772,
+        "b": 1.4142135623730951,
+        "major_axis": "y",
+        "x_coef": 2.0,
+        "y_coef": 3.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 3849,
+    "conic_type": "ellipse",
+    "image_path": "samples/train/ellipse/problem_3849.png",
+    "problem": {
+      "text": "Given the parabola $C_{1}$: $y=a x^{2}  (a>0)$, the focus $F$ of which is also a focus of the ellipse $C_{2}$: $\\frac{y^{2}}{4}+\\frac{x^{2}}{b^{2}}=1  (b>0)$. Points $M$ and $P(\\frac{3}{2}, 1)$ are on curves $C_{1}$ and $C_{2}$ respectively. Then the minimum value of $|M P|+|M F|$ is?",
+      "fact_expressions": "C1: Parabola;Expression(C1) = (y = a*x^2);a: Number;a>0;F: Point;Focus(C1) = F;C2: Ellipse;Expression(C2) = (y^2/4 + x^2/b^2 = 1);b: Number;b>0;OneOf(Focus(C2)) = F;M: Point;PointOnCurve(M, C1);P: Point;Coordinate(P) = (3/2, 1);PointOnCurve(P, C2)",
+      "query_expressions": "Min(Abs(LineSegmentOf(M, F)) + Abs(LineSegmentOf(M, P)))",
+      "answer_expressions": "2",
+      "process": "Since point $ P\\left(\\frac{3}{2},1\\right) $ lies on the ellipse $ C_{2} $, and $ b>0 $, we have $ \\frac{1}{4}+\\frac{\\left(\\frac{3}{2}\\right)^{2}}{b^{2}}=1 \\Rightarrow b=\\sqrt{3} $, so the coordinates of focus $ F $ are $ (0,1) $. Also, from the equation of parabola $ C_{1} $, we get $ F\\left(0,\\frac{1}{4a}\\right) $, so $ \\frac{1}{4a}=1 \\Rightarrow a=\\frac{1}{4} $, then $ c_{1}: y=\\frac{1}{4}x^{2} $. By the definition of the parabola, $ |MF| $ equals the distance $ d $ from point $ M $ to its directrix $ l: y=-1 $. Draw a perpendicular line $ l': x=\\frac{3}{2} $ from point $ P $ to the directrix $ l: y=-1 $. Then the intersection point of the perpendicular line $ l': x=\\frac{3}{2} $ and the parabola $ C_{1}: y=\\frac{1}{4}x^{2} $ is the desired point $ M $. Therefore, the minimum value of $ |MP|+|MF|=|MP|+d $ is $ 1-(-1)=2 $."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 1.8537487983703613,
+        "b": 1.6118527266061986,
+        "major_axis": "x",
+        "x_coef": 4.0,
+        "y_coef": 3.0
+      },
+      "optimization": {
+        "final_loss": 1.4665974334810584e-06,
+        "converged": true,
+        "iterations": 90
+      },
+      "coords": {
+        "P": [
+          1.5,
+          1.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 7753,
+    "conic_type": "ellipse",
+    "image_path": "samples/train/ellipse/problem_7753.png",
+    "problem": {
+      "text": "The eccentricity of the ellipse $\\frac{y^{2}}{3}+x^{2}=1$ is?",
+      "fact_expressions": "G: Ellipse;Expression(G) = (x^2 + y^2/3 = 1)",
+      "query_expressions": "Eccentricity(G)",
+      "answer_expressions": "sqrt(6)/3",
+      "process": "Find the values of a, b, and c, then determine the eccentricity of the ellipse \\frac{y^{2}}{3}+x^{2}=1. In the ellipse \\frac{y^{2}}{3}+x^{2}=1, a=\\sqrt{3}, b=1, c=\\sqrt{a^{2}-b^{2}}=\\sqrt{2}. Therefore, the eccentricity of the ellipse \\frac{y^{2}}{3}+x^{2}=1 is e=\\frac{c}{a}=\\frac{\\sqrt{2}}{\\sqrt{3}}=\\frac{\\sqrt{6}}{3}"
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.0,
+        "major_axis": "y",
+        "x_coef": 1.0,
+        "y_coef": 4.0
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 1,
+    "conic_type": "hyperbola",
+    "image_path": "samples/train/hyperbola/problem_0001.png",
+    "problem": {
+      "text": "Given that one asymptote of the hyperbola $\\frac{x^{2}}{4}-\\frac{y^{2}}{m^{2}}=1$ $(m>0)$ is $5 x-2 y=0$, then $m=$?",
+      "fact_expressions": "G: Hyperbola;m: Number;m>0;Expression(G) = (x^2/4 - y^2/m^2 = 1);Expression(OneOf(Asymptote(G))) = (5*x - 2*y = 0)",
+      "query_expressions": "m",
+      "answer_expressions": "5",
+      "process": "The asymptotes of the hyperbola $\\frac{x^{2}}{4}-\\frac{y^{2}}{m^{2}}=1$ $(m>0)$ are given by $y=\\pm\\frac{m}{2}x$. The equation of the line $5x-2y=0$ can be rewritten as $y=\\frac{5}{2}x$, so $m=5$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 1.5,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 3822,
+    "conic_type": "hyperbola",
+    "image_path": "samples/train/hyperbola/problem_3822.png",
+    "problem": {
+      "text": "The distance from the focus of the hyperbola $\\frac{x^{2}}{4}-\\frac{y^{2}}{12}=1$ to its asymptote is?",
+      "fact_expressions": "G: Hyperbola;Expression(G) = (x^2/4 - y^2/12 = 1)",
+      "query_expressions": "Distance(Focus(G), Asymptote(G))",
+      "answer_expressions": "Preserve all mathematical expressions exactly (including LaTeX format, symbols, and numbers).  \nDo not add explanations.",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 2.0,
+        "b": 3.4641016151377544,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 7756,
+    "conic_type": "hyperbola",
+    "image_path": "samples/train/hyperbola/problem_7756.png",
+    "problem": {
+      "text": "Given the hyperbola $\\frac{x^{2}}{3}-y^{2}=1$, the left and right foci are $F_{1}$ and $F_{2}$ respectively, $P$ is a point on the right branch of the hyperbola, and the coordinates of point $Q$ are $(-2,3)$. Then the minimum value of $|P Q|+|P F_{1}|$ is?",
+      "fact_expressions": "G: Hyperbola;Expression(G) = (x^2/3 - y^2 = 1);F1: Point;F2: Point;LeftFocus(G) = F1;RightFocus(G) = F2;P: Point;PointOnCurve(P, RightPart(G));Q: Point;Coordinate(Q) = (-2, 3)",
+      "query_expressions": "Min(Abs(LineSegmentOf(P, F1)) + Abs(LineSegmentOf(P, Q)))",
+      "answer_expressions": "5+2*sqrt(3)",
+      "process": ""
+    },
+    "sdf_annotation": {
+      "params": {
+        "a": 1.7320508075688772,
+        "b": 1.0,
+        "orientation": "horizontal"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {
+        "Q": [
+          -2.0,
+          3.0
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 4,
+    "conic_type": "parabola",
+    "image_path": "samples/train/parabola/problem_0004.png",
+    "problem": {
+      "text": "The parabola $x^{2}=a y$ passes through the point $A(1, \\frac{1}{4})$, then the distance from point $A$ to the focus of this parabola is?",
+      "fact_expressions": "G: Parabola;Expression(G) = (x^2 = a*y);a: Number;A: Point;Coordinate(A) = (1, 1/4);PointOnCurve(A, G)",
+      "query_expressions": "Distance(A, Focus(G))",
+      "answer_expressions": "5/4",
+      "process": "\\because the parabola x^{2}=ay passes through point A(1,\\frac{1}{4}), \\therefore 1^{2}=a\\times\\frac{1}{4}, solving gives a=4. Therefore, the equation of the parabola is x^{2}=4y, yielding its focus at F(0,1) and directrix equation y=-1. \\because the distance from any point on the parabola to the focus equals the distance from that point to the directrix of the parabola, \\therefore the distance from point A to the focus of this parabola is y_{4}-(-1)=\\frac{1}{4}+1=\\frac{5}{4}"
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 0.9959803819656372,
+        "direction": "up"
+      },
+      "optimization": {
+        "final_loss": 3.6780886603082763e-07,
+        "converged": true,
+        "iterations": 56
+      },
+      "coords": {
+        "A": [
+          1.0,
+          0.25
+        ]
+      }
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 3812,
+    "conic_type": "parabola",
+    "image_path": "samples/train/parabola/problem_3812.png",
+    "problem": {
+      "text": "A point $M$ on the parabola $y=4 x^{2}$ is at a distance of $1$ from the focus. What is the ordinate of point $M$?",
+      "fact_expressions": "G: Parabola;Expression(G) = (y = 4*x^2);M: Point;PointOnCurve(M, G);Distance(M, Focus(G)) = 1",
+      "query_expressions": "YCoordinate(M)",
+      "answer_expressions": "15/16",
+      "process": "From $ y = 4x^{2} $, we obtain $ x^{2} = \\frac{1}{4}y $, so the focus of the parabola is $ F(0, \\frac{1}{16}) $, and the equation of the directrix is $ y = -\\frac{1}{16} $. Let $ M(x_{M}, y_{M}) $. By the definition of the parabola, we have $ MF = y_{M} + \\frac{1}{16} = 1 $, so $ y_{M} = \\frac{15}{16} $."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 0.0625,
+        "direction": "up"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  },
+  {
+    "dataset": "train",
+    "index": 7755,
+    "conic_type": "parabola",
+    "image_path": "samples/train/parabola/problem_7755.png",
+    "problem": {
+      "text": "If the distance from point $P$ on the parabola $x^{2}=8y$ to the focus is $12$, then what is the distance from $P$ to the $x$-axis?",
+      "fact_expressions": "G: Parabola;P: Point;Expression(G) = (x^2 = 8*y);PointOnCurve(P, G);Distance(P, Focus(G)) = 12",
+      "query_expressions": "Distance(P, xAxis)",
+      "answer_expressions": "10",
+      "process": "Since the parabola is $x^{2}=8y$, the focus coordinates are $(0,2)$, and the directrix equation is $y=-2$. Because the distance from point $P$ to the focus is $12$, according to the definition of a parabola, the distance from $P$ to the directrix is also $12$. Therefore, the distance from point $P$ to the $x$-axis is $10$."
+    },
+    "sdf_annotation": {
+      "params": {
+        "p": 2.0,
+        "direction": "up"
+      },
+      "optimization": {
+        "final_loss": 0.0,
+        "converged": true,
+        "note": "using explicit params"
+      },
+      "coords": {}
+    }
+  }
+]

create_samples.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Create a samples directory with a few examples from each curve type.
+"""
+import os
+import shutil
+import json
+
+# Configuration
+SAMPLES_PER_TYPE = 3  # Number of samples per curve type per dataset
+SOURCE_DIR = "results"
+TARGET_DIR = "samples"
+
+def create_samples():
+    # Remove existing samples directory
+    if os.path.exists(TARGET_DIR):
+        shutil.rmtree(TARGET_DIR)
+    
+    os.makedirs(TARGET_DIR)
+    
+    datasets = ['dev', 'test', 'train']
+    curve_types = ['circle', 'ellipse', 'hyperbola', 'parabola']
+    
+    total_copied = 0
+    
+    for dataset in datasets:
+        dataset_dir = os.path.join(SOURCE_DIR, dataset)
+        if not os.path.exists(dataset_dir):
+            continue
+            
+        target_dataset_dir = os.path.join(TARGET_DIR, dataset)
+        os.makedirs(target_dataset_dir, exist_ok=True)
+        
+        # Copy summary.json
+        summary_src = os.path.join(dataset_dir, 'summary.json')
+        if os.path.exists(summary_src):
+            shutil.copy(summary_src, target_dataset_dir)
+        
+        for curve_type in curve_types:
+            src_type_dir = os.path.join(dataset_dir, curve_type)
+            if not os.path.exists(src_type_dir):
+                continue
+            
+            target_type_dir = os.path.join(target_dataset_dir, curve_type)
+            os.makedirs(target_type_dir, exist_ok=True)
+            
+            # Get PNG files and sort them
+            png_files = sorted([f for f in os.listdir(src_type_dir) if f.endswith('.png')])
+            
+            # Select samples (first, middle, last)
+            if len(png_files) == 0:
+                continue
+            elif len(png_files) <= SAMPLES_PER_TYPE:
+                selected = png_files
+            else:
+                indices = [0, len(png_files)//2, len(png_files)-1]
+                selected = [png_files[i] for i in indices[:SAMPLES_PER_TYPE]]
+            
+            # Copy selected files
+            for filename in selected:
+                src = os.path.join(src_type_dir, filename)
+                dst = os.path.join(target_type_dir, filename)
+                shutil.copy(src, dst)
+                total_copied += 1
+                print(f"  Copied: {dataset}/{curve_type}/{filename}")
+    
+    print(f"\n✓ Created samples directory with {total_copied} files")
+    print(f"  Location: {os.path.abspath(TARGET_DIR)}")
+
+if __name__ == "__main__":
+    create_samples()

requirements.txt

@@ -0,0 +1,48 @@
+# =============================================================================
+# Image_SDF: Analytic Geometry Diagram Synthesis
+# =============================================================================
+# Python >= 3.9 required
+# Installation: pip install -r requirements.txt
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+# Core Dependencies
+# -----------------------------------------------------------------------------
+
+# Deep Learning Framework
+# - Tensor operations and automatic differentiation
+# - AdamW optimizer for constraint satisfaction
+torch>=2.0.0
+
+# Numerical Computing
+# - Array operations and linear algebra
+# - Mathematical functions (sqrt, trigonometric)
+numpy>=1.24.0
+
+# Visualization
+# - SDF field rendering and zero-level set visualization
+# - Figure generation with annotations
+matplotlib>=3.7.0
+
+# Progress Tracking
+# - Batch processing progress bars
+tqdm>=4.65.0
+
+# -----------------------------------------------------------------------------
+# Optional Dependencies (uncomment if needed)
+# -----------------------------------------------------------------------------
+
+# Enhanced numerical methods
+# scipy>=1.10.0
+
+# Image processing utilities
+# pillow>=10.0.0
+
+# Better plot styling
+# seaborn>=0.12.0
+
+# Type checking (development)
+# mypy>=1.0.0
+
+# Testing (development)
+# pytest>=7.0.0

src/__pycache__/sdf_geo_solver.cpython-313.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:056b7b1420e4c50b338528b19709d35f84ab65b8616f8a7c2fbef17231a78d2b
+size 148145

src/main.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+SDF-Based Analytic Geometry Solver
+Main entry point for batch processing geometry problems.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Add src directory to path for module imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from sdf_geo import SDFBatchProcessor
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='SDF-Based Geometry Solver - Automatic geometry visualization using Signed Distance Fields'
+    )
+    parser.add_argument(
+        '--input', '-i', 
+        type=str, 
+        default='data/test_en.json',
+        help='Path to input JSON file containing geometry problems'
+    )
+    parser.add_argument(
+        '--output', '-o', 
+        type=str, 
+        default='results',
+        help='Output directory for generated visualizations'
+    )
+    parser.add_argument(
+        '--max', '-m', 
+        type=int, 
+        default=None,
+        help='Maximum number of problems to process (default: all)'
+    )
+    parser.add_argument(
+        '--verbose', '-v', 
+        action='store_true',
+        help='Enable verbose output during processing'
+    )
+    
+    args = parser.parse_args()
+    
+    # Resolve paths
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+    
+    # Check input file exists
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}")
+        return 1
+    
+    # Create processor and run
+    processor = SDFBatchProcessor(str(output_path))
+    processor.process_batch(
+        str(input_path), 
+        max_problems=args.max, 
+        verbose=args.verbose
+    )
+    
+    return 0
+
+
+if __name__ == '__main__':
+    exit(main())

src/sdf_geo/__init__.py

@@ -0,0 +1,51 @@
+"""
+SDF-Based Analytic Geometry Solver Package
+
+Core modules for geometric problem solving using Signed Distance Fields.
+"""
+
+from .primitives import (
+    DEVICE,
+    SDFPrimitive,
+    PointSDF,
+    CircleSDF,
+    EllipseSDF,
+    HyperbolaSDF,
+    ParabolaSDF,
+    LineSDF,
+    LineSegmentSDF,
+    TriangleEdgesSDF,
+    TriangleFillSDF,
+    RightAngleSDF
+)
+
+from .constraints import GeometricConstraints
+from .parser import ProblemParser
+from .renderer import SDFRenderer
+from .optimizer import GeometryOptimizer
+from .processor import SDFBatchProcessor
+
+__all__ = [
+    # Device
+    'DEVICE',
+    # Primitives
+    'SDFPrimitive',
+    'PointSDF',
+    'CircleSDF',
+    'EllipseSDF',
+    'HyperbolaSDF',
+    'ParabolaSDF',
+    'LineSDF',
+    'LineSegmentSDF',
+    'TriangleEdgesSDF',
+    'TriangleFillSDF',
+    'RightAngleSDF',
+    # Core classes
+    'GeometricConstraints',
+    'ProblemParser',
+    'SDFRenderer',
+    'GeometryOptimizer',
+    'SDFBatchProcessor',
+]
+
+__version__ = '1.0.0'

src/sdf_geo/constraints.py

@@ -0,0 +1,82 @@
+"""
+Geometric Constraints - Differentiable constraint functions for optimization.
+Following GeoSDF paper Section 5.
+"""
+
+import torch
+from typing import Callable
+
+
+class GeometricConstraints:
+    """Collection of differentiable geometric constraint functions."""
+    
+    @staticmethod
+    def point_on_curve(sdf: Callable, point: torch.Tensor) -> torch.Tensor:
+        """Constraint: point lies on curve (SDF = 0)."""
+        return sdf(point.unsqueeze(0))**2
+    
+    @staticmethod
+    def distance_constraint(p1: torch.Tensor, p2: torch.Tensor, 
+                           target_dist: float) -> torch.Tensor:
+        """Constraint: distance between two points equals target."""
+        actual_dist = torch.norm(p1 - p2)
+        return (actual_dist - target_dist)**2
+    
+    @staticmethod
+    def eccentricity_ellipse(a: torch.Tensor, b: torch.Tensor, 
+                            target_e: float) -> torch.Tensor:
+        """Constraint: ellipse eccentricity."""
+        c_squared = a**2 - b**2
+        c = torch.sqrt(torch.clamp(c_squared, min=1e-8))
+        e = c / a
+        return (e - target_e)**2
+    
+    @staticmethod
+    def eccentricity_hyperbola(a: torch.Tensor, b: torch.Tensor,
+                               target_e: float) -> torch.Tensor:
+        """Constraint: hyperbola eccentricity e = c/a where c² = a² + b²."""
+        c_squared = a**2 + b**2
+        c = torch.sqrt(c_squared)
+        e = c / (a + 1e-8)
+        return (e - target_e)**2
+    
+    @staticmethod
+    def asymptote_slope(a: torch.Tensor, b: torch.Tensor, 
+                       target_slope: float) -> torch.Tensor:
+        """Constraint: hyperbola asymptote slope b/a."""
+        actual_slope = b / (a + 1e-8)
+        return (actual_slope - target_slope)**2
+    
+    @staticmethod
+    def focus_constraint(a: torch.Tensor, b: torch.Tensor, 
+                        focus_coord: float, is_hyperbola: bool = False) -> torch.Tensor:
+        """Constraint: focus at specific coordinate."""
+        if is_hyperbola:
+            c_squared = a**2 + b**2
+        else:
+            c_squared = a**2 - b**2
+        c = torch.sqrt(torch.clamp(c_squared, min=1e-8))
+        return (c - abs(focus_coord))**2
+    
+    @staticmethod
+    def focus_constraint_hyperbola(a: torch.Tensor, b: torch.Tensor, 
+                                   target_c: float) -> torch.Tensor:
+        """Constraint: hyperbola focus distance c where c² = a² + b²."""
+        c_squared = a**2 + b**2
+        c = torch.sqrt(c_squared)
+        return (c - target_c)**2
+    
+    @staticmethod
+    def positive_constraint(param: torch.Tensor, min_val: float = 0.1) -> torch.Tensor:
+        """Soft constraint to keep parameter positive."""
+        return torch.relu(min_val - param)**2
+    
+    @staticmethod
+    def crowd_penalty(positions: list, min_dist: float = 0.5) -> torch.Tensor:
+        """Penalty for elements being too close together."""
+        penalty = torch.tensor(0.0)
+        for i, p1 in enumerate(positions):
+            for p2 in positions[i+1:]:
+                dist = torch.norm(p1 - p2)
+                penalty = penalty + torch.relu(min_dist - dist)**2
+        return penalty

src/sdf_geo/optimizer.py

@@ -0,0 +1,81 @@
+"""
+Geometry Optimizer Module
+Gradient-based optimization for geometric constraints.
+"""
+
+import torch
+from typing import Dict, List, Callable
+
+
+class GeometryOptimizer:
+    """
+    Optimizer for geometric constraints using gradient descent.
+    Following GeoSDF paper methodology with AdamW optimizer.
+    """
+    
+    def __init__(self, learning_rate: float = 0.1, max_iterations: int = 500,
+                 convergence_threshold: float = 1e-6):
+        self.learning_rate = learning_rate
+        self.max_iterations = max_iterations
+        self.convergence_threshold = convergence_threshold
+    
+    def optimize(self, sdf, constraints: List[Callable], 
+                 weights: List[float], verbose: bool = False) -> Dict:
+        """
+        Optimize SDF parameters to satisfy constraints.
+        
+        Args:
+            sdf: SDF primitive with learnable parameters
+            constraints: List of constraint functions returning loss tensors
+            weights: Weight for each constraint
+            verbose: Print optimization progress
+            
+        Returns:
+            Dictionary with optimization results
+        """
+        # Get trainable parameters
+        params = [p for p in sdf.parameters() if p.requires_grad]
+        if not params:
+            return {'final_loss': 0.0, 'converged': True, 'iterations': 0}
+        
+        optimizer = torch.optim.AdamW(params, lr=self.learning_rate)
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            optimizer, T_max=self.max_iterations, eta_min=1e-4
+        )
+        
+        prev_loss = float('inf')
+        converged = False
+        
+        for i in range(self.max_iterations):
+            optimizer.zero_grad()
+            
+            # Compute weighted sum of constraint losses
+            total_loss = torch.tensor(0.0)
+            for constraint, weight in zip(constraints, weights):
+                loss = constraint()
+                total_loss = total_loss + weight * loss
+            
+            # Backward pass
+            total_loss.backward()
+            
+            # Gradient clipping for stability
+            torch.nn.utils.clip_grad_norm_(params, max_norm=1.0)
+            
+            optimizer.step()
+            scheduler.step()
+            
+            # Check convergence
+            current_loss = total_loss.item()
+            if abs(prev_loss - current_loss) < self.convergence_threshold:
+                converged = True
+                break
+            prev_loss = current_loss
+            
+            if verbose and i % 100 == 0:
+                print(f"  Iteration {i}: loss = {current_loss:.6f}")
+        
+        return {
+            'final_loss': current_loss,
+            'converged': converged,
+            'iterations': i + 1
+        }

src/sdf_geo/parser.py

@@ -0,0 +1,1184 @@
+"""
+Problem Parser Module
+Extracts geometric parameters from problem expressions.
+"""
+
+import re
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+
+
+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

src/sdf_geo/primitives.py

@@ -0,0 +1,354 @@
+"""
+SDF Primitives - Core geometric shape representations as Signed Distance Fields.
+Following GeoSDF paper methodology.
+
+This module contains:
+- Math utilities for quartic solving (Appendix B)
+- SDF primitive classes (Circle, Ellipse, Hyperbola, Parabola, Line, etc.)
+"""
+
+import torch
+import torch.nn as nn
+from typing import Tuple
+
+# Device configuration
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+
+# =============================================================================
+# Quartic Solver Utilities (Following Paper Appendix B)
+# =============================================================================
+
+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 using Cardano's formula."""
+    a_safe = a + 1e-10 * torch.sign(a + 1e-20)
+    p = b / a_safe
+    q = c / a_safe
+    r = d / a_safe
+    
+    alpha = q - p**2 / 3
+    beta = 2 * p**3 / 27 - p * q / 3 + r
+    discriminant = (beta / 2)**2 + (alpha / 3)**3
+    sqrt_disc = torch.sqrt(torch.clamp(discriminant, min=0) + 1e-12)
+    
+    term1 = -beta / 2 + sqrt_disc
+    term2 = -beta / 2 - sqrt_disc
+    
+    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)
+    
+    return u + v - p / 3
+
+
+def hyperbola_distance_quartic(px: torch.Tensor, py: torch.Tensor, 
+                                a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Compute exact distance from point to hyperbola using Newton iteration."""
+    px_abs = torch.abs(px)
+    py_abs = torch.abs(py)
+    
+    t = torch.asinh(py_abs / (b + 1e-8))
+    t = torch.clamp(t, 0.01, 10.0)
+    
+    for _ in range(15):
+        cosh_t = torch.cosh(t)
+        sinh_t = torch.sinh(t)
+        hx = a * cosh_t
+        hy = b * sinh_t
+        dx = px_abs - hx
+        dy = py_abs - hy
+        
+        grad = -2 * (dx * a * sinh_t + dy * b * cosh_t)
+        hess = 2 * (a**2 * sinh_t**2 + b**2 * cosh_t**2 - dx * a * cosh_t - dy * b * sinh_t) + 1e-6
+        
+        step = grad / torch.abs(hess)
+        t = t - torch.clamp(step, -0.3, 0.3)
+        t = torch.clamp(t, 0.001, 20.0)
+    
+    cosh_t = torch.cosh(t)
+    sinh_t = torch.sinh(t)
+    return torch.sqrt((px_abs - a * cosh_t)**2 + (py_abs - b * sinh_t)**2 + 1e-10)
+
+
+def ellipse_distance_quartic(px: torch.Tensor, py: torch.Tensor,
+                              a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """Compute exact distance from point to ellipse using Newton iteration."""
+    px_abs = torch.abs(px)
+    py_abs = torch.abs(py)
+    
+    a_use = torch.max(a, b)
+    b_use = torch.min(a, b)
+    
+    needs_swap = a < b
+    if needs_swap:
+        px_use, py_use = py_abs, px_abs
+    else:
+        px_use, py_use = px_abs, py_abs
+    
+    at_origin = (px_use < 1e-10) & (py_use < 1e-10)
+    on_x_axis = py_use < 1e-10
+    on_y_axis = px_use < 1e-10
+    
+    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)
+        ex = a_use * cos_t
+        ey = b_use * sin_t
+        dx = px_use - ex
+        dy = py_use - ey
+        
+        grad = 2 * (dx * a_use * sin_t - dy * b_use * cos_t)
+        hess = 2 * (a_use**2 * sin_t**2 + b_use**2 * cos_t**2 + dx * a_use * cos_t + dy * b_use * sin_t) + 1e-6
+        
+        theta = theta - torch.clamp(grad / torch.abs(hess), -0.3, 0.3)
+    
+    cos_t = torch.cos(theta)
+    sin_t = torch.sin(theta)
+    dist = torch.sqrt((px_use - a_use * cos_t)**2 + (py_use - b_use * sin_t)**2 + 1e-10)
+    
+    dist = torch.where(at_origin, b_use, dist)
+    dist = torch.where(on_x_axis & ~at_origin, torch.where(px_use > a_use, px_use - a_use, torch.sqrt((px_use - a_use)**2 + 1e-10)), dist)
+    dist = torch.where(on_y_axis & ~at_origin, torch.abs(py_use - b_use), dist)
+    
+    return dist
+
+
+# =============================================================================
+# SDF Primitives Base Class
+# =============================================================================
+
+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."""
+        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"""
+    
+    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"""
+    
+    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 = p_local[..., 0]
+        py = p_local[..., 1]
+        
+        a = torch.abs(self.a) + 1e-8
+        b = torch.abs(self.b) + 1e-8
+        
+        dist = ellipse_distance_quartic(px, py, a, b)
+        ellipse_val = px**2 / (a**2) + py**2 / (b**2)
+        inside = ellipse_val < 1
+        
+        return torch.where(inside, -dist, dist)
+
+
+class HyperbolaSDF(SDFPrimitive):
+    """SDF for hyperbola: x²/a² - y²/b² = 1"""
+    
+    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 = p_local[..., 0]
+        py = p_local[..., 1]
+        
+        a = torch.abs(self.a) + 1e-8
+        b = torch.abs(self.b) + 1e-8
+        
+        dist = hyperbola_distance_quartic(px, py, a, b)
+        hyperbola_val = px**2 / (a**2) - py**2 / (b**2)
+        is_between_branches = hyperbola_val < 1
+        
+        return torch.where(is_between_branches, -dist, dist)
+
+
+class ParabolaSDF(SDFPrimitive):
+    """SDF for parabola: y² = 4px (rightward) or x² = 4py (upward)"""
+    
+    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:
+        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':
+            return self._compute_distance_right(px, py, p_param)
+        elif self.direction == 'left':
+            return self._compute_distance_right(-px, py, p_param)
+        elif self.direction == 'up':
+            return self._compute_distance_right(py, px, p_param)
+        elif self.direction == 'down':
+            return self._compute_distance_right(-py, px, p_param)
+        return self._compute_distance_right(px, py, p_param)
+    
+    def _compute_distance_right(self, px: torch.Tensor, py: torch.Tensor, p: torch.Tensor) -> torch.Tensor:
+        t = py.clone()
+        
+        for _ in range(12):
+            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
+            
+            t = t - torch.clamp(grad / torch.abs(hess), -1.0, 1.0)
+        
+        para_x = t**2 / (4 * p)
+        para_y = t
+        dist = torch.sqrt((px - para_x)**2 + (py - para_y)**2 + 1e-10)
+        
+        at_vertex = (torch.abs(px) < 1e-6) & (torch.abs(py) < 1e-6)
+        dist = torch.where(at_vertex, torch.zeros_like(dist), dist)
+        
+        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."""
+    
+    def __init__(self, point: torch.Tensor, direction: torch.Tensor):
+        super().__init__()
+        self.point = nn.Parameter(point.clone())
+        self.direction = nn.Parameter(direction / (torch.norm(direction) + 1e-8))
+    
+    def forward(self, p: torch.Tensor) -> torch.Tensor:
+        v = p - self.point
+        normal = torch.tensor([-self.direction[1], self.direction[0]], device=p.device)
+        return (v * normal).sum(dim=-1)
+
+
+class LineSegmentSDF(SDFPrimitive):
+    """SDF for line segment from point a to point b."""
+    
+    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:
+        v_ab = self.b - self.a
+        v_ap = p - self.a
+        h = (v_ap * v_ab).sum(dim=-1) / (torch.norm(v_ab)**2 + 1e-8)
+        h_clamped = torch.clamp(h, 0, 1)
+        closest = self.a + h_clamped.unsqueeze(-1) * v_ab
+        return torch.norm(p - closest, dim=-1)
+
+
+class TriangleEdgesSDF(SDFPrimitive):
+    """SDF for triangle edges (boundary only)."""
+    
+    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:
+        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."""
+    
+    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:
+        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:
+        d0 = self.edge0(p)
+        d1 = self.edge1(p)
+        d2 = self.edge2(p)
+        dist = torch.min(torch.min(d0, d1), d2)
+        
+        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 = ((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."""
+    
+    def __init__(self, vertex: torch.Tensor, dir1: torch.Tensor, dir2: torch.Tensor,
+                 size: float = 0.25, thickness: float = 0.015):
+        super().__init__()
+        dir1_norm = dir1 / (torch.norm(dir1) + 1e-8)
+        dir2_norm = dir2 / (torch.norm(dir2) + 1e-8)
+        
+        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:
+        return torch.min(self.seg1(p), self.seg2(p)) - self.thickness

src/sdf_geo/processor.py

@@ -0,0 +1,1218 @@
+"""
+Batch Processor Module
+Processes geometry problems and generates visualizations.
+"""
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+from tqdm import tqdm
+
+from .primitives import (
+    CircleSDF, EllipseSDF, HyperbolaSDF, ParabolaSDF
+)
+from .constraints import GeometricConstraints
+from .parser import ProblemParser
+from .optimizer import GeometryOptimizer
+from .renderer import SDFRenderer
+
+
+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:
+        """
+        Rigorous validation following paper-quality standards.
+        Validates all explicit geometric constraints from the problem.
+        
+        Validation includes:
+        - Parameter positivity (a, b, p, r > 0)
+        - Eccentricity matching (e_calc vs e_target)
+        - Asymptote slope matching (b/a vs target slope)
+        - Focus position verification (c² = a² ± b²)
+        - Point-on-curve verification for constrained points
+        - Directrix position verification (parabola)
+        """
+        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 = []
+        
+        # Tolerance settings (paper-quality)
+        tol_point = 3e-2      # Point on curve tolerance
+        tol_param = 0.05      # Parameter matching tolerance (e, slope)
+        tol_focus = 0.05      # Focus position tolerance
+        
+        # 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)
+        
+        # Helper: extract focus coordinates from fact_expr
+        def get_focus_coords() -> List[Tuple[float, float]]:
+            """Extract focus point coordinates."""
+            foci = []
+            for name, coord in coords.items():
+                # Check if this point is declared as a focus
+                if re.search(rf'Focus\s*\(\s*{main_conic}\s*\)\s*=\s*\{{\s*{name}', fact_expr) or \
+                   re.search(rf'Focus\s*\(\s*{main_conic}\s*\)\s*=\s*{name}', fact_expr) or \
+                   (name in ['F', 'F1', 'F2'] and re.search(rf'Focus\s*\(\s*{main_conic}\s*\)', fact_expr)):
+                    foci.append(coord)
+            return foci
+        
+        # Helper: check if point is on curve constraint
+        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']
+            
+            # 1. Parameter positivity
+            if a <= 0 or b <= 0:
+                reasons.append('ellipse_nonpositive_axes')
+            
+            # 2. Eccentricity verification
+            ecc_target = self.parser.parse_eccentricity(fact_expr)
+            if ecc_target and 0 < ecc_target < 1:
+                a_major, b_minor = max(a, b), min(a, b)
+                ecc_calc = np.sqrt(1 - (b_minor / a_major)**2)
+                if abs(ecc_calc - ecc_target) > tol_param:
+                    reasons.append('ellipse_ecc_mismatch')
+            
+            # 3. Focus position verification (c² = a² - b² for ellipse)
+            foci = get_focus_coords()
+            if foci:
+                a_major, b_minor = max(a, b), min(a, b)
+                c_calc = np.sqrt(max(0, a_major**2 - b_minor**2))
+                for fx, fy in foci:
+                    # Focus should be at (±c, 0) or (0, ±c) from center
+                    c_given = np.sqrt(fx**2 + fy**2)  # Assuming center at origin
+                    if abs(c_calc - c_given) > tol_focus:
+                        reasons.append('ellipse_focus_mismatch')
+                        break
+            
+            # 4. Point-on-curve verification
+            for name, (px, py) in coords.items():
+                if has_point_constraint(name):
+                    major_axis = params.get('major_axis', 'x')
+                    if major_axis == 'x':
+                        val = (px**2) / (a**2) + (py**2) / (b**2) - 1
+                    else:
+                        val = (px**2) / (b**2) + (py**2) / (a**2) - 1
+                    if abs(val) > tol_point:
+                        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')
+            
+            # 1. Parameter positivity
+            if a <= 0 or b <= 0:
+                reasons.append('hyperbola_nonpositive_axes')
+            
+            # 2. Asymptote slope verification (b/a for horizontal)
+            asym = self.parser.parse_asymptote_slope(fact_expr)
+            if asym:
+                slope_calc = b / a if orientation == 'horizontal' else a / b
+                if abs(slope_calc - asym) > tol_param:
+                    reasons.append('hyperbola_asymptote_mismatch')
+            
+            # 3. Eccentricity verification (e = c/a = sqrt(1 + b²/a²))
+            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) > tol_param:
+                    reasons.append('hyperbola_ecc_mismatch')
+            
+            # 4. Focus position verification (c² = a² + b² for hyperbola)
+            foci = get_focus_coords()
+            if foci:
+                c_calc = np.sqrt(a**2 + b**2)
+                for fx, fy in foci:
+                    # Focus should be at (±c, 0) or (0, ±c) from center
+                    c_given = np.sqrt(fx**2 + fy**2)  # Assuming center at origin
+                    if abs(c_calc - c_given) > tol_focus:
+                        reasons.append('hyperbola_focus_mismatch')
+                        break
+            
+            # 5. Point-on-curve verification
+            for name, (px, py) in coords.items():
+                if has_point_constraint(name):
+                    if orientation == 'vertical':
+                        val = (py**2) / (a**2) - (px**2) / (b**2) - 1
+                    else:
+                        val = (px**2) / (a**2) - (py**2) / (b**2) - 1
+                    if abs(val) > tol_point:
+                        reasons.append('hyperbola_point_off_curve')
+                        break
+        
+        elif conic_type == 'parabola':
+            params = result.get('params', {})
+            p = params.get('p', 0)
+            direction = params.get('direction', 'right')
+            
+            # 1. Parameter positivity
+            if p <= 0:
+                reasons.append('parabola_nonpositive_p')
+            
+            # 2. Focus position verification
+            # Focus at (p, 0) for y² = 4px (right-opening)
+            foci = get_focus_coords()
+            if foci:
+                for fx, fy in foci:
+                    if direction == 'right':
+                        focus_expected = (p, 0)
+                    elif direction == 'left':
+                        focus_expected = (-p, 0)
+                    elif direction == 'up':
+                        focus_expected = (0, p)
+                    else:  # down
+                        focus_expected = (0, -p)
+                    
+                    dist = np.sqrt((fx - focus_expected[0])**2 + (fy - focus_expected[1])**2)
+                    if dist > tol_focus:
+                        reasons.append('parabola_focus_mismatch')
+                        break
+            
+            # 3. Directrix verification (if specified)
+            # Directrix at x = -p for y² = 4px
+            directrix_match = re.search(r'Directrix\s*\(\s*\w+\s*\)\s*=\s*\(x\s*=\s*(-?\d+\.?\d*)\)', fact_expr)
+            if directrix_match:
+                directrix_given = float(directrix_match.group(1))
+                if direction == 'right':
+                    directrix_expected = -p
+                elif direction == 'left':
+                    directrix_expected = p
+                else:
+                    directrix_expected = None  # y-directrix for up/down
+                
+                if directrix_expected is not None:
+                    if abs(directrix_given - directrix_expected) > tol_focus:
+                        reasons.append('parabola_directrix_mismatch')
+            
+            # 4. Point-on-curve verification
+            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_point:
+                        reasons.append('parabola_point_off_curve')
+                        break
+        
+        elif conic_type == 'circle':
+            params = result.get('params', {})
+            r = params.get('radius', 0)
+            cx, cy = params.get('center', (0, 0))
+            
+            # 1. Parameter positivity
+            if r <= 0:
+                reasons.append('circle_nonpositive_radius')
+            
+            # 2. Center verification (if specified)
+            center_match = re.search(r'Center\s*\(\s*\w+\s*\)\s*=\s*\(([^,]+),\s*([^)]+)\)', fact_expr)
+            if center_match:
+                try:
+                    cx_given = float(center_match.group(1))
+                    cy_given = float(center_match.group(2))
+                    if abs(cx - cx_given) > tol_focus or abs(cy - cy_given) > tol_focus:
+                        reasons.append('circle_center_mismatch')
+                except:
+                    pass
+            
+            # 3. Radius verification (if specified)
+            radius_match = re.search(r'Radius\s*\(\s*\w+\s*\)\s*=\s*(\d+\.?\d*)', fact_expr)
+            if radius_match:
+                r_given = float(radius_match.group(1))
+                if abs(r - r_given) > tol_focus:
+                    reasons.append('circle_radius_mismatch')
+            
+            # 4. Point-on-curve verification
+            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_point:
+                        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').
+        """
+        # 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)
+        """
+        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
+        # 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, min_dist=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, min_dist=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, min_dist=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 _setup_gaokao_axes(self, ax, xlim, ylim):
+        """Setup coordinate axes in Chinese Gaokao analytic geometry style."""
+        ax.set_facecolor('white')
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+        ax.set_xticks([])
+        ax.set_yticks([])
+
+        # Draw arrow axes through origin
+        arrow_kw = dict(arrowstyle='->', color='black', lw=1.0)
+        ax.annotate('', xy=(xlim[1], 0), xytext=(xlim[0], 0), arrowprops=arrow_kw)
+        ax.annotate('', xy=(0, ylim[1]), xytext=(0, ylim[0]), arrowprops=arrow_kw)
+
+        # Label offset proportional to plot range
+        r = max(xlim[1] - xlim[0], ylim[1] - ylim[0])
+        d = r * 0.025
+
+        ax.text(xlim[1] - d, -d * 2, '$x$', fontsize=14, ha='right', va='top')
+        ax.text(d * 0.5, ylim[1] - d * 0.5, '$y$', fontsize=14, ha='left', va='top')
+        ax.text(-d * 1.5, -d * 2, '$O$', fontsize=14, ha='right', va='top')
+
+        ax.set_xlim(xlim)
+        ax.set_ylim(ylim)
+        ax.set_aspect('equal')
+
+    def _visualize_circle(self, sdf: CircleSDF, problem: Dict, params: Dict,
+                         output_path: Path):
+        """Visualize circle in Gaokao style."""
+
+        with torch.no_grad():
+            cx = sdf.center[0].item()
+            cy = sdf.center[1].item()
+            r = abs(sdf.radius.item())
+
+        margin = r + 1.5
+        xlim = (min(cx - margin, -0.5), max(cx + margin, 0.5))
+        ylim = (min(cy - margin, -0.5), max(cy + margin, 0.5))
+
+        fig, ax = plt.subplots(figsize=(8, 8))
+        fig.patch.set_facecolor('white')
+
+        renderer = SDFRenderer(resolution=400, xlim=xlim, ylim=ylim)
+        renderer.render_curve_only(sdf, ax, color='black', linewidth=1.5)
+
+        # Mark center
+        d = max(xlim[1] - xlim[0], ylim[1] - ylim[0]) * 0.02
+        ax.plot(cx, cy, 'k.', markersize=4)
+        ax.text(cx + d, cy + d * 2, '$C$', fontsize=13, ha='left', va='bottom')
+
+        # Additional points
+        for name, (px, py) in params.get('coords', {}).items():
+            ax.plot(px, py, 'k.', markersize=4)
+            ax.text(px + d, py + d * 2, f'${name}$', fontsize=13, ha='left', va='bottom')
+
+        self._setup_gaokao_axes(ax, xlim, ylim)
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close(fig)
+    
+    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 in Gaokao style."""
+
+        with torch.no_grad():
+            a = abs(sdf.a.item())
+            b = abs(sdf.b.item())
+
+        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
+
+        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.5 + 0.5
+
+        xlim = (-max_dim, max_dim)
+        ylim = (-max_dim, max_dim)
+
+        fig, ax = plt.subplots(figsize=(8, 8))
+        fig.patch.set_facecolor('white')
+
+        renderer = SDFRenderer(resolution=500, xlim=xlim, ylim=ylim)
+        renderer.render_curve_only(sdf, ax, color='black', linewidth=1.5)
+
+        # Draw secondary hyperbola if present
+        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)
+            renderer.render_curve_only(hyp_sdf, ax, color='black', linewidth=1.5)
+
+            # Asymptotes
+            slope_hyp = hyperbola_params['b'] / hyperbola_params['a']
+            x_asym = np.linspace(-max_dim, max_dim, 100)
+            ax.plot(x_asym, slope_hyp * x_asym, 'k--', linewidth=0.8, alpha=0.5)
+            ax.plot(x_asym, -slope_hyp * x_asym, 'k--', linewidth=0.8, alpha=0.5)
+
+        # Foci
+        c = np.sqrt(abs(a**2 - b**2)) if a > b else np.sqrt(abs(b**2 - a**2))
+        d = max_dim * 0.025
+        if major_axis == 'x':
+            ax.plot(c, 0, 'k.', markersize=5)
+            ax.plot(-c, 0, 'k.', markersize=5)
+            ax.text(-c, d * 2, '$F_1$', fontsize=13, ha='center', va='bottom')
+            ax.text(c, d * 2, '$F_2$', fontsize=13, ha='center', va='bottom')
+        else:
+            ax.plot(0, c, 'k.', markersize=5)
+            ax.plot(0, -c, 'k.', markersize=5)
+            ax.text(d * 2, -c, '$F_1$', fontsize=13, ha='left', va='center')
+            ax.text(d * 2, c, '$F_2$', fontsize=13, ha='left', va='center')
+
+        # 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.plot(px, py, 'k.', markersize=5)
+                ax.text(px + d, py + d * 2, f'${name}$', fontsize=13)
+
+        self._setup_gaokao_axes(ax, xlim, ylim)
+
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close(fig)
+    
+    def _visualize_hyperbola(self, sdf: HyperbolaSDF, problem: Dict, params: Dict,
+                            output_path: Path):
+        """Visualize hyperbola in Gaokao style."""
+
+        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:
+            slope = line_params['slope']
+            if 'LeftFocus' in fact_expr or 'RightFocus' in fact_expr:
+                c_hyp = np.sqrt(a**2 + b**2)
+                focus_x = -c_hyp if 'LeftFocus' in fact_expr else c_hyp
+                line_params['a'] = slope
+                line_params['b'] = -1.0
+                line_params['c'] = -slope * focus_x
+
+        # 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
+
+        xlim = (-max_dim, max_dim)
+        ylim = (-max_dim, max_dim)
+
+        fig, ax = plt.subplots(figsize=(8, 8))
+        fig.patch.set_facecolor('white')
+
+        renderer = SDFRenderer(resolution=500, xlim=xlim, ylim=ylim)
+        renderer.render_curve_only(sdf, ax, color='black', linewidth=1.5)
+
+        # Draw secondary ellipse if present
+        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)
+            renderer.render_curve_only(ellipse_sdf, ax, color='black', linewidth=1.5)
+
+        # Draw line if present
+        if has_line and line_params.get('a') is not None and line_params.get('b') is not None:
+            line_a = line_params['a']
+            line_b = line_params['b']
+            line_c = line_params.get('c', 0)
+            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
+                mask = (y_line >= ylim[0]) & (y_line <= ylim[1])
+                ax.plot(x_line[mask], y_line[mask], 'k-', linewidth=1.0)
+            else:
+                x_val = -line_c / line_a if abs(line_a) > 1e-6 else 0
+                ax.axvline(x=x_val, color='black', linewidth=1.0)
+
+        # Asymptotes
+        slope = b / a
+        x_asym = np.linspace(-max_dim, max_dim, 100)
+        ax.plot(x_asym, slope * x_asym, 'k--', linewidth=0.8, alpha=0.5)
+        ax.plot(x_asym, -slope * x_asym, 'k--', linewidth=0.8, alpha=0.5)
+
+        # Foci
+        c = np.sqrt(a**2 + b**2)
+        d = max_dim * 0.025
+        ax.plot(c, 0, 'k.', markersize=5)
+        ax.plot(-c, 0, 'k.', markersize=5)
+        ax.text(-c, d * 2, '$F_1$', fontsize=13, ha='center', va='bottom')
+        ax.text(c, d * 2, '$F_2$', fontsize=13, ha='center', va='bottom')
+
+        # Additional points
+        coords = self.parser.parse_coordinates(fact_expr)
+        for name, (px, py) in coords.items():
+            if name not in ['F1', 'F2', 'F', 'O']:
+                ax.plot(px, py, 'k.', markersize=5)
+                ax.text(px + d, py + d * 2, f'${name}$', fontsize=13)
+
+        self._setup_gaokao_axes(ax, xlim, ylim)
+
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close(fig)
+    
+    def _visualize_parabola(self, sdf: ParabolaSDF, problem: Dict, params: Dict,
+                           output_path: Path):
+        """Visualize parabola in Gaokao style."""
+
+        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 * 3, extent)
+            ylim = (-extent * 0.8, extent * 0.8)
+        elif direction == 'left':
+            xlim = (-extent, p * 3)
+            ylim = (-extent * 0.8, extent * 0.8)
+        elif direction == 'up':
+            xlim = (-extent * 0.8, extent * 0.8)
+            ylim = (-p * 3, extent)
+        else:  # down
+            xlim = (-extent * 0.8, extent * 0.8)
+            ylim = (-extent, p * 3)
+
+        # Ensure origin is visible
+        xlim = (min(xlim[0], -0.5), max(xlim[1], 0.5))
+        ylim = (min(ylim[0], -0.5), max(ylim[1], 0.5))
+
+        fig, ax = plt.subplots(figsize=(8, 8))
+        fig.patch.set_facecolor('white')
+
+        renderer = SDFRenderer(resolution=600, xlim=xlim, ylim=ylim)
+        renderer.render_curve_only(sdf, ax, color='black', linewidth=1.5)
+
+        d = max(xlim[1] - xlim[0], ylim[1] - ylim[0]) * 0.02
+
+        # Focus and directrix
+        if direction == 'right':
+            ax.plot(p, 0, 'k.', markersize=5)
+            ax.text(p + d, d * 2, '$F$', fontsize=13, ha='left', va='bottom')
+            ax.plot([-p, -p], [ylim[0], ylim[1]], 'k--', linewidth=0.8, alpha=0.5)
+        elif direction == 'left':
+            ax.plot(-p, 0, 'k.', markersize=5)
+            ax.text(-p - d, d * 2, '$F$', fontsize=13, ha='right', va='bottom')
+            ax.plot([p, p], [ylim[0], ylim[1]], 'k--', linewidth=0.8, alpha=0.5)
+        elif direction == 'up':
+            ax.plot(0, p, 'k.', markersize=5)
+            ax.text(d * 2, p + d, '$F$', fontsize=13, ha='left', va='bottom')
+            ax.plot([xlim[0], xlim[1]], [-p, -p], 'k--', linewidth=0.8, alpha=0.5)
+        else:  # down
+            ax.plot(0, -p, 'k.', markersize=5)
+            ax.text(d * 2, -p - d, '$F$', fontsize=13, ha='left', va='top')
+            ax.plot([xlim[0], xlim[1]], [p, p], 'k--', linewidth=0.8, alpha=0.5)
+
+        # Additional points with staggered labels
+        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.plot(px, py, 'k.', markersize=5)
+                offset_y = d * 2 + d * idx
+                ax.text(px + d, py + offset_y, f'${name}$', fontsize=13)
+
+        self._setup_gaokao_axes(ax, xlim, ylim)
+
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close(fig)
+    
+    def process_batch(self, problems_input, max_problems: int = None,
+                     verbose: bool = False) -> List[Dict]:
+        """Process a batch of problems.
+        
+        Args:
+            problems_input: Either a list of problem dicts or a path to JSON file
+            max_problems: Maximum number of problems to process
+            verbose: Whether to print verbose output
+        """
+        # Handle both list and file path inputs
+        if isinstance(problems_input, str):
+            with open(problems_input, 'r', encoding='utf-8') as f:
+                problems = json.load(f)
+        else:
+            problems = problems_input
+            
+        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

src/sdf_geo/renderer.py

@@ -0,0 +1,98 @@
+"""
+SDF Renderer Module
+Visualization utilities for SDF fields and zero-level sets.
+"""
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from typing import Tuple, Optional
+
+
+class SDFRenderer:
+    """
+    Renderer for SDF fields and zero-level sets.
+    Creates visualization grids and renders SDF values.
+    """
+    
+    def __init__(self, resolution: int = 512, 
+                 xlim: Tuple[float, float] = (-5, 5),
+                 ylim: Tuple[float, float] = (-5, 5)):
+        self.resolution = resolution
+        self.xlim = xlim
+        self.ylim = ylim
+        
+        # Create evaluation 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)
+        
+        # Custom colormap for SDF visualization
+        self.sdf_cmap = LinearSegmentedColormap.from_list(
+            'sdf', ['#2E86AB', '#FFFFFF', '#E74C3C'], N=256
+        )
+    
+    def render_sdf_field(self, sdf, ax: plt.Axes, 
+                        show_field: bool = True,
+                        field_alpha: float = 0.3) -> np.ndarray:
+        """
+        Render SDF field and zero-level set.
+        
+        Args:
+            sdf: SDF primitive to render
+            ax: Matplotlib axes
+            show_field: Show background SDF field
+            field_alpha: Alpha for background field
+            
+        Returns:
+            SDF values as numpy array
+        """
+        with torch.no_grad():
+            # Evaluate SDF on grid
+            grid_flat = self.grid.reshape(-1, 2)
+            distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
+            distances_np = distances.cpu().numpy()
+        
+        # Show SDF field as background
+        if show_field:
+            max_val = min(np.abs(distances_np).max(), 10)
+            ax.contourf(self.xx.numpy(), self.yy.numpy(), distances_np,
+                       levels=50, cmap=self.sdf_cmap, alpha=field_alpha,
+                       vmin=-max_val, vmax=max_val)
+        
+        # Draw zero-level set (the curve)
+        ax.contour(self.xx.numpy(), self.yy.numpy(), distances_np,
+                  levels=[0], colors=['#2E86AB'], linewidths=2.5)
+        
+        return distances_np
+    
+    def render_multiple(self, sdfs: list, ax: plt.Axes,
+                       colors: Optional[list] = None) -> None:
+        """Render multiple SDFs on the same axes."""
+        if colors is None:
+            colors = ['#2E86AB', '#E74C3C', '#27AE60', '#9B59B6', '#F39C12']
+        
+        with torch.no_grad():
+            grid_flat = self.grid.reshape(-1, 2)
+            
+            for i, sdf in enumerate(sdfs):
+                distances = sdf(grid_flat).reshape(self.resolution, self.resolution)
+                distances_np = distances.cpu().numpy()
+                
+                color = colors[i % len(colors)]
+                ax.contour(self.xx.numpy(), self.yy.numpy(), distances_np,
+                          levels=[0], colors=[color], linewidths=2.5)
+
+    def render_curve_only(self, sdf, ax, color='black', linewidth=1.5, linestyle='-'):
+        """Render only the zero-level set (curve) without SDF field background."""
+        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(), self.yy.numpy(), distances_np,
+                  levels=[0], colors=[color], linewidths=linewidth, linestyles=linestyle)
+
+        return distances_np