""" 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(, G) where G is the main conic - Intersection(*, G) = {A, B} where G is the main conic Excludes: - PointOnCurve(, H) where H is a line - PointOnCurve(, Asymptote(G)) - on asymptote, not curve - PointOnCurve(, Directrix(G)) - on directrix, not curve - PointOnCurve(, 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