feat: implement Geometric Sanity Engine (V1.0) and fix project ID in functions

.gcloudignore

@@ -0,0 +1,16 @@
+.gcloudignore
+.git
+.gitignore
+venv/
+.venv/
+.venv_fix/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+tests/
+test_results/
+logs/
+server.log
+deploy_hf/

constraint_checks.py

@@ -0,0 +1,159 @@
+# constraint_checks.py - V1.0 (Geometric Constraint Validator)
+# Deterministic algebraic checks using SymPy.
+# Each function verifies a specific geometric relationship and logs
+# the result to the GeometryAnchor (verified_facts or warnings).
+
+import logging
+from sympy import simplify, symbols, Eq, solve, Rational
+
+from geometry_types import Point, Line, Segment, Circle, GeometryAnchor
+
+logger = logging.getLogger(__name__)
+
+
+def check_point_on_circle(p: Point, circle: Circle, anchor: GeometryAnchor):
+    """
+    Verifies algebraically whether point p lies on the circle boundary.
+    Injects a verified_fact or a warning into the anchor.
+    """
+    try:
+        if circle.contains(p):
+            anchor.add_fact(
+                f"✓ הנקודה {p} נמצאת על המעגל (מרכז {circle.center}, r={circle.radius})"
+            )
+        else:
+            lhs = (p.x - circle.center.x)**2 + (p.y - circle.center.y)**2
+            anchor.add_warning(
+                f"✗ הנקודה {p} אינה על המעגל — "
+                f"חישוב: {simplify(lhs)} ≠ r²={simplify(circle.radius**2)}. "
+                f"ייתכן שה-OCR חילץ קואורדינטות שגויות."
+            )
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] check_point_on_circle failed: {e}")
+        anchor.add_warning(f"⚠️ לא ניתן לאמת שהנקודה {p.name} על המעגל: {e}")
+
+
+def check_point_on_line(p: Point, line: Line, anchor: GeometryAnchor):
+    """
+    Verifies algebraically whether point p lies on the line ax + by + c = 0.
+    """
+    try:
+        if line.contains(p):
+            anchor.add_fact(
+                f"✓ הנקודה {p} נמצאת על הישר {line}"
+            )
+        else:
+            val = simplify(line.a * p.x + line.b * p.y + line.c)
+            anchor.add_warning(
+                f"✗ הנקודה {p} אינה על הישר {line} — "
+                f"הצבה נותנת {val} ≠ 0"
+            )
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] check_point_on_line failed: {e}")
+        anchor.add_warning(f"⚠️ לא ניתן לאמת שהנקודה {p.name} על הישר: {e}")
+
+
+def check_is_diameter(segment: Segment, circle: Circle, anchor: GeometryAnchor):
+    """
+    Checks if a segment is a diameter by verifying its midpoint equals the circle center.
+    This is the most critical check for preventing midpoint hallucination.
+    """
+    try:
+        mid = segment.midpoint()
+        center = circle.center
+        if mid == center:
+            anchor.add_fact(
+                f"✓ הקטע {segment.p1.name}{segment.p2.name} הוא קוטר — "
+                f"אמצעו {mid} = מרכז המעגל {center}"
+            )
+        else:
+            anchor.add_warning(
+                f"✗ הקטע {segment.p1.name}{segment.p2.name} אינו קוטר — "
+                f"אמצע הקטע הוא {mid}, אך מרכז המעגל הוא {center}. "
+                f"⚠️ אל תניח שמרכז המעגל הוא נקודת האמצע של קטע זה!"
+            )
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] check_is_diameter failed: {e}")
+        anchor.add_warning(f"⚠️ לא ניתן לאמת האם הקטע {segment} הוא קוטר: {e}")
+
+
+def check_perpendicular_lines(slope1, slope2, anchor: GeometryAnchor, label1="ישר 1", label2="ישר 2"):
+    """
+    Verifies that two lines (given by slopes) are perpendicular: m1 * m2 = -1.
+    """
+    try:
+        product = simplify(slope1 * slope2)
+        if product == -1:
+            anchor.add_fact(
+                f"✓ {label1} ו-{label2} מאונכים — מכפלת שיפועים = {product} = -1"
+            )
+        else:
+            anchor.add_warning(
+                f"✗ {label1} ו-{label2} אינם מאונכים — מכפלת שיפועים = {product} ≠ -1"
+            )
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] check_perpendicular_lines failed: {e}")
+        anchor.add_warning(f"⚠️ לא ניתן לאמת אנכיות: {e}")
+
+
+def find_circle_center_from_diameters(
+    d1: Segment,
+    d2: Segment,
+    anchor: GeometryAnchor
+) -> Point:
+    """
+    Finds the circle center deterministically as the intersection of two diameter segments.
+    This eliminates any need for the LLM to 'guess' the center.
+    """
+    try:
+        x, y = symbols('x y')
+
+        def line_eq_through(p1: Point, p2: Point):
+            if simplify(p2.x - p1.x) == 0:
+                # Vertical line
+                return Eq(x, p1.x)
+            slope = Rational(p2.y - p1.y, p2.x - p1.x)
+            return Eq(y, slope * (x - p1.x) + p1.y)
+
+        eq1 = line_eq_through(d1.p1, d1.p2)
+        eq2 = line_eq_through(d2.p1, d2.p2)
+
+        solution = solve([eq1, eq2], [x, y])
+
+        if not solution:
+            anchor.add_warning(
+                "[SOLVER] לא ניתן לחשב מרכז מעגל מחיתוך שני קטרים — הישרים מקבילים?"
+            )
+            return None
+
+        cx = solution[x] if isinstance(solution, dict) else solution[0]
+        cy = solution[y] if isinstance(solution, dict) else solution[1]
+        center = Point(name="M", x=simplify(cx), y=simplify(cy))
+        anchor.add_fact(
+            f"✓ מרכז המעגל M חושב כחיתוך קטרים: M = {center}"
+        )
+        return center
+
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] find_circle_center_from_diameters failed: {e}")
+        anchor.add_warning(f"⚠️ חישוב מרכז ממעגל נכשל: {e}")
+        return None
+
+
+def check_distance(p1: Point, p2: Point, expected_distance, anchor: GeometryAnchor, label=""):
+    """
+    Verifies the distance between two points matches an expected value.
+    """
+    try:
+        actual = simplify(p1.distance_to(p2))
+        expected = simplify(expected_distance)
+        desc = label or f"{p1.name}↔{p2.name}"
+        if simplify(actual - expected) == 0:
+            anchor.add_fact(f"✓ המרחק {desc} = {actual} (תואם לנתון)")
+        else:
+            anchor.add_warning(
+                f"✗ המרחק {desc}: חישוב={actual} ≠ נתון={expected}"
+            )
+    except Exception as e:
+        logger.error(f"[CONSTRAINT] check_distance failed: {e}")
+        anchor.add_warning(f"⚠️ בדיקת מרחק נכשלה: {e}")

geometric_sanity.py

@@ -0,0 +1,191 @@
+# geometric_sanity.py - V1.0 (Geometric Sanity Engine)
+# This module is the public entry point for the sanity check layer.
+#
+# Responsibilities:
+# 1. Parse the raw DataAnchor dict into typed geometric objects.
+# 2. Run all relevant constraint checks (via constraint_checks.py).
+# 3. Build the "VERIFIED FACTS" prompt block for injection into the LLM prompt.
+#
+# Design note: All errors are caught and logged. This module NEVER raises —
+# it always returns a valid (possibly empty) GeometryAnchor and prompt block.
+
+import logging
+from sympy import Rational, sympify
+
+from geometry_types import Point, Line, Segment, Circle, GeometryAnchor
+from constraint_checks import (
+    check_point_on_circle,
+    check_point_on_line,
+    check_is_diameter,
+    check_distance,
+    find_circle_center_from_diameters,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_point(raw: str, name: str) -> Point | None:
+    """
+    Parses a string like '(3, 5)' or '3,5' into a Point with SymPy Rational coords.
+    Returns None if unparseable (so the engine degrades gracefully).
+    """
+    try:
+        clean = raw.strip().strip("()")
+        parts = clean.split(",")
+        if len(parts) != 2:
+            return None
+        x = Rational(parts[0].strip())
+        y = Rational(parts[1].strip())
+        return Point(name=name, x=x, y=y)
+    except Exception as e:
+        logger.debug(f"[GEO-SANITY] Could not parse point '{raw}' as '{name}': {e}")
+        return None
+
+
+def _parse_radius(raw) -> object | None:
+    """
+    Parses a radius value into a SymPy Rational or expression.
+    """
+    try:
+        return Rational(raw)
+    except Exception:
+        try:
+            return sympify(str(raw))
+        except Exception as e:
+            logger.debug(f"[GEO-SANITY] Could not parse radius '{raw}': {e}")
+            return None
+
+
+def _build_prompt_block(anchor: GeometryAnchor) -> str:
+    """
+    Builds the 'VERIFIED MATHEMATICAL FACTS' block to be injected before LLM generation.
+    This is the final output consumed by prompts.py / strategy_manager.py.
+    """
+    facts_text = "\n".join(anchor.verified_facts) if anchor.verified_facts else "אין עובדות מאומתות."
+    warnings_text = "\n".join(anchor.warnings) if anchor.warnings else "אין סתירות."
+    
+    block = f"""
+╔══════════════════════════════════════════════════════╗
+║  VERIFIED MATHEMATICAL FACTS (GROUND TRUTH — V1.0)  ║
+╚══════════════════════════════════════════════════════╝
+{facts_text}
+
+╔══════════════════════════════════════════════════════╗
+║  CONSTRAINT VIOLATIONS (READ CAREFULLY)             ║
+╚══════════════════════════════════════════════════════╝
+{warnings_text}
+
+⚠️ הוראה קריטית: אם האינטואיציה שלך סותרת עובדה מאומתת לעיל,
+   **העובדה האלגברית תמיד מנצחת**. אל תמציא נתונים גיאומטריים
+   שאינם מאושרים כ-Verified Fact. כל ה-Verified Facts חושבו ע"י
+   SymPy ואינם ניתנים לערעור.
+╔══════════════════════════════════════════════════════╝
+"""
+    return block
+
+
+def run_geometric_sanity(data_anchor: dict) -> tuple[GeometryAnchor, str]:
+    """
+    V1.0: Main entry point. Parses the data_anchor dict and runs all applicable checks.
+    
+    Args:
+        data_anchor: dict — the raw anchor extracted by orchestrator._extract_key_data()
+    
+    Returns:
+        (GeometryAnchor, str) — the populated anchor + the prompt block for LLM injection.
+    
+    This function NEVER raises. All exceptions are caught and logged.
+    """
+    anchor = GeometryAnchor()
+
+    if not data_anchor:
+        logger.info("[GEO-SANITY] Empty data_anchor — skipping geometric checks.")
+        return anchor, ""
+
+    logger.info("[GEO-SANITY] 🔍 Starting Geometric Sanity Check...")
+
+    # ─── 1. Parse raw center & radius ───────────────────────────────────────────
+    raw_center = data_anchor.get("center")
+    raw_radius = data_anchor.get("radius")
+    circle = None
+
+    if raw_center and len(raw_center) == 2:
+        try:
+            cx = Rational(raw_center[0])
+            cy = Rational(raw_center[1])
+            center_point = Point(name="O", x=cx, y=cy)
+        except Exception as e:
+            center_point = None
+            logger.warning(f"[GEO-SANITY] Could not parse center {raw_center}: {e}")
+    else:
+        center_point = None
+
+    if center_point and raw_radius is not None:
+        r = _parse_radius(raw_radius)
+        if r is not None:
+            circle = Circle(center=center_point, radius=r)
+            anchor.circles.append(circle)
+            anchor.add_fact(f"✓ מעגל נטען: מרכז {center_point}, r={r}")
+
+    # ─── 2. Parse named points ────────────────────────────────────────────────
+    parsed_points: dict[str, Point] = {}
+
+    for field_name in ["point_a", "point_b", "point_c", "point_d"]:
+        raw = data_anchor.get(field_name)
+        if raw:
+            label = field_name.split("_")[-1].upper()
+            pt = _parse_point(str(raw), label)
+            if pt:
+                parsed_points[label] = pt
+                anchor.points.append(pt)
+
+    # Also parse points from the 'points' list (e.g., ["A(3,5)", "B(0,0)"])
+    for raw_point_str in data_anchor.get("points", []):
+        try:
+            # Match "A(3,5)" or "A(3, 5)"
+            import re
+            m = re.match(r'([A-Za-z]+)\s*\(([^)]+)\)', str(raw_point_str))
+            if m:
+                lbl = m.group(1)
+                coords = m.group(2).split(",")
+                if len(coords) == 2:
+                    px = Rational(coords[0].strip())
+                    py = Rational(coords[1].strip())
+                    pt = Point(name=lbl, x=px, y=py)
+                    parsed_points[lbl] = pt
+                    anchor.points.append(pt)
+        except Exception as e:
+            logger.debug(f"[GEO-SANITY] Could not parse points entry '{raw_point_str}': {e}")
+
+    # ─── 3. Run point-on-circle checks ───────────────────────────────────────
+    if circle:
+        for name, pt in parsed_points.items():
+            check_point_on_circle(pt, circle, anchor)
+
+    # ─── 4. Diameter check: if exactly 2 points, check if they form a diameter ─
+    if circle and len(parsed_points) >= 2:
+        names = list(parsed_points.keys())
+        for i in range(len(names)):
+            for j in range(i + 1, len(names)):
+                p_i = parsed_points[names[i]]
+                p_j = parsed_points[names[j]]
+                seg = Segment(p1=p_i, p2=p_j)
+                check_is_diameter(seg, circle, anchor)
+                anchor.segments.append(seg)
+
+    # ─── 5. Final summary log ─────────────────────────────────────────────────
+    logger.info(
+        f"[GEO-SANITY] ✅ Check complete. "
+        f"Facts: {len(anchor.verified_facts)}, Warnings: {len(anchor.warnings)}"
+    )
+
+    prompt_block = _build_prompt_block(anchor)
+    return anchor, prompt_block
+
+
+def build_verified_facts_prompt(anchor: GeometryAnchor) -> str:
+    """
+    Public helper: Re-builds the prompt block from an already-populated anchor.
+    Useful for re-injection after additional checks.
+    """
+    return _build_prompt_block(anchor)

geometry_types.py

@@ -0,0 +1,122 @@
+# geometry_types.py - V1.0 (Geometric Sanity Engine — Type Contracts)
+# CTO NOTE: All coordinate arithmetic uses SymPy Rational to guarantee
+# exact arithmetic — no float drift, no rounding surprises.
+
+from dataclasses import dataclass, field
+from sympy import Rational, simplify, sqrt
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Point:
+    name: str
+    x: object  # SymPy expression or numeric
+    y: object
+
+    def __eq__(self, other):
+        if not isinstance(other, Point):
+            return False
+        return (simplify(self.x - other.x) == 0 and
+                simplify(self.y - other.y) == 0)
+
+    def __repr__(self):
+        return f"{self.name}({self.x}, {self.y})"
+
+    def distance_to(self, other: "Point"):
+        """Exact SymPy distance between two points."""
+        return sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
+
+
+@dataclass
+class Line:
+    """Represents the line ax + by + c = 0."""
+    a: object
+    b: object
+    c: object
+
+    def y_at(self, x_val):
+        """Compute y given x (assuming b ≠ 0)."""
+        if simplify(self.b) == 0:
+            raise ValueError("[Line.y_at] Vertical line — b=0, y is undefined for a given x.")
+        return Rational(-self.a * x_val - self.c, self.b)
+
+    def contains(self, p: "Point") -> bool:
+        """Returns True if point p satisfies ax + by + c = 0."""
+        val = simplify(self.a * p.x + self.b * p.y + self.c)
+        return val == 0
+
+    def __repr__(self):
+        return f"Line({self.a}x + {self.b}y + {self.c} = 0)"
+
+
+@dataclass
+class Segment:
+    p1: Point
+    p2: Point
+
+    def midpoint(self) -> Point:
+        """Returns the midpoint with exact rational arithmetic."""
+        from sympy import Rational as R
+        mid_x = (self.p1.x + self.p2.x) / 2
+        mid_y = (self.p1.y + self.p2.y) / 2
+        return Point(
+            name=f"mid_{self.p1.name}{self.p2.name}",
+            x=simplify(mid_x),
+            y=simplify(mid_y)
+        )
+
+    def length(self):
+        """Exact SymPy length of the segment."""
+        return self.p1.distance_to(self.p2)
+
+    def __repr__(self):
+        return f"Segment({self.p1.name}{self.p2.name})"
+
+
+@dataclass
+class Circle:
+    center: Point
+    radius: object  # SymPy expression (can be symbolic)
+
+    def contains(self, p: Point) -> bool:
+        """Returns True if p lies exactly on the circle boundary."""
+        lhs = (p.x - self.center.x)**2 + (p.y - self.center.y)**2
+        return simplify(lhs - self.radius**2) == 0
+
+    def __repr__(self):
+        return f"Circle(center={self.center}, r={self.radius})"
+
+
+@dataclass
+class GeometryAnchor:
+    """
+    V1.0: The single source of truth for verified geometric facts.
+    Populated by `constraint_checks.py` and consumed by `geometric_sanity.py`.
+    """
+    points: list = field(default_factory=list)
+    lines: list = field(default_factory=list)
+    segments: list = field(default_factory=list)
+    circles: list = field(default_factory=list)
+    verified_facts: list = field(default_factory=list)
+    warnings: list = field(default_factory=list)
+
+    def add_fact(self, fact: str):
+        logger.info(f"[GEO-ANCHOR] ✓ FACT: {fact}")
+        self.verified_facts.append(fact)
+
+    def add_warning(self, warning: str):
+        logger.warning(f"[GEO-ANCHOR] ✗ WARNING: {warning}")
+        self.warnings.append(warning)
+
+    def is_clean(self) -> bool:
+        """True if no geometric contradictions were detected."""
+        return len(self.warnings) == 0
+
+    def summary(self) -> dict:
+        return {
+            "verified_facts": self.verified_facts,
+            "warnings": self.warnings,
+            "has_contradictions": not self.is_clean()
+        }

orchestrator.py

@@ -6,6 +6,7 @@ import logging, re
 import ocr_strip_engine  # V300: Stitch & Strip OCR engine
 from utils.safe_json import safe_extract_json           # V1.0: Canonical JSON extractor
 from domain.math_validator import MathPolygraph         # V1.0: SymPy Polygraph
+from geometric_sanity import run_geometric_sanity        # V1.0: Geometric Sanity Engine
 from domain.processing_strategy import ProcessingStrategy
 from domain.ontology import get_allowed_concepts, get_pedagogical_tag
 from domain.math_normalizer import MathCanonicalizer
@@ -2357,6 +2358,20 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
         if image_data and data_anchor:
             print("🛡️ [V8.9.2] Starting Data Anchor Validation Pass...")
             data_anchor = await self._validate_anchor(data_anchor, image_data, problem_text)
+
+        # V1.0: GEOMETRIC SANITY CHECK (Ground Truth Injection)
+        # Runs BEFORE the LLM to verify algebraic consistency of the extracted data.
+        # Injects 'verified_facts' and 'geometry_warnings' into the anchor.
+        try:
+            _geo_anchor, _geo_prompt_block = run_geometric_sanity(data_anchor)
+            if _geo_anchor.verified_facts or _geo_anchor.warnings:
+                data_anchor["_verified_facts"] = _geo_anchor.verified_facts
+                data_anchor["_geometry_warnings"] = _geo_anchor.warnings
+                data_anchor["_geo_prompt_block"] = _geo_prompt_block
+                print(f"🔬 [GEO-SANITY] Injected {len(_geo_anchor.verified_facts)} fact(s), "
+                      f"{len(_geo_anchor.warnings)} warning(s) into data_anchor.")
+        except Exception as _geo_err:
+            logging.warning(f"[GEO-SANITY] Non-fatal error: {_geo_err}")
         
         # Iterate through the streaming smart_solve
         # V5.10.2: Remove keys already passed explicitly to avoid TypeError collision

prompts.py

@@ -322,7 +322,13 @@ def get_specialist_prompt(category, problem_text, solver_hint, grade, student_na
     
     # Anchor Block — DATA INTEGRITY RULE
     anchor_block = ""
+    geo_verified_block = ""  # V1.0: Geometric Sanity Engine output
     if data_anchor:
+        # Extract and remove internal sanity keys before JSON serialization
+        geo_prompt_block = data_anchor.pop("_geo_prompt_block", "")
+        data_anchor.pop("_verified_facts", None)
+        data_anchor.pop("_geometry_warnings", None)
+
         anchor_block = f"""
     ══════════════════════════════════════════════════════
     📜 DATA INTEGRITY RULE (ABSOLUTE TRUTH):
@@ -338,6 +344,9 @@ def get_specialist_prompt(category, problem_text, solver_hint, grade, student_na
 
     CONSTRAINT: If the data says A(0,5), use A(0,5). If it contains f(x), solve that f(x).
     """
+        # V1.0: Inject verified geometric facts (if the sanity engine found anything)
+        if geo_prompt_block:
+            geo_verified_block = geo_prompt_block
 
     # V231.5: Gender-aware phrases
     if student_gender == "F":
@@ -417,6 +426,7 @@ def get_specialist_prompt(category, problem_text, solver_hint, grade, student_na
     TONE: {features['tone']}
     
     {anchor_block}
+    {geo_verified_block}
 
     🎯 המשימה: פתור את התרגיל בצורה פדגוגית, מעצימה ובשלבים ברורים.