Add AIFlow Math Ink 0.6 intermediate research snapshot

MANIFEST.json

@@ -0,0 +1,99 @@
+{
+    "schema":  "aiflow-hf-research-snapshot-v1",
+    "generated_at":  "2026-07-23T18:48:05.4863509Z",
+    "track":  "R_noncommercial_only",
+    "product_validation":  false,
+    "contains_raw_dataset":  false,
+    "files":  [
+                  {
+                      "path":  "artifacts/boundary_behavior_guard.joblib",
+                      "bytes":  824191,
+                      "sha256":  "18aff472c1bdb25a519b1553364229c9869aed1f36a9d663cf88a1bc808fab8f"
+                  },
+                  {
+                      "path":  "pyproject.snapshot.toml",
+                      "bytes":  669,
+                      "sha256":  "e9571da506b96d9ab6baa8f8e2c1d87cd8ee9fd0c880f3cf6646a99086ae3f09"
+                  },
+                  {
+                      "path":  "README.md",
+                      "bytes":  2800,
+                      "sha256":  "49ed73662471bdd8180f561c3b318aef49b3849ab71e541cbb88062530a27193"
+                  },
+                  {
+                      "path":  "reports/behavior_role_3seed_summary.json",
+                      "bytes":  3567,
+                      "sha256":  "b16049218d2d006d952f59f55642fa9f3fbfbc3cc3a730fbd7b075f507c3b251"
+                  },
+                  {
+                      "path":  "reports/boundary_behavior_guard_report.json",
+                      "bytes":  72053,
+                      "sha256":  "f55a230a9f0892b9676c71db46e9e527862b3d8da776dc43db767ce7a0f6a5c7"
+                  },
+                  {
+                      "path":  "reports/component_competition_report.json",
+                      "bytes":  22284,
+                      "sha256":  "4d3db5f71e5008381dd072f2c10aafb22e08f96e23f2a32f82a3a46abd9c70b9"
+                  },
+                  {
+                      "path":  "reports/local_baseline_guard_report.json",
+                      "bytes":  24052,
+                      "sha256":  "8f209b2890245f01f437c26e7556e19fee76c057d449c9382e2d64a70a3764d6"
+                  },
+                  {
+                      "path":  "reports/local_baseline_overmerge_audit.json",
+                      "bytes":  1237409,
+                      "sha256":  "33a9ccafebd559ca8b173f011e9a0a6f495d37b8fdb2693673663479d3457071"
+                  },
+                  {
+                      "path":  "reports/multistroke_family_guard_report.json",
+                      "bytes":  15740,
+                      "sha256":  "27b31da71b9f39f7ded38aa1ce3694911af140d22854543d4ae2b5f9e709b479"
+                  },
+                  {
+                      "path":  "reports/RESEARCH_REPORT.md",
+                      "bytes":  22993,
+                      "sha256":  "ef83f8145422cdf341ec14ebc5dab3d799e7fd3a0536398c70c0e67640cc1c59"
+                  },
+                  {
+                      "path":  "scripts/audit_math_ink_06_local_baseline_overmerge.py",
+                      "bytes":  11900,
+                      "sha256":  "f32a18c8e7d3a0ea36379293e6be88bfb509b7df99846c38149fb8458e6cc994"
+                  },
+                  {
+                      "path":  "scripts/evaluate_crohme_tray_joint_selector.py",
+                      "bytes":  11671,
+                      "sha256":  "58c175a95cdeb9fc764fb96594a76888122b8f118f2f26da1283e743b1a7cd04"
+                  },
+                  {
+                      "path":  "scripts/sweep_math_ink_06_component_competition_guard.py",
+                      "bytes":  9084,
+                      "sha256":  "e2dee616e2c6ebdc32281624889017685648b7076515242e04a1452d98d1c7da"
+                  },
+                  {
+                      "path":  "scripts/sweep_math_ink_06_local_baseline_guard.py",
+                      "bytes":  9063,
+                      "sha256":  "28cfc7b9b695256cfa9199d912d1d938d402292b88e9411d42fddb3508446d3b"
+                  },
+                  {
+                      "path":  "scripts/train_math_ink_06_boundary_behavior_guard.py",
+                      "bytes":  12461,
+                      "sha256":  "9fd410b402976416c12057a196babf6c98d971c41c23ae1a0e5f183c06a42b6e"
+                  },
+                  {
+                      "path":  "src/segmentation_lattice.py",
+                      "bytes":  13772,
+                      "sha256":  "8cc2dc1e13b56c21d53a76b9b863cdf5c8f8dd315da6eb18c1bd2b5b87c1a616"
+                  },
+                  {
+                      "path":  "src/structure_relations.py",
+                      "bytes":  9671,
+                      "sha256":  "59edbdcbfebaab029612beed132f38b69c84487f5ba930fd169f3278e10323bb"
+                  },
+                  {
+                      "path":  "src/tray_joint.py",
+                      "bytes":  19404,
+                      "sha256":  "160c2dd8db3dd4da77bdd21209a898b73fb0cb5a1b24e59d2c8bc54e159ea3e0"
+                  }
+              ]
+}

README.md

@@ -0,0 +1,64 @@
+---
+language:
+  - ko
+  - en
+library_name: scikit-learn
+license: other
+tags:
+  - handwriting
+  - mathematical-expression-recognition
+  - online-handwriting
+  - segmentation
+  - research
+---
+
+# AIFlow Math Ink 0.6 — Intermediate Research Snapshot
+
+이 저장소는 AIFlow Math Ink 0.6의 **중간 R-track 연구 스냅샷**이다. 전체 LaTeX OCR 또는 상용 ODA 모델이 아니며, 수식 stroke grouping과 행동 문맥 실험의 재현 자료를 보존한다.
+
+## 이번 스냅샷의 결론
+
+- protected multi-stroke family selector 기준 CROHME official test exact partition: **60.04%**
+- boundary behavior guard 적용 exact partition: **60.25%**
+- pair-F1: **91.07% → 91.26%**
+- overmerge formula rate: **21.72% → 20.49%**
+- validation에서 고정한 boundary 설정: probability threshold `0.5`, logit penalty weight `6.0`
+- 전체 로컬 Python 회귀: **271 passed**
+
+Boundary head는 grouping 전에 다획 후보가 둘 이상의 정답 기호 경계를 침범하는지 예측한다. 규칙형 component competition과 이미 grouping된 partition 이후의 local-baseline relation guard는 채택되지 않았다.
+
+## 디렉터리
+
+- `artifacts/`: scikit-learn boundary 연구 head
+- `reports/`: validation/test 지표와 실패 감사
+- `scripts/`: 학습·sweep·감사 entry point
+- `src/`: 이번 실험에 직접 관련된 selector/관계 코드 snapshot
+
+## 사용 제한
+
+이 스냅샷은 **연구 전용**이다.
+
+- `boundary_behavior_guard.joblib`은 CROHME 정답 grouping으로 학습된 R-track 산출물이다.
+- 상용 제품, 배포 checkpoint, teacher 또는 distillation 입력으로 사용하지 않는다.
+- CROHME/HWRT 원본 데이터, 필기 표본, OCR cache는 이 저장소에 포함하지 않는다.
+- 상용 전환은 동일 boundary target을 상용 허용 P-track 연속식 데이터로 다시 학습해야 한다.
+- 개별 외부 데이터셋의 원 라이선스와 사용 조건은 사용자가 별도로 확인해야 한다.
+
+## 보안 주의
+
+`joblib`/pickle 계열 파일은 임의 코드를 실행할 수 있다. 이 저장소와 파일 checksum을 신뢰하는 환경에서만 로드한다.
+
+```python
+import joblib
+
+payload = joblib.load("artifacts/boundary_behavior_guard.joblib")
+print(payload["schema"])
+print(payload["feature_names"])
+print(payload["threshold"], payload["weight"])
+```
+
+## 재현 경계
+
+포함된 script는 전체 AIFlow 프로젝트와 사용자가 별도로 확보한 데이터셋이 있어야 완전 실행된다. 공식 test는 validation 선택에 사용하지 않았지만, 반복 연구 과정에서 test 실패를 관찰했으므로 여기에 기록된 결과는 독립 제품 인증 수치가 아니다.
+
+자세한 설계·실패 분석·후속 P-track 계획은 `reports/RESEARCH_REPORT.md`를 참고한다.

artifacts/boundary_behavior_guard.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18aff472c1bdb25a519b1553364229c9869aed1f36a9d663cf88a1bc808fab8f
+size 824191

pyproject.snapshot.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "math-grid-drawer-simulation"
+version = "0.1.0"
+description = "필기 수식 stroke 그리딩을 실험하는 독립 Python 드로워"
+requires-python = ">=3.11"
+dependencies = ["Pillow>=10,<12"]
+
+[project.optional-dependencies]
+recognition = ["numpy>=1.26,<3", "torch>=2.2,<3", "transformers==4.47.0", "safetensors>=0.4,<1"]
+research = [
+  "numpy>=1.26,<3",
+  "opencv-contrib-python-headless>=4.10,<5",
+  "scikit-learn>=1.5,<2",
+  "torch>=2.2,<3",
+]
+
+[project.scripts]
+math-grid-drawer = "math_grid_drawer.app:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

reports/RESEARCH_REPORT.md

@@ -0,0 +1,363 @@
+# AIFlow Math Ink 0.6 — 행동 문맥 모델 전환 보고서
+
+## 결론
+
+0.6의 남은 정확도는 고립 기호 분류기만 더 학습해서 해결되지 않는다. 동일한 교차획이 `x`, `X`, `\times`가 될 수 있고, 동일한 대문자도 분자·분모·첨자처럼 축소된 수식 슬롯에서는 식 전체 높이와 비교할 수 없기 때문이다.
+
+따라서 다음 책임 분리를 채택한다.
+
+1. trajectory/raster 신경망은 형태 후보 top-k와 확률을 만든다.
+2. Tray·관계 레이어는 분자·분모·첨자·피개항 등 로컬 좌표계를 만든다.
+3. 행동 문맥 레이어는 획 행동, 로컬 크기, 이웃 후보, 간격, Tray 역할을 사용해 같은 형태군 안의 의미만 재점수화한다.
+4. 수식 gate와 LaTeX 문법은 그 뒤에서 작동한다.
+5. 행동 증거가 부족하면 원래 top-k를 그대로 반환한다.
+
+```text
+touch / raster
+→ 128×128 정규화·trajectory encoder
+→ 기호 top-k
+→ segmentation lattice·Tray·2D relation
+→ 행동 문맥 모델
+   ├─ 로컬 슬롯별 대소문자
+   ├─ x / X / \times 의미 역할
+   └─ O / o / 0 등 hard-family 후보 보존
+→ math/non-math gate
+→ Formula Expert·LaTeX
+```
+
+행동 모델은 glyph 인식기를 덮어쓰는 새 OCR이 아니다. 신경망이 보존한 후보군 안에서 사용자가 그 기호를 어떤 역할로 배치했는지 추정하는 작은 후단 모델이다.
+
+## 지금까지 확인된 연구 결과
+
+### Online/shared encoder
+
+- 승인 HWRT·UJI Pen v1/v2·Pendigits 기반 128-step·19-channel 경로를 구축했다.
+- seed 17·31·47 paired test 평균은 exact top-1 `83.00%`, top-5 `97.78%`, family top-1 `91.37%`다.
+- logit ensemble은 exact `83.82%`, top-5 `98.04%`, casefold `90.93%`, shape-family `93.02%`다.
+- exact 오류의 `43.95%`가 대소문자만 다른 오류이고 `56.86%`가 같은 shape family 안의 오류다.
+- 이는 형태 후보는 상당 부분 살아 있으나 최종 의미 배정이 병목이라는 근거다.
+
+### Raster→virtual stroke
+
+- top-4 virtual stroke와 shared encoder 재입력 경로를 구현했다.
+- 후보 다양성은 개선됐지만 최종 raster 정확도는 release gate에 크게 미달했다.
+- 3-seed 차이가 작아 seed variance보다 vectorizer와 online feature 분포 정렬이 주 병목이다.
+- 따라서 행동 문맥은 raster vectorizer 병목을 감추는 대체물이 아니며, 두 문제를 별도 gate로 측정해야 한다.
+
+### 대소문자 문맥
+
+- `k/p/y`처럼 획 자체가 다른 쌍은 exact head가 담당한다.
+- `c/o/s/u/v/w/x/z`처럼 주 차이가 상대 높이인 쌍만 context head가 담당한다.
+- 기존 행 전체 기준 proxy는 validation `70.31→72.14%`, test `62.19→67.34%`로 개선됐지만, 연속 수식 P 데이터의 제품 근거는 아니다.
+- 행 전체 기준은 축소된 분수·첨자 안의 대문자를 소문자로 내릴 수 있으므로 이번 구현에서 로컬 슬롯 기준으로 교체했다.
+
+### 구조·Tray
+
+- 분수선은 완성된 분자·분모가 있을 때만 `FRACTION` Tray를 만든다.
+- 근호는 radicand와 선택적 degree, 적분은 integrand와 선택적 upper/lower/differential을 분리한다.
+- `=` 인식은 좌우 식의 완성 여부와 독립적으로 보존한다.
+- Tray는 기호 이름을 결정하지 않고 기호가 놓인 수학적 슬롯과 로컬 기준선만 제공한다.
+
+## `x`, `X`, `\times` 판단
+
+`2 ? 3`이라는 이웃 정보만으로 가운데를 곱하기로 확정할 수 없다. 사용자가 변수 `x` 또는 문자 `X`를 숫자 사이에 쓸 수도 있기 때문이다. 이 모호성은 문법만으로 완전히 제거할 수 없다.
+
+현재 행동 레이어는 다음 원칙을 적용한다.
+
+- 양옆 숫자는 보조 feature로만 사용한다.
+- 교차획 시각 확률, infix 점유, 연산자형 간격, 명시적 operator context 중 하나 이상의 구조 증거가 없으면 no-op이다.
+- 조건을 통과해도 `x/X/\times` family의 총 logit 질량을 보존한 채 `\times` prior만 더한다.
+- 원 신경망의 `X` 증거가 충분히 강하면 행동 prior가 뒤집지 못한다.
+- 본질적으로 모호한 입력은 top-k와 낮은 confidence로 반환하며 거짓 확정을 하지 않는다.
+
+향후 학습 feature는 다음과 같다.
+
+- 원 신경망의 family logits와 entropy
+- 앞뒤 token의 digit/identifier/operator 확률 질량
+- 좌우 간격, 중심선 정렬, 로컬 높이비
+- 교차획의 방향·획순서·pen-up·속도·시간 간격
+- segmentation lattice의 infix 점수
+- Tray ID·slot·관계 edge
+- observed/canonical timestamp와 missing mask
+
+학습 target은 원 glyph 이름 하나가 아니라 `identifier_lower`, `identifier_upper`, `multiply_operator`, `other/abstain` 의미 역할로 둔다.
+
+## 분수·첨자 안의 대소문자
+
+대문자 여부는 식 전체 canvas 높이와 비교하지 않는다.
+
+- main row
+- fraction numerator
+- fraction denominator
+- superscript/subscript
+- root degree/radicand
+- integral upper/lower/integrand
+
+각 슬롯을 별도의 `local_context_id`로 묶고, 같은 슬롯의 신뢰 가능한 숫자·형태 문자만 높이 anchor로 사용한다. 슬롯에 anchor가 없으면 case logits를 보존한다. 이 원칙은 작은 분자 안의 `X`를 main row보다 작다는 이유로 `x`로 강등하는 오류를 막는다.
+
+## 구현
+
+`behavior_context06.py`를 추가하고 `math_context_layer.py` 앞단에 연결했다.
+
+공개 입력 계약은 record별 다음 선택 feature를 사용한다.
+
+```json
+{
+  "behavior_context": {
+    "local_context_id": "fraction:f1:numerator",
+    "cross_visual_probability": 0.91,
+    "infix_occupancy": 0.94,
+    "operator_spacing_score": 0.82,
+    "explicit_operator_context": 0.0
+  }
+}
+```
+
+Tray가 있으면 `tray_id + tray_slot`, 일반 행이면 `baseline_group`, 아무 정보도 없으면 `main`을 사용한다. `FRACTION.numerator/denominator`와 구조 관계의 `SUPERSCRIPT/SUBSCRIPT/ABOVE/BELOW/CONTAINS`는 별도 수작업 없이 로컬 context로 자동 변환한다.
+
+회귀 검증은 다음 네 항목을 고정했다.
+
+1. 축소된 분자 안의 `X` 보존
+2. 숫자 이웃만으로 `\times` 강제 금지
+3. 획·infix·간격 증거가 겹친 애매한 교차획의 소프트 `\times` 선택과 family 질량 보존
+4. 강한 원본 `X` logit 보존
+
+관련 context 회귀 테스트는 `15/15`, 전체 Python 회귀 테스트는 `264/264` 통과했다.
+
+## 행동 모델 파인튜닝 계획
+
+### 단계 A — shadow feature 수집
+
+기존 모델 weight는 고정하고 각 기호에 top-k, geometry, stroke behavior, Tray slot을 붙여 저장한다. 이미지나 원 stroke를 서버로 보내지 않는 온디바이스 원칙은 유지한다. 연구 데이터에는 원본 provenance와 writer/source/device split을 보존한다.
+
+### 단계 B — 작은 role head
+
+행동 head는 모바일 student에 붙일 수 있는 작은 TCN/MLP로 시작한다. pixel encoder를 다시 크게 학습하지 않고 다음 multi-task를 사용한다.
+
+- cross semantic role CE
+- local case role CE
+- Tray slot consistency loss
+- 원 family logit 보존 KL
+- abstain/calibration loss
+
+초기 loss weight는 validation sweep 대상이며 아직 배포 상수로 고정하지 않는다.
+
+### 단계 C — 실제 수식 검증
+
+합성 조합은 데이터 증강으로만 사용한다. 최종 선택은 writer/device/source-disjoint 연속 수식에서 수행한다.
+
+- `x/X/\times` role top-1·top-k와 confusion matrix
+- local slot별 case exact
+- unchanged-safe rate: 행동 증거가 없는 표본의 원 top-1 보존율
+- family oracle 대비 회수율
+- ECE와 abstain coverage/accuracy
+- main/numerator/denominator/script slice 최저 성능
+
+비상용·용도 제한 데이터는 연구 평가에만 사용하고 배포 checkpoint 학습에는 포함하지 않는다.
+
+## 현재 판단
+
+- 행동 모델 방향 채택: **예**
+- 기존 case layer를 로컬 슬롯 행동 layer로 교체: **예**
+- `x/X/\times` hard rewrite: **아니오**
+- CROHME R-track 조건부 역할 정확도 상승 확인: **예**
+- 이를 제품 수치로 주장: **아니오**
+- 0.6 상용 카나리: **아직 아니오**
+
+## 첫 GPU 행동학습 결과
+
+기존 3-seed glyph teacher를 각각 동결하고 `128×19 stroke TCN + 49차 문맥 MLP` 행동 head를 GTX 1650 CUDA에서 학습했다. CROHME 2012 `trainData`는 writer 기준 fit 1,063식/validation 275식으로 나눴고 `testDataGT` 488식은 공식 held-out으로만 한 번 평가했다.
+
+역할 분모는 다음과 같다.
+
+| split | lower identifier | upper identifier | multiply operator |
+|---|---:|---:|---:|
+| fit | 1,573 | 99 | 177 |
+| validation | 401 | 22 | 44 |
+| official test | 568 | 31 | 36 |
+
+head 입력에는 다음을 사용했다.
+
+- seed별 frozen 0.6 teacher의 lower/upper/times logits
+- target 원본 stroke의 순서·방향·pen-up을 보존한 128×19 sequence
+- 좌우 이웃의 정답 label이 아닌 teacher 예측 역할 확률
+- bbox, 간격, 중심선, 로컬 높이·폭 비율
+- 19개 cross visual feature와 stroke/point 수
+
+| 지표 | seed 17 | seed 31 | seed 47 | 평균 ± 표준편차 |
+|---|---:|---:|---:|---:|
+| teacher role accuracy | 74.33% | 60.79% | 60.94% | 65.35 ± 6.35%p |
+| behavior role accuracy | 93.07% | 93.86% | 93.07% | **93.33 ± 0.37%p** |
+| behavior macro-F1 | 76.64% | 77.17% | 75.42% | **76.41 ± 0.73%p** |
+| lower recall | 95.07% | 96.30% | 95.60% | 95.66 ± 0.50%p |
+| upper recall | 61.29% | 51.61% | 54.84% | **55.91 ± 4.02%p** |
+| multiply recall | 88.89% | 91.67% | 86.11% | **88.89 ± 2.27%p** |
+| ECE | 4.73% | 5.09% | 4.82% | 4.88 ± 0.15%p |
+
+평균 accuracy 이득은 `+27.98%p`이고 seed 간 편차도 작아 행동 문맥 방향은 유효하다. 특히 frozen teacher가 세 seed 모두 `\times`를 0% 회수하던 조건에서 행동 head는 86.11~91.67%를 회수했다.
+
+그러나 다음 한계 때문에 제품 승격은 금지한다.
+
+1. 정답 symbol grouping 이후의 조���부 역할 평가다. segmentation 오류는 분모에 없다.
+2. CROHME R-track weight라 상용 checkpoint에 병합할 수 없다.
+3. official test의 대문자 분모는 31개뿐이며 recall 평균도 55.91%다.
+4. 분수·첨자 로컬 case의 실제 device-disjoint 제품 분모가 아니다.
+5. 세 teacher별 head는 약 75.8KB지만 distillation/온디바이스 변환 단계로 넘기지 않는다.
+
+따라서 첫 학습 결론은 `x/X/\times` 의미 역할 head 채택, 대문자 데이터 확장, predicted grouping end-to-end 재평가다. 제품용 다음 학습은 승인된 trajectory를 수학 배치로 합성한 약한 P-compatible proxy와 실제 상용 허용 연속식 데이터를 구분해 사용해야 한다.
+
+## 후속 루프 — 합성 대문자와 predicted grouping
+
+### 승인 trajectory 분모
+
+HWRT·UJI Pen v1/v2의 writer-disjoint training split에는 상대크기군 각 대·소문자가 약 90~111개씩 있다. 이를 실제 stroke 그대로 사용하고 수식 행의 높이·좌우 숫자 anchor만 합성한 P-compatible proxy를 만들었다.
+
+첫 후보는 8개 case family 1,590개를 loss weight 0.35로 추가했다. 두 번째 후보는 실제 CROHME fit 정규화 통계를 고정하고 `c/x/z` family의 대문자 284개와 소문자 77개만 weight 0.15로 추가했다.
+
+| seed 17 official test | 원 behavior | 전체 proxy | targeted proxy |
+|---|---:|---:|---:|
+| accuracy | 93.07% | 93.39% | 93.39% |
+| macro-F1 | 76.64% | 75.62% | 76.45% |
+| upper recall | **61.29%** | 51.61% | 54.84% |
+| multiply recall | 88.89% | 86.11% | 88.89% |
+
+두 후보 모두 목표인 upper recall을 악화시켰다. 고립기호를 인위적으로 키운 데이터는 실제 연속식의 대문자 행동 분포를 대체하지 못하므로 조기 기각했고 seed 31·47로 확장하지 않았다. 작은 전체 accuracy 상승을 근거로 채택하지 않는다.
+
+로컬 MathWriting 2024 excerpt는 train/valid/test 각 100식과 symbols/synthetic 각 100개가 있지만 formula InkML에 symbol-to-stroke group 정답이 없다. LaTeX 문자열과 전체 stroke만으로 대문자 역할 target을 강제 정렬하면 label·필순을 발명하게 되므로 supervised behavior 학습에 넣지 않는다.
+
+### Predicted grouping 감사
+
+공식 test 488식의 행동 대상 635개를 validation에서 고정한 lattice selector로 다시 평가했다.
+
+| grouping 경로 | 전체 target | lower | upper | `\times` | `x` exact group |
+|---|---:|---:|---:|---:|---:|
+| base OCR fusion | 81.89% | 79.93% | 96.77% | 100% | 75.56% |
+| Tray/infix joint | 81.42% | 79.58% | 93.55% | 100% | 75.11% |
+| cross-visual + Tray/infix, gap 20% | 91.02% | 90.32% | 93.55% | 100% | 88.89% |
+| full selector, gap 50% | 93.39% | 92.96% | 93.55% | 100% | **92.22%** |
+| **protected family selector, gap 40%** | **92.91%** | **92.43%** | 93.55% | 100% | 91.56% |
+
+base에서 실패 115건 중 `x`가 110건이고, 그중 96건이 두 획 oversplit이었다. 최초 cross-visual 결합은 전체 oversplit을 98→42건으로 줄이고 `x` exact grouping을 `+13.33%p` 올렸다. 반면 cross model 없는 Tray/infix 단독은 소폭 악화돼 행동 grouping 경로로 채택하지 않는다.
+
+현재 병목은 다음처럼 분리된다.
+
+1. `x`: 최종 결합 후 grouping recall은 91.56%로 90%대를 유지하며 잔여 38건은 oversplit 26, overmerge/혼합 12다.
+2. `X/C`: upper 역할 grouping은 93.55%이므로 주 병목은 behavior role head와 실제 연속식 대문자 데이터다.
+3. `\times`: grouping 100%, conditional role recall 88.89%이므로 의미 head가 병목이다.
+4. grouping과 role 오류가 독립이라고 가정한 근사 end-to-end recall은 lower 88.42%, upper 52.31%, multiply 88.89%다. 이는 실측 end-to-end 수치가 아니므로 제품 지표로 사용하지 않는다.
+5. 전체 488식 exact partition은 60.04%이며 fraction·superscript·단일기호 overmerge가 다음 segmentation 병목이다.
+
+따라서 R-track grouping 기준선은 `equality + cross-visual + protected multistroke family + Tray/infix`, cross gap ratio `0.40`으로 갱신한다. 대문자는 합성 isolated proxy가 아니라 실제 symbol-group annotation이 있는 연속식만 다음 supervised 학습 후보로 허용한다.
+
+### x prefilter 병목과 gap validation sweep
+
+실패를 candidate 생성→cross head→exact-cover selector로 분해했다. 두 획 `x`의 lattice candidate recall은 validation/test 모두 100%이고 test cross threshold recall은 98.37%였다. 그런데 실패 후보의 cross 확률 중앙값도 0.929인데 `infix_signal=0`이었다. 원인은 cross head 앞의 bbox gap 20% prefilter가 좌우 곡선 `)(`형 x를 모델에 전달하지 않은 것이다.
+
+전역 threshold와 merge weight를 고정하고 gap ratio `0.20~0.80`만 writer-validation에서 선택했다. Validation winner `0.50`을 equality head까지 포함한 full selector의 공식 test에 적용했다.
+
+| 지표 | gap 20% | **gap 50%** | 변화 |
+|---|---:|---:|---:|
+| validation `x` grouping | 82.31% | **88.45%** | +6.14%p |
+| validation exact partition | 63.27% | **65.82%** | +2.55%p |
+| validation pair-F1 | 91.00% | **91.69%** | +0.69%p |
+| official test `x` grouping | 88.89% | **92.22%** | +3.33%p |
+| official test exact partition | 53.69% | **54.51%** | +0.82%p |
+| official test pair-F1 | 88.38% | **88.72%** | +0.35%p |
+
+gap 50%는 이 단계에서 전 지표가 함께 올라 채택했다. 이후 같은 기준에서 threshold `0.5`, weight `10`의 공격 후보는 test `x`를 94.44%로 올렸지만 exact partition 54.51→53.89%, pair-F1 88.72→88.41%, overmerge 21.11→23.57%로 악화돼 기각했다. 다획 family boost와 결합한 validation 재선택에서는 동일 test 성능을 내는 더 좁은 gap `0.40`이 선택됐다. 최종 cross 값은 gap `0.40`, threshold `0.692841...`, infix weight `8`이다.
+
+### 다획 family must-link와 geometry 보호
+
+`sum/pi/rightarrow/neq/pm`은 candidate recall이 validation/test 모두 100%였지만 합친 OCR alias가 기존 reliable 목록과 연결되지 않거나 3개의 singleton 점수에 밀렸다. `Sigma/pi-family/arrow-family/neq/pm` 후보에만 추가 symbol signal을 주고 boost `0~6`을 writer-validation에서 선택했다.
+
+| 공식 test grouping | 기준 | boost 6 + 보호 |
+|---|---:|---:|
+| 다섯 family 전체 | 45.19% | **82.96%** |
+| `\sum` | 25.81% | **70.97%** |
+| `\pi` | 40.00% | **90.00%** |
+| `\rightarrow` | 71.43% | **89.80%** |
+| `\neq` | 23.08% | **76.92%** |
+| `\pm` | 25.00% | **75.00%** |
+
+무보호 boost 6은 전체식 exact 57.38%까지 올렸지만 `hookrightarrow`, 좁은 `Sigma`, 세로로 긴 `pm` 오인이 단일기호를 먹었다. Training writer-validation의 실제 geometry 범위에서 arrow `pair_gap_max≤0.50`, `Sigma width_ref≥2.0`, `pm height_ref≤2.0` guard를 만들고 ontology 밖 `hookrightarrow` alias를 제거했다. 보호 후 공식 test exact는 **60.04%**, pair-F1은 **91.07%**, overmerge formula rate는 21.72%다. Gap-only 대비 각각 +5.53%p, +2.35%p이며 overmerge 증가는 +0.61%p로 제한됐다.
+
+### 최종 잔여 segmentation 병목
+
+최종 full selector의 488식 잔여 실패는 exact 293, oversplit 89, overmerge 72, 혼합 34다. 구조별 exact는 sqrt 68.00%, plain 63.95%, subscript 57.01%, superscript 52.75%, fraction 52.10%다. 3획 기호 correct는 34→63개로 늘었고 oversplit은 57→32개로 줄었다.
+
+| label | 오류/전체 | 주 실패 |
+|---|---:|---|
+| `x` | 38/450 | oversplit 26, overmerge·혼합 12 |
+| `1` | 36/482 | 주변 획과 overmerge |
+| `-` | 36/584 | overmerge |
+| `\sin` physical part | 35/297 | overmerge 15, oversplit 18 |
+| `\sum` | 9/31 | oversplit 8 |
+| `i` | 9/41 | oversplit |
+| `F` | 7/10 | oversplit |
+| `\div` | 7/11 | oversplit |
+
+따라서 다음 우선순위는 전역 threshold가 아니라 분수·위첨자에서 `1/-/괄호`가 이웃 Tray로 넘어가지 않게 하는 local-baseline must-not-link, 그리고 남은 `F/div/i` 다획 family다.
+
+### Local-baseline 감사와 학습형 boundary 행동 head
+
+최종 selector의 overmerge를 정답 기호 단위로 다시 연결했다. 공식 test에는 299개 overmerge event와 149개 고유 선택 후보가 있었다. 오류가 집중된 정답은 `1` 36건, `-` 36건, 괄호 53건이며 구조별로 superscript 150건, fraction 112건, subscript 96건이 겹쳐 있었다. 기존 fraction penalty는 299건 중 4건에만 신호를 냈다.
+
+두 규칙형 가드는 채택하지 않았다.
+
+1. 합친 OCR이 구성획보다 약할 때 감점하는 component competition은 validation exact를 개선하지 못하고 family grouping을 악화시켜 weight 0을 선택했다.
+2. base partition에서 `SUPERSCRIPT/SUBSCRIPT/ABOVE/BELOW/CONTAINS` edge를 만든 local-baseline guard는 validation 3,293개·test 5,061개 후보에 신호를 만들었지만 실제 149개 오병합 후보에는 유효 신호가 0개였다. 이미 오병합된 partition 뒤에서 관계를 만들었기 때문에 내부 경계를 복원할 수 없었다.
+
+이에 grouping 이전의 모든 다획 후보를 대상으로, 둘 이상의 정답 기호를 침범하는지를 예측하는 geometry boundary 행동 head를 fit writer에 학습했다. 72,223개 후보 중 66,842개가 boundary 양성이며, validation에서 threshold 0.5·penalty weight 6을 선택했다.
+
+| 지표 | 보호 selector | boundary 행동 head | 변화 |
+|---|---:|---:|---:|
+| validation exact partition | 68.00% | **69.82%** | +1.82%p |
+| validation pair-F1 | 92.98% | **93.64%** | +0.66%p |
+| official exact partition | 60.04% | **60.25%** | +0.20%p |
+| official pair-F1 | 91.07% | **91.26%** | +0.19%p |
+| official overmerge formula | 21.72% | **20.49%** | -1.23%p |
+| official `x` grouping | 91.56% | 91.33% | -0.22%p |
+| official 다획 family grouping | 82.96% | 81.48% | -1.48%p |
+
+사전 정의한 `x` -1%p, family -2%p, pair-F1 -0.25%p 보호 gate 안에서 exact와 pair-F1이 함께 올라 R-track head로 채택한다. 다만 CROHME 정답 경계로 학습한 비상업 연구 weight이므로 제품 checkpoint·teacher·distillation에는 사용할 수 없다. 상용 이전 경로는 동일 boundary target을 P-track 연속식으로 재학습하거나 shared trajectory encoder의 auxiliary boundary loss로 옮기는 것이다. 전체 Python 회귀는 271개가 통과했다.
+
+## 산출물
+
+- `src/math_grid_drawer/research/behavior_context06.py`
+- `src/math_grid_drawer/research/behavior_role_head06.py`
+- `src/math_grid_drawer/research/math_context_layer.py`
+- `scripts/train_math_ink_06_behavior_role.py`
+- `scripts/summarize_math_ink_06_behavior_seeds.py`
+- `scripts/audit_math_ink_06_behavior_grouping.py`
+- `scripts/audit_math_ink_06_x_edge_bottleneck.py`
+- `scripts/sweep_math_ink_06_x_grouping_guard.py`
+- `scripts/sweep_math_ink_06_cross_gap_guard.py`
+- `scripts/audit_math_ink_06_multistroke_families.py`
+- `scripts/sweep_math_ink_06_multistroke_family_guard.py`
+- `scripts/audit_math_ink_06_multistroke_guard_regressions.py`
+- `scripts/audit_math_ink_06_local_baseline_overmerge.py`
+- `scripts/sweep_math_ink_06_component_competition_guard.py`
+- `scripts/sweep_math_ink_06_local_baseline_guard.py`
+- `scripts/train_math_ink_06_boundary_behavior_guard.py`
+- `scripts/analyze_crohme_lattice_failures.py`
+- `tests/test_behavior_context06.py`
+- `tests/test_behavior_role_head06.py`
+- `research/AIFlow-MATH-INK-0.6-BEHAVIOR-CONTEXT-REPORT-20260724.md`
+- `research/runs/math_ink_06_behavior_role_3seed_20260724/run_summary.json`
+- `research/runs/math_ink_06_behavior_grouping_audit_20260724/report.json`
+- `research/runs/math_ink_06_behavior_grouping_cross_joint_audit_20260724/report.json`
+- `research/runs/math_ink_06_x_grouping_guard_20260724/report.json`
+- `research/runs/math_ink_06_x_edge_bottleneck_20260724/report.json`
+- `research/runs/math_ink_06_cross_gap_guard_full_selector_20260724/report.json`
+- `research/runs/math_ink_06_behavior_grouping_full_selector_gap50_20260724/report.json`
+- `research/runs/math_ink_06_x_grouping_guard_gap50_full_selector_20260724/report.json`
+- `research/runs/math_ink_06_full_selector_gap50_failure_audit_20260724/report.json`
+- `research/runs/math_ink_06_cross_gap_guard_family6_full_selector_20260724/report.json`
+- `research/runs/math_ink_06_multistroke_family_guard_geometry_protected_20260724/report.json`
+- `research/runs/math_ink_06_multistroke_guard_regression_audit_20260724/report.json`
+- `research/runs/math_ink_06_full_selector_gap40_family6_protected_failure_audit_20260724/report.json`
+- `research/runs/math_ink_06_behavior_grouping_full_selector_gap40_family6_protected_20260724/report.json`
+- `research/runs/math_ink_06_component_competition_guard_20260724/report.json`
+- `research/runs/math_ink_06_local_baseline_guard_20260724/report.json`
+- `research/runs/math_ink_06_local_baseline_overmerge_audit_20260724/report.json`
+- `research/runs/math_ink_06_boundary_behavior_guard_20260724/report.json`

reports/behavior_role_3seed_summary.json

@@ -0,0 +1,132 @@
+{
+  "experiment": "R-MATH-INK-06-BEHAVIOR-ROLE-3SEED-001",
+  "generated_at": "2026-07-23T16:44:02.899929+00:00",
+  "seeds": [
+    17,
+    31,
+    47
+  ],
+  "reports": [
+    "research\\runs\\math_ink_06_behavior_role_seed17_20260724\\report.json",
+    "research\\runs\\math_ink_06_behavior_role_seed31_20260724\\report.json",
+    "research\\runs\\math_ink_06_behavior_role_seed47_20260724\\report.json"
+  ],
+  "split_contract": "CROHME2012 trainData writer fit/validation; testDataGT official held-out",
+  "denominator": {
+    "formulas": {
+      "fit": 1063,
+      "validation": 275,
+      "official_test": 488
+    },
+    "role_samples": {
+      "fit": {
+        "identifier_lower": 1573,
+        "multiply_operator": 177,
+        "identifier_upper": 99
+      },
+      "validation": {
+        "identifier_lower": 401,
+        "multiply_operator": 44,
+        "identifier_upper": 22
+      },
+      "official_test": {
+        "identifier_lower": 568,
+        "identifier_upper": 31,
+        "multiply_operator": 36
+      }
+    }
+  },
+  "teacher_official_test": {
+    "accuracy": {
+      "values": [
+        0.7433071136474609,
+        0.6078740358352661,
+        0.6094487905502319
+      ],
+      "mean": 0.6535433133443197,
+      "std": 0.06347584762070135,
+      "minimum": 0.6078740358352661
+    },
+    "macro_f1": {
+      "values": [
+        0.3644206619715246,
+        0.31082213130722774,
+        0.31121831754743146
+      ],
+      "mean": 0.3288203702753946,
+      "std": 0.02517372727695006,
+      "minimum": 0.31082213130722774
+    }
+  },
+  "behavior_official_test": {
+    "accuracy": {
+      "values": [
+        0.930708646774292,
+        0.9385826587677002,
+        0.930708646774292
+      ],
+      "mean": 0.9333333174387614,
+      "std": 0.00371184485045543,
+      "minimum": 0.930708646774292
+    },
+    "macro_f1": {
+      "values": [
+        0.7664031279554507,
+        0.7717349248806314,
+        0.7541782507773837
+      ],
+      "mean": 0.764105434537822,
+      "std": 0.0073493195908634484,
+      "minimum": 0.7541782507773837
+    },
+    "identifier_lower_recall": {
+      "values": [
+        0.9507042253521126,
+        0.9630281690140845,
+        0.9559859154929577
+      ],
+      "mean": 0.9565727699530516,
+      "std": 0.0050483129501424015,
+      "minimum": 0.9507042253521126
+    },
+    "identifier_upper_recall": {
+      "values": [
+        0.6129032258064516,
+        0.5161290322580645,
+        0.5483870967741935
+      ],
+      "mean": 0.5591397849462365,
+      "std": 0.040232875126601536,
+      "minimum": 0.5161290322580645
+    },
+    "multiply_operator_recall": {
+      "values": [
+        0.8888888888888888,
+        0.9166666666666666,
+        0.8611111111111112
+      ],
+      "mean": 0.8888888888888888,
+      "std": 0.02268046058132569,
+      "minimum": 0.8611111111111112
+    },
+    "ece": {
+      "values": [
+        0.04725504415735027,
+        0.050884793443143006,
+        0.048238128075605236
+      ],
+      "mean": 0.04879265522536617,
+      "std": 0.0015328394652397476,
+      "minimum": 0.04725504415735027
+    }
+  },
+  "diagnosis": {
+    "behavior_accuracy_gain_pp": 27.979000409444165,
+    "stable_across_seeds": true,
+    "remaining_bottleneck": "identifier_upper recall; official test denominator 31",
+    "conditional_scope": "truth symbol grouping 이후 semantic role 분류"
+  },
+  "track": "R_noncommercial_only",
+  "product_validation": false,
+  "distillation_allowed": false
+}

reports/boundary_behavior_guard_report.json

@@ -0,0 +1,2735 @@
+{
+  "experiment": "R-MATH-INK-06-BOUNDARY-BEHAVIOR-GUARD-001",
+  "generated_at": "2026-07-23T18:44:45.356755+00:00",
+  "training": {
+    "candidate_rows": 72223,
+    "boundary_rows": 66842,
+    "boundary_rate": 0.9254946485191697
+  },
+  "feature_names": [
+    "stroke_count",
+    "point_count_log",
+    "width_ref",
+    "height_ref",
+    "aspect_log",
+    "temporal_span",
+    "temporal_contiguous",
+    "singleton",
+    "geometry_votes",
+    "has_temporal",
+    "has_spatial_pair",
+    "pair_gap_mean",
+    "pair_gap_max",
+    "stroke_width_mean",
+    "stroke_width_std",
+    "stroke_height_mean",
+    "stroke_height_std"
+  ],
+  "reference_validation": {
+    "threshold": 0.3,
+    "weight": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 244,
+        "oversplit": 31,
+        "overmerge": 3,
+        "grouping_recall": 0.8808664259927798
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "winner_validation": {
+    "threshold": 0.5,
+    "weight": 6.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.6981818181818182,
+      "exact_group_recall": 0.9580492920818039,
+      "overmerge_rate": 0.12,
+      "oversplit_rate": 0.21454545454545454,
+      "pair_precision": 0.9687249398556536,
+      "pair_recall": 0.9062265566391597,
+      "pair_f1": 0.9364341085271317
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 245,
+        "oversplit": 31,
+        "overmerge": 2,
+        "grouping_recall": 0.8844765342960289
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 50,
+      "grouping_recall": 0.847457627118644,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 16,
+          "grouping_recall": 0.8
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "trials": [
+    {
+      "threshold": 0.3,
+      "weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.955951756685894,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9618138424821002,
+        "pair_recall": 0.9069767441860465,
+        "pair_f1": 0.9335907335907335
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9567383324593602,
+        "overmerge_rate": 0.12727272727272726,
+        "oversplit_rate": 0.22181818181818183,
+        "pair_precision": 0.9662650602409638,
+        "pair_recall": 0.9024756189047262,
+        "pair_f1": 0.9332816136539953
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6909090909090909,
+        "exact_group_recall": 0.9572627163083377,
+        "overmerge_rate": 0.12363636363636364,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9670682730923694,
+        "pair_recall": 0.9032258064516129,
+        "pair_f1": 0.9340574088440652
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9575249082328264,
+        "overmerge_rate": 0.11636363636363636,
+        "oversplit_rate": 0.2290909090909091,
+        "pair_precision": 0.9692307692307692,
+        "pair_recall": 0.8979744936234059,
+        "pair_f1": 0.9322429906542056
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 243,
+          "oversplit": 33,
+          "overmerge": 2,
+          "grouping_recall": 0.8772563176895307
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9575249082328264,
+        "overmerge_rate": 0.11636363636363636,
+        "oversplit_rate": 0.2290909090909091,
+        "pair_precision": 0.9692307692307692,
+        "pair_recall": 0.8979744936234059,
+        "pair_f1": 0.9322429906542056
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 243,
+          "oversplit": 33,
+          "overmerge": 2,
+          "grouping_recall": 0.8772563176895307
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.3,
+      "weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9572627163083377,
+        "overmerge_rate": 0.11636363636363636,
+        "oversplit_rate": 0.23272727272727273,
+        "pair_precision": 0.9691808596918086,
+        "pair_recall": 0.8964741185296324,
+        "pair_f1": 0.93141075604053
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 243,
+          "oversplit": 33,
+          "overmerge": 2,
+          "grouping_recall": 0.8772563176895307
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 49,
+        "grouping_recall": 0.8305084745762712,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 14,
+            "grouping_recall": 0.8235294117647058
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9554273728369166,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9610492845786963,
+        "pair_recall": 0.9069767441860465,
+        "pair_f1": 0.933230412967966
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9562139486103828,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9648562300319489,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9346228239845261
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6909090909090909,
+        "exact_group_recall": 0.957000524383849,
+        "overmerge_rate": 0.12727272727272726,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9664,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9353464963221061
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6981818181818182,
+        "exact_group_recall": 0.9580492920818039,
+        "overmerge_rate": 0.12,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9687249398556536,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9364341085271317
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6981818181818182,
+        "exact_group_recall": 0.9580492920818039,
+        "overmerge_rate": 0.12,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9687249398556536,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9364341085271317
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.5,
+      "weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6909090909090909,
+        "exact_group_recall": 0.9575249082328264,
+        "overmerge_rate": 0.12,
+        "oversplit_rate": 0.22181818181818183,
+        "pair_precision": 0.9686495176848875,
+        "pair_recall": 0.9039759939984996,
+        "pair_f1": 0.9351959642995732
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 32,
+          "overmerge": 2,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 49,
+        "grouping_recall": 0.8305084745762712,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 14,
+            "grouping_recall": 0.8235294117647058
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9543786051389617,
+        "overmerge_rate": 0.14545454545454545,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9594916600476568,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9320987654320987
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9640861931364725,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.934261407579273
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9640861931364725,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.934261407579273
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6909090909090909,
+        "exact_group_recall": 0.9567383324593602,
+        "overmerge_rate": 0.13090909090909092,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9664,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9353464963221061
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6909090909090909,
+        "exact_group_recall": 0.9567383324593602,
+        "overmerge_rate": 0.13090909090909092,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9664,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9353464963221061
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.65,
+      "weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6945454545454546,
+        "exact_group_recall": 0.9575249082328264,
+        "overmerge_rate": 0.12363636363636364,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9679230152365678,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9356589147286822
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 14,
+            "grouping_recall": 0.8235294117647058
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9543786051389617,
+        "overmerge_rate": 0.14545454545454545,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9594916600476568,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9320987654320987
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9551651809124279,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9632881085395052,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9334880123743232
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9551651809124279,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9632881085395052,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9334880123743232
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.8,
+      "weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9543786051389617,
+        "overmerge_rate": 0.14545454545454545,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9594916600476568,
+        "pair_recall": 0.9062265566391597,
+        "pair_f1": 0.9320987654320987
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9551651809124279,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9632881085395052,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9334880123743232
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6836363636363636,
+        "exact_group_recall": 0.9551651809124279,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.9632881085395052,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9334880123743232
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "threshold": 0.9,
+      "weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6872727272727273,
+        "exact_group_recall": 0.9556895647614053,
+        "overmerge_rate": 0.13454545454545455,
+        "oversplit_rate": 0.21454545454545454,
+        "pair_precision": 0.964828137490008,
+        "pair_recall": 0.905476369092273,
+        "pair_f1": 0.9342105263157895
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 245,
+          "oversplit": 31,
+          "overmerge": 2,
+          "grouping_recall": 0.8844765342960289
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    }
+  ],
+  "official_test_reference": {
+    "threshold": 0.3,
+    "weight": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 412,
+        "oversplit": 30,
+        "overmerge": 12,
+        "grouping_recall": 0.9155555555555556
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_winner": {
+    "threshold": 0.5,
+    "weight": 6.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6024590163934426,
+      "exact_group_recall": 0.9396626926432102,
+      "overmerge_rate": 0.20491803278688525,
+      "oversplit_rate": 0.2581967213114754,
+      "pair_precision": 0.9301524840137727,
+      "pair_recall": 0.8957839886309806,
+      "pair_f1": 0.9126447876447876
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 411,
+        "oversplit": 32,
+        "overmerge": 11,
+        "grouping_recall": 0.9133333333333333
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 110,
+      "grouping_recall": 0.8148148148148148,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 26,
+          "grouping_recall": 0.8666666666666667
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 43,
+          "grouping_recall": 0.8775510204081632
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_deltas": {
+    "exact_partition_pp": 0.2049180327868827,
+    "pair_f1_pp": 0.1939074730721302,
+    "x_grouping_pp": -0.22222222222222365,
+    "family_grouping_pp": -1.4814814814814836
+  },
+  "decision": {
+    "adopted": true,
+    "selected_threshold": 0.5,
+    "selected_weight": 6.0
+  },
+  "artifact": "research\\runs\\math_ink_06_boundary_behavior_guard_20260724\\boundary_behavior_guard.joblib",
+  "track": "R_noncommercial_only",
+  "product_validation": false
+}

reports/component_competition_report.json

@@ -0,0 +1,843 @@
+{
+  "experiment": "R-MATH-INK-06-COMPONENT-COMPETITION-GUARD-001",
+  "generated_at": "2026-07-23T18:30:20.711476+00:00",
+  "selection_contract": {
+    "split": "CROHME trainData writer-validation only",
+    "cross_gap_ratio": 0.4,
+    "multistroke_family_boost": 6.0,
+    "maximum_x_regression_pp": 1.0,
+    "maximum_family_regression_pp": 2.0,
+    "maximum_pair_f1_regression_pp": 0.25
+  },
+  "reference_validation": {
+    "component_competition_weight": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 244,
+        "oversplit": 31,
+        "overmerge": 3,
+        "grouping_recall": 0.8808664259927798
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "winner_validation": {
+    "component_competition_weight": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 244,
+        "oversplit": 31,
+        "overmerge": 3,
+        "grouping_recall": 0.8808664259927798
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "trials": [
+    {
+      "component_competition_weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9538542212899843,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.22545454545454546,
+        "pair_precision": 0.9585326953748007,
+        "pair_recall": 0.9017254313578394,
+        "pair_f1": 0.9292616930807887
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6727272727272727,
+        "exact_group_recall": 0.9538542212899843,
+        "overmerge_rate": 0.13090909090909092,
+        "oversplit_rate": 0.23272727272727273,
+        "pair_precision": 0.9599037690457097,
+        "pair_recall": 0.8979744936234059,
+        "pair_f1": 0.9279069767441861
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 242,
+          "oversplit": 33,
+          "overmerge": 3,
+          "grouping_recall": 0.8736462093862816
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 3.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6436363636363637,
+        "exact_group_recall": 0.9509701101206083,
+        "overmerge_rate": 0.13090909090909092,
+        "oversplit_rate": 0.26545454545454544,
+        "pair_precision": 0.9586038961038961,
+        "pair_recall": 0.8859714928732183,
+        "pair_f1": 0.9208576998050683
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 240,
+          "oversplit": 35,
+          "overmerge": 3,
+          "grouping_recall": 0.8664259927797834
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.64,
+        "exact_group_recall": 0.9507079181961196,
+        "overmerge_rate": 0.12363636363636364,
+        "oversplit_rate": 0.28,
+        "pair_precision": 0.9607843137254902,
+        "pair_recall": 0.8822205551387847,
+        "pair_f1": 0.9198279233476732
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 240,
+          "oversplit": 35,
+          "overmerge": 3,
+          "grouping_recall": 0.8664259927797834
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6290909090909091,
+        "exact_group_recall": 0.9499213424226534,
+        "overmerge_rate": 0.11636363636363636,
+        "oversplit_rate": 0.29818181818181816,
+        "pair_precision": 0.9628406275805119,
+        "pair_recall": 0.8747186796699175,
+        "pair_f1": 0.9166666666666666
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 239,
+          "oversplit": 36,
+          "overmerge": 3,
+          "grouping_recall": 0.8628158844765343
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6145454545454545,
+        "exact_group_recall": 0.948348190875721,
+        "overmerge_rate": 0.11272727272727273,
+        "oversplit_rate": 0.31636363636363635,
+        "pair_precision": 0.9633943427620633,
+        "pair_recall": 0.8687171792948237,
+        "pair_f1": 0.9136094674556214
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 237,
+          "oversplit": 38,
+          "overmerge": 3,
+          "grouping_recall": 0.855595667870036
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 50,
+        "grouping_recall": 0.847457627118644,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "component_competition_weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.5527272727272727,
+        "exact_group_recall": 0.9396958573675931,
+        "overmerge_rate": 0.11272727272727273,
+        "oversplit_rate": 0.3927272727272727,
+        "pair_precision": 0.9621993127147767,
+        "pair_recall": 0.8402100525131283,
+        "pair_f1": 0.8970764917901483
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 229,
+          "oversplit": 46,
+          "overmerge": 3,
+          "grouping_recall": 0.8267148014440433
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 48,
+        "grouping_recall": 0.8135593220338984,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 14,
+            "grouping_recall": 0.8235294117647058
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 15,
+            "grouping_recall": 0.75
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    }
+  ],
+  "official_test_reference": {
+    "component_competition_weight": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 412,
+        "oversplit": 30,
+        "overmerge": 12,
+        "grouping_recall": 0.9155555555555556
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_winner": {
+    "component_competition_weight": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 412,
+        "oversplit": 30,
+        "overmerge": 12,
+        "grouping_recall": 0.9155555555555556
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_deltas": {
+    "exact_partition_pp": 0.0,
+    "pair_f1_pp": 0.0,
+    "x_grouping_pp": 0.0,
+    "family_grouping_pp": 0.0
+  },
+  "decision": {
+    "adopted": false,
+    "selected_component_competition_weight": 0.0,
+    "reason": "official adoption gate failed"
+  },
+  "track": "R_noncommercial_only",
+  "product_validation": false
+}

reports/local_baseline_guard_report.json

@@ -0,0 +1,915 @@
+{
+  "experiment": "R-MATH-INK-06-LOCAL-BASELINE-GUARD-001",
+  "generated_at": "2026-07-23T18:36:25.447949+00:00",
+  "selection_contract": {
+    "split": "CROHME trainData writer-validation only",
+    "cross_gap_ratio": 0.4,
+    "multistroke_family_boost": 6.0,
+    "maximum_x_regression_pp": 1.0,
+    "maximum_family_regression_pp": 2.0,
+    "maximum_pair_f1_regression_pp": 0.25
+  },
+  "signal_coverage": {
+    "validation_candidates": 3293,
+    "official_test_candidates": 5061
+  },
+  "reference_validation": {
+    "local_baseline_weight": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 244,
+        "oversplit": 31,
+        "overmerge": 3,
+        "grouping_recall": 0.8808664259927798
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "winner_validation": {
+    "local_baseline_weight": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 277,
+        "matched": 244,
+        "oversplit": 31,
+        "overmerge": 3,
+        "grouping_recall": 0.8808664259927798
+      },
+      "X": {
+        "samples": 7,
+        "matched": 7,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      },
+      "\\times": {
+        "samples": 44,
+        "matched": 44,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "trials": [
+    {
+      "local_baseline_weight": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 0.5,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 3.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 8.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "local_baseline_weight": 12.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "behavior_targets": {
+        "x": {
+          "samples": 277,
+          "matched": 244,
+          "oversplit": 31,
+          "overmerge": 3,
+          "grouping_recall": 0.8808664259927798
+        },
+        "X": {
+          "samples": 7,
+          "matched": 7,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        },
+        "\\times": {
+          "samples": 44,
+          "matched": 44,
+          "oversplit": 0,
+          "overmerge": 0,
+          "grouping_recall": 1.0
+        }
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    }
+  ],
+  "official_test_reference": {
+    "local_baseline_weight": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 412,
+        "oversplit": 30,
+        "overmerge": 12,
+        "grouping_recall": 0.9155555555555556
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_winner": {
+    "local_baseline_weight": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "behavior_targets": {
+      "x": {
+        "samples": 450,
+        "matched": 412,
+        "oversplit": 30,
+        "overmerge": 12,
+        "grouping_recall": 0.9155555555555556
+      },
+      "X": {
+        "samples": 14,
+        "matched": 12,
+        "oversplit": 2,
+        "overmerge": 1,
+        "grouping_recall": 0.8571428571428571
+      },
+      "\\times": {
+        "samples": 36,
+        "matched": 36,
+        "oversplit": 0,
+        "overmerge": 0,
+        "grouping_recall": 1.0
+      }
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_deltas": {
+    "exact_partition_pp": 0.0,
+    "pair_f1_pp": 0.0,
+    "x_grouping_pp": 0.0,
+    "family_grouping_pp": 0.0
+  },
+  "decision": {
+    "adopted": false,
+    "selected_local_baseline_weight": 0.0,
+    "reason": "official adoption gate failed"
+  },
+  "track": "R_noncommercial_only",
+  "product_validation": false
+}

reports/multistroke_family_guard_report.json

@@ -0,0 +1,565 @@
+{
+  "experiment": "R-MATH-INK-06-MULTISTROKE-FAMILY-GUARD-001",
+  "generated_at": "2026-07-23T18:17:32.159942+00:00",
+  "selection_contract": {
+    "split": "CROHME trainData writer-validation only",
+    "cross_gap_ratio": 0.4,
+    "symbol_weight": 4.0,
+    "maximum_exact_regression_pp": 0.5,
+    "maximum_pair_f1_regression_pp": 0.25
+  },
+  "reference_validation": {
+    "multistroke_family_boost": 0.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.6581818181818182,
+      "exact_group_recall": 0.9480859989512324,
+      "overmerge_rate": 0.14181818181818182,
+      "oversplit_rate": 0.24727272727272728,
+      "pair_precision": 0.9605587510271159,
+      "pair_recall": 0.8769692423105776,
+      "pair_f1": 0.9168627450980391
+    },
+    "families": {
+      "total": 59,
+      "matched": 28,
+      "grouping_recall": 0.4745762711864407,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 2,
+          "grouping_recall": 0.18181818181818182
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 10,
+          "grouping_recall": 0.5882352941176471
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 14,
+          "grouping_recall": 0.7
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 1,
+          "grouping_recall": 0.5
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 1,
+          "grouping_recall": 0.1111111111111111
+        }
+      }
+    }
+  },
+  "winner_validation": {
+    "multistroke_family_boost": 6.0,
+    "global": {
+      "formulas": 275,
+      "exact_partition": 0.68,
+      "exact_group_recall": 0.9528054535920294,
+      "overmerge_rate": 0.14909090909090908,
+      "oversplit_rate": 0.21818181818181817,
+      "pair_precision": 0.9563838223632039,
+      "pair_recall": 0.9047261815453863,
+      "pair_f1": 0.9298380878951427
+    },
+    "families": {
+      "total": 59,
+      "matched": 51,
+      "grouping_recall": 0.864406779661017,
+      "by_label": {
+        "\\sum": {
+          "samples": 11,
+          "matched": 8,
+          "grouping_recall": 0.7272727272727273
+        },
+        "\\pi": {
+          "samples": 17,
+          "matched": 15,
+          "grouping_recall": 0.8823529411764706
+        },
+        "\\rightarrow": {
+          "samples": 20,
+          "matched": 17,
+          "grouping_recall": 0.85
+        },
+        "\\neq": {
+          "samples": 2,
+          "matched": 2,
+          "grouping_recall": 1.0
+        },
+        "\\pm": {
+          "samples": 9,
+          "matched": 9,
+          "grouping_recall": 1.0
+        }
+      }
+    }
+  },
+  "trials": [
+    {
+      "multistroke_family_boost": 0.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6581818181818182,
+        "exact_group_recall": 0.9480859989512324,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.24727272727272728,
+        "pair_precision": 0.9605587510271159,
+        "pair_recall": 0.8769692423105776,
+        "pair_f1": 0.9168627450980391
+      },
+      "families": {
+        "total": 59,
+        "matched": 28,
+        "grouping_recall": 0.4745762711864407,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 2,
+            "grouping_recall": 0.18181818181818182
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 10,
+            "grouping_recall": 0.5882352941176471
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 14,
+            "grouping_recall": 0.7
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 1,
+            "grouping_recall": 0.5
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 1,
+            "grouping_recall": 0.1111111111111111
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 0.5,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6654545454545454,
+        "exact_group_recall": 0.9488725747246984,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.23636363636363636,
+        "pair_precision": 0.9607522485690924,
+        "pair_recall": 0.881470367591898,
+        "pair_f1": 0.9194053208137716
+      },
+      "families": {
+        "total": 59,
+        "matched": 31,
+        "grouping_recall": 0.5254237288135594,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 2,
+            "grouping_recall": 0.18181818181818182
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 11,
+            "grouping_recall": 0.6470588235294118
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 14,
+            "grouping_recall": 0.7
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 1,
+            "grouping_recall": 0.5
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 3,
+            "grouping_recall": 0.3333333333333333
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 1.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6654545454545454,
+        "exact_group_recall": 0.9499213424226534,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.23272727272727273,
+        "pair_precision": 0.9609756097560975,
+        "pair_recall": 0.886721680420105,
+        "pair_f1": 0.9223566133437378
+      },
+      "families": {
+        "total": 59,
+        "matched": 35,
+        "grouping_recall": 0.5932203389830508,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 3,
+            "grouping_recall": 0.2727272727272727
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 11,
+            "grouping_recall": 0.6470588235294118
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 14,
+            "grouping_recall": 0.7
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 5,
+            "grouping_recall": 0.5555555555555556
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 1.5,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6690909090909091,
+        "exact_group_recall": 0.951232302045097,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.2290909090909091,
+        "pair_precision": 0.9627831715210357,
+        "pair_recall": 0.8927231807951987,
+        "pair_f1": 0.9264305177111717
+      },
+      "families": {
+        "total": 59,
+        "matched": 39,
+        "grouping_recall": 0.6610169491525424,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 3,
+            "grouping_recall": 0.2727272727272727
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 12,
+            "grouping_recall": 0.7058823529411765
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 14,
+            "grouping_recall": 0.7
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 8,
+            "grouping_recall": 0.8888888888888888
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 2.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6727272727272727,
+        "exact_group_recall": 0.9520188778185632,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.22545454545454546,
+        "pair_precision": 0.9629032258064516,
+        "pair_recall": 0.8957239309827457,
+        "pair_f1": 0.9280994947532063
+      },
+      "families": {
+        "total": 59,
+        "matched": 42,
+        "grouping_recall": 0.711864406779661,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 5,
+            "grouping_recall": 0.45454545454545453
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 12,
+            "grouping_recall": 0.7058823529411765
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 14,
+            "grouping_recall": 0.7
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 3.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6763636363636364,
+        "exact_group_recall": 0.9530676455165181,
+        "overmerge_rate": 0.13818181818181818,
+        "oversplit_rate": 0.22181818181818183,
+        "pair_precision": 0.9630522088353414,
+        "pair_recall": 0.8994748687171793,
+        "pair_f1": 0.930178432893716
+      },
+      "families": {
+        "total": 59,
+        "matched": 45,
+        "grouping_recall": 0.7627118644067796,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 5,
+            "grouping_recall": 0.45454545454545453
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 13,
+            "grouping_recall": 0.7647058823529411
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 4.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.6763636363636364,
+        "exact_group_recall": 0.9533298374410069,
+        "overmerge_rate": 0.14181818181818182,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9616613418530351,
+        "pair_recall": 0.9032258064516129,
+        "pair_f1": 0.9315280464216633
+      },
+      "families": {
+        "total": 59,
+        "matched": 48,
+        "grouping_recall": 0.8135593220338984,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 6,
+            "grouping_recall": 0.5454545454545454
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 16,
+            "grouping_recall": 0.8
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    },
+    {
+      "multistroke_family_boost": 6.0,
+      "global": {
+        "formulas": 275,
+        "exact_partition": 0.68,
+        "exact_group_recall": 0.9528054535920294,
+        "overmerge_rate": 0.14909090909090908,
+        "oversplit_rate": 0.21818181818181817,
+        "pair_precision": 0.9563838223632039,
+        "pair_recall": 0.9047261815453863,
+        "pair_f1": 0.9298380878951427
+      },
+      "families": {
+        "total": 59,
+        "matched": 51,
+        "grouping_recall": 0.864406779661017,
+        "by_label": {
+          "\\sum": {
+            "samples": 11,
+            "matched": 8,
+            "grouping_recall": 0.7272727272727273
+          },
+          "\\pi": {
+            "samples": 17,
+            "matched": 15,
+            "grouping_recall": 0.8823529411764706
+          },
+          "\\rightarrow": {
+            "samples": 20,
+            "matched": 17,
+            "grouping_recall": 0.85
+          },
+          "\\neq": {
+            "samples": 2,
+            "matched": 2,
+            "grouping_recall": 1.0
+          },
+          "\\pm": {
+            "samples": 9,
+            "matched": 9,
+            "grouping_recall": 1.0
+          }
+        }
+      }
+    }
+  ],
+  "official_test_reference": {
+    "multistroke_family_boost": 0.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.5450819672131147,
+      "exact_group_recall": 0.9310846176214016,
+      "overmerge_rate": 0.21106557377049182,
+      "oversplit_rate": 0.32786885245901637,
+      "pair_precision": 0.9236289082521784,
+      "pair_recall": 0.8536238749407864,
+      "pair_f1": 0.8872476612506155
+    },
+    "families": {
+      "total": 135,
+      "matched": 61,
+      "grouping_recall": 0.45185185185185184,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 8,
+          "grouping_recall": 0.25806451612903225
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 12,
+          "grouping_recall": 0.4
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 35,
+          "grouping_recall": 0.7142857142857143
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 3,
+          "grouping_recall": 0.23076923076923078
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 3,
+          "grouping_recall": 0.25
+        }
+      }
+    }
+  },
+  "official_test_winner": {
+    "multistroke_family_boost": 6.0,
+    "global": {
+      "formulas": 488,
+      "exact_partition": 0.6004098360655737,
+      "exact_group_recall": 0.9370456528060482,
+      "overmerge_rate": 0.21721311475409835,
+      "oversplit_rate": 0.2520491803278688,
+      "pair_precision": 0.9231143552311436,
+      "pair_recall": 0.8986262434864993,
+      "pair_f1": 0.9107057129140663
+    },
+    "families": {
+      "total": 135,
+      "matched": 112,
+      "grouping_recall": 0.8296296296296296,
+      "by_label": {
+        "\\sum": {
+          "samples": 31,
+          "matched": 22,
+          "grouping_recall": 0.7096774193548387
+        },
+        "\\pi": {
+          "samples": 30,
+          "matched": 27,
+          "grouping_recall": 0.9
+        },
+        "\\rightarrow": {
+          "samples": 49,
+          "matched": 44,
+          "grouping_recall": 0.8979591836734694
+        },
+        "\\neq": {
+          "samples": 13,
+          "matched": 10,
+          "grouping_recall": 0.7692307692307693
+        },
+        "\\pm": {
+          "samples": 12,
+          "matched": 9,
+          "grouping_recall": 0.75
+        }
+      }
+    }
+  },
+  "official_test_deltas": {
+    "family_grouping_pp": 37.77777777777778,
+    "exact_partition_pp": 5.5327868852458995,
+    "pair_f1_pp": 2.345805166345083
+  },
+  "decision": {
+    "adopted": true,
+    "selected_multistroke_family_boost": 6.0,
+    "reason": "family grouping improves within global partition guards"
+  },
+  "track": "R_noncommercial_only",
+  "product_validation": false
+}

scripts/audit_math_ink_06_local_baseline_overmerge.py

@@ -0,0 +1,260 @@
+"""최종 selector의 overmerge를 이웃 truth·OCR family·Tray penalty 기준으로 분해한다."""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+for path in (PROJECT_ROOT, SOURCE_ROOT):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from math_grid_drawer.research.cross_visual import CrossVisualModel
+from math_grid_drawer.research.equality_visual import EqualityVisualModel
+from math_grid_drawer.research.segmentation_lattice import (
+    LATTICE_FEATURE_NAMES,
+    select_lattice_partition,
+)
+from scripts.crohme_lattice_common import load_cached_split, writer_fit_validation
+from scripts.evaluate_crohme_gt_free_grouping import _truth_partition
+from scripts.evaluate_crohme_lattice_ocr_fusion import _fit_geometry
+from scripts.evaluate_crohme_structure_presence import _truth_structures
+from scripts.evaluate_crohme_tray_joint_selector import _prepared_signals, _weighted
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: 공식 test·cache·full selector head. 작동 원리: 최종 overmerge 감사 CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Audit Math Ink 0.6 local-baseline overmerge")
+    parser.add_argument(
+        "--train-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/trainData",
+    )
+    parser.add_argument(
+        "--test-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/testDataGT",
+    )
+    parser.add_argument(
+        "--cache-dir", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_lattice_ocr_cache_v2_20260722",
+    )
+    parser.add_argument(
+        "--bundle", type=Path,
+        default=Path(r"research\runs\aiflow_ocr_05_dual_trajectory_3seed_20260720\bundle.manifest.json"),
+    )
+    parser.add_argument(
+        "--cross-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_cross_visual_loop3_polyline_20260722/cross_visual.json",
+    )
+    parser.add_argument(
+        "--equality-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_equality_visual_loop1_20260722/equality_visual.json",
+    )
+    parser.add_argument("--profile", default="median_height_32")
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def main() -> None:
+    """필요 변수: gap40·family6 보호 selector. 작동 원리: overmerge candidate와 침범 truth를 1:1 연결한다."""
+
+    args = _parse_args()
+    fit, _validation = writer_fit_validation(args.train_root, args.profile)
+    geometry_model = _fit_geometry(fit)
+    equality_model = EqualityVisualModel.load(args.equality_model)
+    cross_model = CrossVisualModel.load(args.cross_model)
+    samples, cached = load_cached_split(
+        args.test_root,
+        args.cache_dir,
+        split="official_test",
+        profile=args.profile,
+        bundle=args.bundle,
+        version=2,
+    )
+    prepared = _prepared_signals(
+        samples,
+        cached,
+        geometry_model,
+        equality_model=equality_model,
+        cross_model=cross_model,
+        cross_gap_ratio=0.40,
+        multistroke_family_boost=6.0,
+    )
+    weighted = _weighted(
+        prepared,
+        tray_weight=4.0,
+        symbol_weight=4.0,
+        fraction_weight=8.0,
+        infix_weight=8.0,
+    )
+    path_by_id = {path.stem: path for path in sorted(args.test_root.rglob("*.inkml"))}
+    truth_labels: Counter[str] = Counter()
+    candidate_labels: Counter[str] = Counter()
+    candidate_families: Counter[str] = Counter()
+    invaded_pairs: Counter[str] = Counter()
+    structure_counts: Counter[str] = Counter()
+    fraction_penalty_counts: Counter[str] = Counter()
+    local_penalty_counts: Counter[str] = Counter()
+    rows: list[dict[str, Any]] = []
+    unique_bad_candidates: dict[tuple[str, tuple[int, ...]], dict[str, Any]] = {}
+    correct_multistroke_rows: list[dict[str, Any]] = []
+    for sample, row in zip(samples, weighted, strict=True):
+        truth_groups, labels = _truth_partition(sample, "aiflow_geometry")
+        label_by_group = dict(zip(truth_groups, (str(value) for value in labels), strict=True))
+        predicted = set(select_lattice_partition(
+            row["candidates"], row["logits"], row["stroke_count"], group_bias=-2.0,
+        ))
+        candidate_index = {
+            frozenset(int(value) for value in candidate["source_indices"]): index
+            for index, candidate in enumerate(row["candidates"])
+        }
+        families = row.get("ocr_families") or [""] * len(row["candidates"])
+        structures = _truth_structures(path_by_id[sample["sample_id"]])
+        for truth, truth_label in label_by_group.items():
+            if truth in predicted:
+                if len(truth) > 1:
+                    index = candidate_index[truth]
+                    correct_multistroke_rows.append({
+                        "sample_id": sample["sample_id"],
+                        "truth_label": truth_label,
+                        "truth_group": sorted(truth),
+                        "candidate_label": str(row["ocr_labels"][index]),
+                        "candidate_family": str(families[index]),
+                        "features": {
+                            "ocr_top1": float(
+                                row["features"][index][len(LATTICE_FEATURE_NAMES)]
+                            ),
+                            "merge_top1_gain": float(
+                                row["features"][index][len(LATTICE_FEATURE_NAMES) + 6]
+                            ),
+                            "merge_entropy_gain": float(
+                                row["features"][index][len(LATTICE_FEATURE_NAMES) + 7]
+                            ),
+                            "pair_gap_max": float(row["features"][index][12]),
+                        },
+                    })
+                continue
+            overmerged = [
+                group for group in predicted
+                if group & truth and bool(group - truth)
+            ]
+            for group in overmerged:
+                index = candidate_index[group]
+                candidate_label = str(row["ocr_labels"][index])
+                candidate_family = str(families[index])
+                invaded = [
+                    other_label
+                    for other_group, other_label in label_by_group.items()
+                    if other_group != truth and other_group & group
+                ]
+                truth_labels[truth_label] += 1
+                candidate_labels[candidate_label] += 1
+                candidate_families[candidate_family] += 1
+                for other_label in invaded:
+                    invaded_pairs[f"{truth_label} -> {other_label}"] += 1
+                for structure in structures or {"plain"}:
+                    structure_counts[structure] += 1
+                fraction_penalty = float(row["fraction_penalty"][index])
+                fraction_penalty_counts[
+                    "nonzero" if fraction_penalty > 0.0 else "zero"
+                ] += 1
+                raw_local_penalty = float(row["raw_local_baseline_penalty"][index])
+                local_penalty = float(row["local_baseline_penalty"][index])
+                if local_penalty > 0.0:
+                    local_penalty_counts["effective_nonzero"] += 1
+                elif raw_local_penalty > 0.0:
+                    local_penalty_counts["protected_by_positive_signal"] += 1
+                else:
+                    local_penalty_counts["not_detected"] += 1
+                covered_truth = [
+                    other_group for other_group in truth_groups if other_group & group
+                ]
+                replacement_scores = [
+                    float(row["logits"][candidate_index[other_group]])
+                    for other_group in covered_truth if other_group in candidate_index
+                ]
+                oracle_margin = (
+                    float(row["logits"][index]) - sum(replacement_scores)
+                    + 2.0 * (len(replacement_scores) - 1)
+                    if len(replacement_scores) == len(covered_truth) else None
+                )
+                detail = {
+                    "sample_id": sample["sample_id"],
+                    "structures": sorted(structures),
+                    "truth_label": truth_label,
+                    "truth_group": sorted(truth),
+                    "candidate_group": sorted(group),
+                    "candidate_label": candidate_label,
+                    "candidate_family": candidate_family,
+                    "invaded_truth_labels": invaded,
+                    "fraction_penalty": fraction_penalty,
+                    "raw_local_baseline_penalty": raw_local_penalty,
+                    "local_baseline_penalty": local_penalty,
+                    "oracle_truth_partition_margin": oracle_margin,
+                    "tray_signal": float(row["tray_signal"][index]),
+                    "symbol_signal": float(row["symbol_signal"][index]),
+                    "infix_signal": float(row["infix_signal"][index]),
+                    "score": float(row["logits"][index]),
+                    "geometry": {
+                        "width_ref": float(row["features"][index][2]),
+                        "height_ref": float(row["features"][index][3]),
+                        "aspect_log": float(row["features"][index][4]),
+                        "temporal_span": float(row["features"][index][5]),
+                        "pair_gap_max": float(row["features"][index][12]),
+                    },
+                    "ocr_features": {
+                        "ocr_top1": float(
+                            row["features"][index][len(LATTICE_FEATURE_NAMES)]
+                        ),
+                        "merge_top1_gain": float(
+                            row["features"][index][len(LATTICE_FEATURE_NAMES) + 6]
+                        ),
+                        "merge_entropy_gain": float(
+                            row["features"][index][len(LATTICE_FEATURE_NAMES) + 7]
+                        ),
+                    },
+                }
+                rows.append(detail)
+                unique_bad_candidates[(sample["sample_id"], tuple(sorted(group)))] = detail
+    report = {
+        "experiment": "R-MATH-INK-06-LOCAL-BASELINE-OVERMERGE-AUDIT-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "configuration": {
+            "cross_gap_ratio": 0.40,
+            "multistroke_family_boost": 6.0,
+        },
+        "overmerge_events": len(rows),
+        "truth_labels": truth_labels.most_common(),
+        "candidate_labels": candidate_labels.most_common(),
+        "candidate_families": candidate_families.most_common(),
+        "invaded_pairs": invaded_pairs.most_common(),
+        "structures": structure_counts.most_common(),
+        "fraction_penalty": dict(fraction_penalty_counts),
+        "local_baseline_penalty": dict(local_penalty_counts),
+        "unique_bad_candidate_count": len(unique_bad_candidates),
+        "unique_bad_candidates": list(unique_bad_candidates.values()),
+        "correct_multistroke_rows": correct_multistroke_rows,
+        "rows": rows,
+        "track": "R_noncommercial_only",
+        "product_validation": False,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps({
+        key: value for key, value in report.items()
+        if key not in {"rows", "unique_bad_candidates", "correct_multistroke_rows"}
+    }, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/evaluate_crohme_tray_joint_selector.py

@@ -0,0 +1,203 @@
+"""Exact OCR anchor와 수학 Tray 계약을 lattice positive/negative score로 공동 검증한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+
+import numpy as np
+
+from math_grid_drawer.research.cross_visual import CrossVisualModel
+from math_grid_drawer.research.equality_visual import EqualityVisualModel
+from math_grid_drawer.research.math_tray import fraction_tray_boundary_penalties
+from math_grid_drawer.research.segmentation_lattice import select_lattice_partition
+from math_grid_drawer.research.tray_joint import (
+    TrayJointWeights,
+    adjusted_logits,
+    candidate_signals,
+    component_competition_penalties,
+    local_baseline_boundary_penalties,
+)
+from scripts.crohme_lattice_common import load_cache_for_samples, load_cached_split, writer_fit_validation
+from scripts.evaluate_crohme_lattice_ocr_fusion import _fit_geometry, _score
+from scripts.train_crohme_segmentation_lattice_joint_selector import _metrics
+
+
+def _prepared_signals(
+    samples: list[dict], cached: list[dict], model, *, strict_equality: bool = False,
+    equality_model: EqualityVisualModel | None = None, cross_model: CrossVisualModel | None = None,
+    cross_gap_ratio: float = 0.40,
+    multistroke_family_boost: float = 6.0,
+) -> list[dict]:
+    """필요 변수: 원본·v2 cache·geometry model·cross gap. 작동 원리: base fusion과 구조 signal을 한 번 계산한다."""
+
+    output = []
+    for sample, scored in zip(samples, _score(cached, model, ocr_weight=0.5), strict=True):
+        partition = select_lattice_partition(scored["candidates"], scored["logits"], scored["stroke_count"], group_bias=-2.0)
+        tray_signal, symbol_signal, infix_signal = candidate_signals(
+            sample["profiled_strokes"], scored["candidates"], scored["ocr_labels"],
+            scored["features"], partition, ocr_families=scored.get("ocr_families"),
+            strict_equality=strict_equality, equality_model=equality_model,
+            cross_model=cross_model, cross_gap_ratio=cross_gap_ratio,
+            multistroke_family_boost=multistroke_family_boost,
+        )
+        fraction_penalty = fraction_tray_boundary_penalties(scored["candidates"], sample["profiled_strokes"])
+        competition_penalty = component_competition_penalties(
+            scored["candidates"], scored["features"], mode="joint",
+        )
+        raw_local_baseline_penalty = local_baseline_boundary_penalties(
+            sample["profiled_strokes"], scored["candidates"], scored["ocr_labels"],
+            scored["features"], partition, ocr_families=scored.get("ocr_families"),
+        )
+        local_baseline_penalty = raw_local_baseline_penalty.copy()
+        # 신뢰할 수 있는 완성 다획 기호는 구조 경계와 겹쳐도 기존 positive evidence를 우선한다.
+        protected = (tray_signal > 0.0) | (symbol_signal > 0.0) | (infix_signal > 0.0)
+        local_baseline_penalty[protected] = 0.0
+        output.append({
+            **scored, "tray_signal": tray_signal, "symbol_signal": symbol_signal,
+            "infix_signal": infix_signal, "fraction_penalty": fraction_penalty,
+            "competition_penalty": competition_penalty,
+            "raw_local_baseline_penalty": raw_local_baseline_penalty,
+            "local_baseline_penalty": local_baseline_penalty,
+        })
+    return output
+
+
+def _weighted(
+    rows: list[dict], *, tray_weight: float, symbol_weight: float,
+    fraction_weight: float, infix_weight: float = 0.0, competition_weight: float = 0.0,
+    local_baseline_weight: float = 0.0,
+) -> list[dict]:
+    """필요 변수: 사전 계산 signal·가중치. 작동 원리: positive 구조와 세 negative guard를 결합한다."""
+
+    weights = TrayJointWeights(
+        tray=tray_weight, symbol=symbol_weight, fraction=fraction_weight,
+        infix=infix_weight, competition=competition_weight,
+        local_baseline=local_baseline_weight,
+    )
+    return [{**row, "logits": adjusted_logits(
+        row["logits"], row["tray_signal"], row["symbol_signal"], row["fraction_penalty"], weights,
+        row["infix_signal"], row["competition_penalty"], row["local_baseline_penalty"],
+    )} for row in rows]
+
+
+def main() -> None:
+    """필요 변수: CROHME train/test·v2 cache. 작동 원리: writer-validation에서 joint 가중치를 고정하고 official test에 한 번 적용한다."""
+
+    parser = argparse.ArgumentParser(description="Evaluate CROHME Tray joint selector")
+    parser.add_argument("--train-root", type=Path, required=True)
+    parser.add_argument("--test-root", type=Path, required=True)
+    parser.add_argument("--cache-dir", type=Path, required=True)
+    parser.add_argument("--bundle", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--profile", default="median_height_32")
+    parser.add_argument("--equality-model", type=Path, help="선택적 equality visual JSON head")
+    parser.add_argument("--cross-model", type=Path, help="선택적 cross visual JSON head")
+    parser.add_argument("--cross-gap-ratio", type=float, default=0.40, help="cross head 사전 bbox gap/수식 높이 비율")
+    parser.add_argument("--multistroke-family-boost", type=float, default=6.0, help="OCR family 호환 다획 후보의 추가 symbol signal")
+    parser.add_argument("--fixed-selected", action="store_true", help="기존 validation 선택값 4/4/8/-2를 재검증하고 sweep을 생략")
+    parser.add_argument("--sweep-infix", action="store_true", help="기존 가중치는 고정하고 x/= 구조 가중치만 validation 선택")
+    equality_mode = parser.add_mutually_exclusive_group()
+    equality_mode.add_argument("--strict-equality", dest="strict_equality", action="store_true", help="= 후보에 부분식 parser 계약 적용")
+    equality_mode.add_argument("--relaxed-equality", dest="strict_equality", action="store_false", help="=를 수식 완결성과 독립된 shape로 인식")
+    parser.set_defaults(strict_equality=False)
+    args = parser.parse_args()
+    equality_model = EqualityVisualModel.load(args.equality_model) if args.equality_model else None
+    cross_model = CrossVisualModel.load(args.cross_model) if args.cross_model else None
+    fit, validation = writer_fit_validation(args.train_root, args.profile)
+    model = _fit_geometry(fit)
+    validation_cache = load_cache_for_samples(
+        validation, args.cache_dir, split="validation", profile=args.profile, bundle=args.bundle, version=2,
+    )
+    validation_rows = _prepared_signals(
+        validation, validation_cache, model, strict_equality=args.strict_equality,
+        equality_model=equality_model,
+        cross_model=cross_model, cross_gap_ratio=args.cross_gap_ratio,
+        multistroke_family_boost=args.multistroke_family_boost,
+    )
+    if args.sweep_infix:
+        fixed = TrayJointWeights()
+        trials = []
+        for infix_weight in (0.0, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0, 12.0, 16.0):
+            trials.append({
+                "tray_weight": fixed.tray, "symbol_weight": fixed.symbol,
+                "fraction_weight": fixed.fraction, "infix_weight": infix_weight,
+                "group_bias": fixed.group_bias,
+                "metrics": _metrics(_weighted(
+                    validation_rows, tray_weight=fixed.tray, symbol_weight=fixed.symbol,
+                    fraction_weight=fixed.fraction, infix_weight=infix_weight,
+                ), fixed.group_bias),
+            })
+        winner = max(trials, key=lambda row: (row["metrics"]["exact_partition"], row["metrics"]["pair_f1"]))
+    elif args.fixed_selected:
+        fixed = TrayJointWeights()
+        winner = {
+            "tray_weight": fixed.tray, "symbol_weight": fixed.symbol,
+            "fraction_weight": fixed.fraction, "infix_weight": fixed.infix, "group_bias": fixed.group_bias,
+            "metrics": _metrics(_weighted(
+                validation_rows, tray_weight=fixed.tray, symbol_weight=fixed.symbol,
+                fraction_weight=fixed.fraction, infix_weight=fixed.infix,
+            ), fixed.group_bias),
+        }
+    else:
+        trials = []
+        for tray_weight in (0.0, 0.5, 1.0, 2.0, 4.0, 8.0):
+            for symbol_weight in (0.0, 0.5, 1.0, 2.0, 4.0):
+                for fraction_weight in (0.0, 8.0):
+                    weighted = _weighted(
+                        validation_rows, tray_weight=tray_weight,
+                        symbol_weight=symbol_weight, fraction_weight=fraction_weight,
+                    )
+                    for bias in (-2.5, -2.0, -1.5, -1.0):
+                        trials.append({
+                            "tray_weight": tray_weight, "symbol_weight": symbol_weight,
+                            "fraction_weight": fraction_weight, "group_bias": bias,
+                            "infix_weight": 0.0,
+                            "metrics": _metrics(weighted, bias),
+                        })
+        winner = max(trials, key=lambda row: (row["metrics"]["exact_partition"], row["metrics"]["pair_f1"]))
+    test, test_cache = load_cached_split(
+        args.test_root, args.cache_dir, split="official_test", profile=args.profile,
+        bundle=args.bundle, version=2,
+    )
+    test_rows = _prepared_signals(
+        test, test_cache, model, strict_equality=args.strict_equality,
+        equality_model=equality_model,
+        cross_model=cross_model, cross_gap_ratio=args.cross_gap_ratio,
+        multistroke_family_boost=args.multistroke_family_boost,
+    )
+    weighted_test = _weighted(
+        test_rows, tray_weight=float(winner["tray_weight"]), symbol_weight=float(winner["symbol_weight"]),
+        fraction_weight=float(winner["fraction_weight"]),
+        infix_weight=float(winner.get("infix_weight", 0.0)),
+    )
+    report = {
+        "experiment": "R-CROHME-TRAY-JOINT-SELECTOR-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(), "track": "R_noncommercial_only",
+        "selection_mode": "infix_validation_sweep" if args.sweep_infix else ("fixed_refactor_verification" if args.fixed_selected else "writer_validation_sweep"),
+        "strict_equality": args.strict_equality,
+        "equality_model": str(args.equality_model) if args.equality_model else None,
+        "cross_model": str(args.cross_model) if args.cross_model else None,
+        "selected": winner, "official_test": _metrics(weighted_test, float(winner["group_bias"])),
+        "validation_trials": trials if args.sweep_infix else None,
+        "signal_coverage": {
+            "validation_tray_candidates": int(sum(np.count_nonzero(row["tray_signal"]) for row in validation_rows)),
+            "validation_symbol_candidates": int(sum(np.count_nonzero(row["symbol_signal"]) for row in validation_rows)),
+            "test_tray_candidates": int(sum(np.count_nonzero(row["tray_signal"]) for row in test_rows)),
+            "test_symbol_candidates": int(sum(np.count_nonzero(row["symbol_signal"]) for row in test_rows)),
+            "validation_infix_candidates": int(sum(np.count_nonzero(row["infix_signal"]) for row in validation_rows)),
+            "test_infix_candidates": int(sum(np.count_nonzero(row["infix_signal"]) for row in test_rows)),
+        },
+        "reference_test": {"exact_partition": 0.4836065574, "pair_f1": 0.86628},
+        "product_validation": False,
+        "interpretation_limit": "HWRT expanded top-label + CROHME R-track Tray joint selector",
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/sweep_math_ink_06_component_competition_guard.py

@@ -0,0 +1,236 @@
+"""최종 selector에서 구성획보다 약한 merge 후보의 must-not-link weight를 validation 선택한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+for path in (PROJECT_ROOT, SOURCE_ROOT):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from math_grid_drawer.research.cross_visual import CrossVisualModel
+from math_grid_drawer.research.equality_visual import EqualityVisualModel
+from scripts.crohme_lattice_common import load_cache_for_samples, load_cached_split, writer_fit_validation
+from scripts.evaluate_crohme_lattice_ocr_fusion import _fit_geometry
+from scripts.evaluate_crohme_tray_joint_selector import _prepared_signals, _weighted
+from scripts.sweep_math_ink_06_multistroke_family_guard import _family_metrics06
+from scripts.sweep_math_ink_06_x_grouping_guard import _target_metrics06
+from scripts.train_crohme_segmentation_lattice_joint_selector import _metrics
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: CROHME split·cache·full selector head. 작동 원리: test 비개입 competition sweep CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Sweep Math Ink 0.6 component competition guard")
+    parser.add_argument(
+        "--train-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/trainData",
+    )
+    parser.add_argument(
+        "--test-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/testDataGT",
+    )
+    parser.add_argument(
+        "--cache-dir", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_lattice_ocr_cache_v2_20260722",
+    )
+    parser.add_argument(
+        "--bundle", type=Path,
+        default=Path(r"research\runs\aiflow_ocr_05_dual_trajectory_3seed_20260720\bundle.manifest.json"),
+    )
+    parser.add_argument(
+        "--cross-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_cross_visual_loop3_polyline_20260722/cross_visual.json",
+    )
+    parser.add_argument(
+        "--equality-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_equality_visual_loop1_20260722/equality_visual.json",
+    )
+    parser.add_argument("--profile", default="median_height_32")
+    parser.add_argument("--maximum-x-regression-pp", type=float, default=1.0)
+    parser.add_argument("--maximum-family-regression-pp", type=float, default=2.0)
+    parser.add_argument("--maximum-pair-f1-regression-pp", type=float, default=0.25)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _evaluate_weight06(
+    samples: list[dict[str, Any]],
+    prepared: list[dict[str, Any]],
+    weight: float,
+) -> dict[str, Any]:
+    """필요 변수: 한 split의 cached signal·competition weight. 작동 원리: 전역/x/family 지표를 같은 partition에서 계산한다."""
+
+    weighted = _weighted(
+        prepared,
+        tray_weight=4.0,
+        symbol_weight=4.0,
+        fraction_weight=8.0,
+        infix_weight=8.0,
+        competition_weight=weight,
+    )
+    return {
+        "component_competition_weight": weight,
+        "global": _metrics(weighted, -2.0),
+        "behavior_targets": _target_metrics06(
+            samples, weighted, group_bias=-2.0,
+        ),
+        "families": _family_metrics06(samples, weighted),
+    }
+
+
+def _delta_pp06(candidate: float, reference: float) -> float:
+    """필요 변수: 후보·기준 비율. 작동 원리: 채택 판단용 percentage-point 차이를 반환한다."""
+
+    return (candidate - reference) * 100.0
+
+
+def main() -> None:
+    """필요 변수: writer-validation·official test. 작동 원리: 보호 gate 안 exact winner와 기준만 test에서 비교한다."""
+
+    args = _parse_args()
+    fit, validation = writer_fit_validation(args.train_root, args.profile)
+    geometry_model = _fit_geometry(fit)
+    equality_model = EqualityVisualModel.load(args.equality_model)
+    cross_model = CrossVisualModel.load(args.cross_model)
+    validation_cache = load_cache_for_samples(
+        validation,
+        args.cache_dir,
+        split="validation",
+        profile=args.profile,
+        bundle=args.bundle,
+        version=2,
+    )
+    validation_prepared = _prepared_signals(
+        validation,
+        validation_cache,
+        geometry_model,
+        equality_model=equality_model,
+        cross_model=cross_model,
+        cross_gap_ratio=0.40,
+        multistroke_family_boost=6.0,
+    )
+    trials = [
+        _evaluate_weight06(validation, validation_prepared, weight)
+        for weight in (0.0, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 12.0)
+    ]
+    reference = trials[0]
+    minimum_x = (
+        reference["behavior_targets"]["x"]["grouping_recall"]
+        - args.maximum_x_regression_pp / 100.0
+    )
+    minimum_family = (
+        reference["families"]["grouping_recall"]
+        - args.maximum_family_regression_pp / 100.0
+    )
+    minimum_pair_f1 = (
+        reference["global"]["pair_f1"]
+        - args.maximum_pair_f1_regression_pp / 100.0
+    )
+    eligible = [
+        row for row in trials
+        if (
+            row["behavior_targets"]["x"]["grouping_recall"] >= minimum_x
+            and row["families"]["grouping_recall"] >= minimum_family
+            and row["global"]["pair_f1"] >= minimum_pair_f1
+        )
+    ]
+    winner = max(eligible, key=lambda row: (
+        row["global"]["exact_partition"],
+        row["global"]["pair_f1"],
+        row["global"]["exact_group_recall"],
+        -row["component_competition_weight"],
+    ))
+    test, test_cache = load_cached_split(
+        args.test_root,
+        args.cache_dir,
+        split="official_test",
+        profile=args.profile,
+        bundle=args.bundle,
+        version=2,
+    )
+    test_prepared = _prepared_signals(
+        test,
+        test_cache,
+        geometry_model,
+        equality_model=equality_model,
+        cross_model=cross_model,
+        cross_gap_ratio=0.40,
+        multistroke_family_boost=6.0,
+    )
+    official_reference = _evaluate_weight06(test, test_prepared, 0.0)
+    official_winner = _evaluate_weight06(
+        test, test_prepared, float(winner["component_competition_weight"]),
+    )
+    deltas = {
+        "exact_partition_pp": _delta_pp06(
+            official_winner["global"]["exact_partition"],
+            official_reference["global"]["exact_partition"],
+        ),
+        "pair_f1_pp": _delta_pp06(
+            official_winner["global"]["pair_f1"],
+            official_reference["global"]["pair_f1"],
+        ),
+        "x_grouping_pp": _delta_pp06(
+            official_winner["behavior_targets"]["x"]["grouping_recall"],
+            official_reference["behavior_targets"]["x"]["grouping_recall"],
+        ),
+        "family_grouping_pp": _delta_pp06(
+            official_winner["families"]["grouping_recall"],
+            official_reference["families"]["grouping_recall"],
+        ),
+    }
+    adopted = bool(
+        float(winner["component_competition_weight"]) > 0.0
+        and deltas["exact_partition_pp"] > 0.0
+        and deltas["pair_f1_pp"] >= -args.maximum_pair_f1_regression_pp
+        and deltas["x_grouping_pp"] >= -args.maximum_x_regression_pp
+        and deltas["family_grouping_pp"] >= -args.maximum_family_regression_pp
+    )
+    report = {
+        "experiment": "R-MATH-INK-06-COMPONENT-COMPETITION-GUARD-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "selection_contract": {
+            "split": "CROHME trainData writer-validation only",
+            "cross_gap_ratio": 0.40,
+            "multistroke_family_boost": 6.0,
+            "maximum_x_regression_pp": args.maximum_x_regression_pp,
+            "maximum_family_regression_pp": args.maximum_family_regression_pp,
+            "maximum_pair_f1_regression_pp": args.maximum_pair_f1_regression_pp,
+        },
+        "reference_validation": reference,
+        "winner_validation": winner,
+        "trials": trials,
+        "official_test_reference": official_reference,
+        "official_test_winner": official_winner,
+        "official_test_deltas": deltas,
+        "decision": {
+            "adopted": adopted,
+            "selected_component_competition_weight": (
+                float(winner["component_competition_weight"]) if adopted else 0.0
+            ),
+            "reason": (
+                "exact partition improves within x/family/pair-F1 guards"
+                if adopted else "official adoption gate failed"
+            ),
+        },
+        "track": "R_noncommercial_only",
+        "product_validation": False,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps({key: value for key, value in report.items() if key != "trials"}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/sweep_math_ink_06_local_baseline_guard.py

@@ -0,0 +1,207 @@
+"""최종 selector에서 수식 공간 관계 경계를 침범하는 merge의 감점 weight를 validation 선택한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+for path in (PROJECT_ROOT, SOURCE_ROOT):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from math_grid_drawer.research.cross_visual import CrossVisualModel
+from math_grid_drawer.research.equality_visual import EqualityVisualModel
+from scripts.crohme_lattice_common import load_cache_for_samples, load_cached_split, writer_fit_validation
+from scripts.evaluate_crohme_lattice_ocr_fusion import _fit_geometry
+from scripts.evaluate_crohme_tray_joint_selector import _prepared_signals, _weighted
+from scripts.sweep_math_ink_06_multistroke_family_guard import _family_metrics06
+from scripts.sweep_math_ink_06_x_grouping_guard import _target_metrics06
+from scripts.train_crohme_segmentation_lattice_joint_selector import _metrics
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: CROHME split·cache·full selector head. 작동 원리: test 비개입 local-baseline sweep CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Sweep Math Ink 0.6 local baseline guard")
+    parser.add_argument(
+        "--train-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/trainData",
+    )
+    parser.add_argument(
+        "--test-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/testDataGT",
+    )
+    parser.add_argument(
+        "--cache-dir", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_lattice_ocr_cache_v2_20260722",
+    )
+    parser.add_argument(
+        "--bundle", type=Path,
+        default=Path(r"research\runs\aiflow_ocr_05_dual_trajectory_3seed_20260720\bundle.manifest.json"),
+    )
+    parser.add_argument(
+        "--cross-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_cross_visual_loop3_polyline_20260722/cross_visual.json",
+    )
+    parser.add_argument(
+        "--equality-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_equality_visual_loop1_20260722/equality_visual.json",
+    )
+    parser.add_argument("--profile", default="median_height_32")
+    parser.add_argument("--maximum-x-regression-pp", type=float, default=1.0)
+    parser.add_argument("--maximum-family-regression-pp", type=float, default=2.0)
+    parser.add_argument("--maximum-pair-f1-regression-pp", type=float, default=0.25)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _evaluate_weight06(
+    samples: list[dict[str, Any]],
+    prepared: list[dict[str, Any]],
+    weight: float,
+) -> dict[str, Any]:
+    """필요 변수: 한 split의 cached signal·local-baseline weight. 작동 원리: 전역/x/family 지표를 같은 partition에서 계산한다."""
+
+    weighted = _weighted(
+        prepared,
+        tray_weight=4.0,
+        symbol_weight=4.0,
+        fraction_weight=8.0,
+        infix_weight=8.0,
+        local_baseline_weight=weight,
+    )
+    return {
+        "local_baseline_weight": weight,
+        "global": _metrics(weighted, -2.0),
+        "behavior_targets": _target_metrics06(samples, weighted, group_bias=-2.0),
+        "families": _family_metrics06(samples, weighted),
+    }
+
+
+def _delta_pp06(candidate: float, reference: float) -> float:
+    """필요 변수: 후보·기준 비율. 작동 원리: 채택 판단용 percentage-point 차이를 반환한다."""
+
+    return (candidate - reference) * 100.0
+
+
+def main() -> None:
+    """필요 변수: writer-validation·official test. 작동 원리: 보호 gate 안 exact winner와 기준만 test에서 비교한다."""
+
+    args = _parse_args()
+    fit, validation = writer_fit_validation(args.train_root, args.profile)
+    geometry_model = _fit_geometry(fit)
+    equality_model = EqualityVisualModel.load(args.equality_model)
+    cross_model = CrossVisualModel.load(args.cross_model)
+    validation_cache = load_cache_for_samples(
+        validation, args.cache_dir, split="validation", profile=args.profile,
+        bundle=args.bundle, version=2,
+    )
+    validation_prepared = _prepared_signals(
+        validation, validation_cache, geometry_model,
+        equality_model=equality_model, cross_model=cross_model,
+        cross_gap_ratio=0.40, multistroke_family_boost=6.0,
+    )
+    trials = [
+        _evaluate_weight06(validation, validation_prepared, weight)
+        for weight in (0.0, 0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 12.0)
+    ]
+    reference = trials[0]
+    minimum_x = reference["behavior_targets"]["x"]["grouping_recall"] - args.maximum_x_regression_pp / 100.0
+    minimum_family = reference["families"]["grouping_recall"] - args.maximum_family_regression_pp / 100.0
+    minimum_pair_f1 = reference["global"]["pair_f1"] - args.maximum_pair_f1_regression_pp / 100.0
+    eligible = [
+        row for row in trials
+        if (
+            row["behavior_targets"]["x"]["grouping_recall"] >= minimum_x
+            and row["families"]["grouping_recall"] >= minimum_family
+            and row["global"]["pair_f1"] >= minimum_pair_f1
+        )
+    ]
+    winner = max(eligible, key=lambda row: (
+        row["global"]["exact_partition"],
+        row["global"]["pair_f1"],
+        row["global"]["exact_group_recall"],
+        -row["local_baseline_weight"],
+    ))
+    test, test_cache = load_cached_split(
+        args.test_root, args.cache_dir, split="official_test", profile=args.profile,
+        bundle=args.bundle, version=2,
+    )
+    test_prepared = _prepared_signals(
+        test, test_cache, geometry_model,
+        equality_model=equality_model, cross_model=cross_model,
+        cross_gap_ratio=0.40, multistroke_family_boost=6.0,
+    )
+    official_reference = _evaluate_weight06(test, test_prepared, 0.0)
+    official_winner = _evaluate_weight06(test, test_prepared, float(winner["local_baseline_weight"]))
+    deltas = {
+        "exact_partition_pp": _delta_pp06(
+            official_winner["global"]["exact_partition"], official_reference["global"]["exact_partition"],
+        ),
+        "pair_f1_pp": _delta_pp06(
+            official_winner["global"]["pair_f1"], official_reference["global"]["pair_f1"],
+        ),
+        "x_grouping_pp": _delta_pp06(
+            official_winner["behavior_targets"]["x"]["grouping_recall"],
+            official_reference["behavior_targets"]["x"]["grouping_recall"],
+        ),
+        "family_grouping_pp": _delta_pp06(
+            official_winner["families"]["grouping_recall"], official_reference["families"]["grouping_recall"],
+        ),
+    }
+    adopted = bool(
+        float(winner["local_baseline_weight"]) > 0.0
+        and deltas["exact_partition_pp"] > 0.0
+        and deltas["pair_f1_pp"] >= -args.maximum_pair_f1_regression_pp
+        and deltas["x_grouping_pp"] >= -args.maximum_x_regression_pp
+        and deltas["family_grouping_pp"] >= -args.maximum_family_regression_pp
+    )
+    report = {
+        "experiment": "R-MATH-INK-06-LOCAL-BASELINE-GUARD-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "selection_contract": {
+            "split": "CROHME trainData writer-validation only",
+            "cross_gap_ratio": 0.40,
+            "multistroke_family_boost": 6.0,
+            "maximum_x_regression_pp": args.maximum_x_regression_pp,
+            "maximum_family_regression_pp": args.maximum_family_regression_pp,
+            "maximum_pair_f1_regression_pp": args.maximum_pair_f1_regression_pp,
+        },
+        "signal_coverage": {
+            "validation_candidates": sum(
+                int((row["local_baseline_penalty"] > 0.0).sum()) for row in validation_prepared
+            ),
+            "official_test_candidates": sum(
+                int((row["local_baseline_penalty"] > 0.0).sum()) for row in test_prepared
+            ),
+        },
+        "reference_validation": reference,
+        "winner_validation": winner,
+        "trials": trials,
+        "official_test_reference": official_reference,
+        "official_test_winner": official_winner,
+        "official_test_deltas": deltas,
+        "decision": {
+            "adopted": adopted,
+            "selected_local_baseline_weight": float(winner["local_baseline_weight"]) if adopted else 0.0,
+            "reason": (
+                "exact partition improves within x/family/pair-F1 guards"
+                if adopted else "official adoption gate failed"
+            ),
+        },
+        "track": "R_noncommercial_only",
+        "product_validation": False,
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({key: value for key, value in report.items() if key != "trials"}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/train_math_ink_06_boundary_behavior_guard.py

@@ -0,0 +1,283 @@
+"""Grouping 이전 geometry로 기호 경계 침범 확률을 학습하고 최종 selector에서 검증한다."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sys
+from typing import Any
+
+import joblib
+import numpy as np
+from sklearn.ensemble import HistGradientBoostingClassifier
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src"
+for path in (PROJECT_ROOT, SOURCE_ROOT):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from math_grid_drawer.aiflow_ocr05 import AIFlowOCR05
+from math_grid_drawer.research.cross_visual import CrossVisualModel
+from math_grid_drawer.research.equality_visual import EqualityVisualModel
+from math_grid_drawer.research.segmentation_lattice import (
+    LATTICE_FEATURE_NAMES,
+    lattice_candidate_features,
+)
+from scripts.crohme_lattice_common import load_cache_for_samples, load_cached_split, writer_fit_validation
+from scripts.evaluate_crohme_gt_free_grouping import _truth_partition
+from scripts.evaluate_crohme_lattice_ocr_fusion import _fit_geometry
+from scripts.evaluate_crohme_tray_joint_selector import _prepared_signals, _weighted
+from scripts.sweep_math_ink_06_multistroke_family_guard import _family_metrics06
+from scripts.sweep_math_ink_06_x_grouping_guard import _target_metrics06
+from scripts.train_crohme_segmentation_lattice_joint_selector import _metrics
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: CROHME split·cache·head 경로. 작동 원리: writer-disjoint boundary 학습/검증 CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Train Math Ink 0.6 boundary behavior guard")
+    parser.add_argument(
+        "--train-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/trainData",
+    )
+    parser.add_argument(
+        "--test-root", type=Path,
+        default=PROJECT_ROOT / "research/data/R_noncommercial/ICFHR_package/CROHME2012_data/testDataGT",
+    )
+    parser.add_argument(
+        "--cache-dir", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_lattice_ocr_cache_v2_20260722",
+    )
+    parser.add_argument(
+        "--bundle", type=Path,
+        default=Path(r"research\runs\aiflow_ocr_05_dual_trajectory_3seed_20260720\bundle.manifest.json"),
+    )
+    parser.add_argument(
+        "--cross-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_cross_visual_loop3_polyline_20260722/cross_visual.json",
+    )
+    parser.add_argument(
+        "--equality-model", type=Path,
+        default=PROJECT_ROOT / "research/runs/crohme_equality_visual_loop1_20260722/equality_visual.json",
+    )
+    parser.add_argument("--profile", default="median_height_32")
+    parser.add_argument("--maximum-x-regression-pp", type=float, default=1.0)
+    parser.add_argument("--maximum-family-regression-pp", type=float, default=2.0)
+    parser.add_argument("--maximum-pair-f1-regression-pp", type=float, default=0.25)
+    parser.add_argument("--output", type=Path, required=True)
+    return parser.parse_args()
+
+
+def _boundary_training_rows(samples: list[dict[str, Any]]) -> tuple[np.ndarray, np.ndarray]:
+    """필요 변수: fit writer 수식·truth partition. 작동 원리: 둘 이상의 정답 기호를 침범한 다획 후보를 boundary=1로 학습한다."""
+
+    feature_rows: list[np.ndarray] = []
+    targets: list[bool] = []
+    for sample in samples:
+        strokes = sample["profiled_strokes"]
+        candidates = AIFlowOCR05.build_segmentation_lattice(strokes)
+        features = lattice_candidate_features(candidates, strokes)
+        truth_groups, _labels = _truth_partition(sample, "aiflow_geometry")
+        for candidate, feature in zip(candidates, features, strict=True):
+            group = frozenset(int(value) for value in candidate["source_indices"])
+            if len(group) <= 1:
+                continue
+            feature_rows.append(feature)
+            targets.append(sum(bool(group & truth) for truth in truth_groups) > 1)
+    return np.asarray(feature_rows, dtype=np.float32), np.asarray(targets, dtype=np.int64)
+
+
+def _fit_boundary_model(samples: list[dict[str, Any]]) -> tuple[HistGradientBoostingClassifier, dict[str, Any]]:
+    """필요 변수: fit writer 후보. 작동 원리: class-balanced gradient boosting으로 기호 경계 침범 확률을 학습한다."""
+
+    features, targets = _boundary_training_rows(samples)
+    positives = max(int(targets.sum()), 1)
+    negatives = max(len(targets) - positives, 1)
+    sample_weight = np.where(
+        targets == 1, len(targets) / (2 * positives), len(targets) / (2 * negatives),
+    )
+    model = HistGradientBoostingClassifier(
+        learning_rate=0.06,
+        max_iter=220,
+        max_leaf_nodes=31,
+        l2_regularization=2.0,
+        min_samples_leaf=40,
+        random_state=17,
+    ).fit(features, targets, sample_weight=sample_weight)
+    return model, {
+        "candidate_rows": len(targets),
+        "boundary_rows": int(targets.sum()),
+        "boundary_rate": float(targets.mean()),
+    }
+
+
+def _boundary_probabilities(
+    prepared: list[dict[str, Any]], model: HistGradientBoostingClassifier,
+) -> list[np.ndarray]:
+    """필요 변수: 평가 후보 geometry·학습 모델. 작동 원리: singleton은 0, 다획 후보만 경계 침범 확률을 반환한다."""
+
+    output = []
+    for row in prepared:
+        probabilities = model.predict_proba(row["features"][:, :len(LATTICE_FEATURE_NAMES)])[:, 1]
+        multistroke = np.asarray(
+            [len(candidate["source_indices"]) > 1 for candidate in row["candidates"]],
+            dtype=bool,
+        )
+        output.append(np.where(multistroke, probabilities, 0.0).astype(np.float32))
+    return output
+
+
+def _evaluate06(
+    samples: list[dict[str, Any]],
+    prepared: list[dict[str, Any]],
+    probabilities: list[np.ndarray],
+    *,
+    threshold: float,
+    weight: float,
+) -> dict[str, Any]:
+    """필요 변수: selector row·boundary 확률·threshold/weight. 작동 원리: 확률 초과분만 logit에서 빼고 보호 지표를 계산한다."""
+
+    weighted = _weighted(
+        prepared, tray_weight=4.0, symbol_weight=4.0,
+        fraction_weight=8.0, infix_weight=8.0,
+    )
+    guarded = []
+    for row, probability in zip(weighted, probabilities, strict=True):
+        penalty = np.maximum(probability - threshold, 0.0) / max(1.0 - threshold, 1e-6)
+        guarded.append({**row, "logits": row["logits"] - weight * penalty})
+    return {
+        "threshold": threshold,
+        "weight": weight,
+        "global": _metrics(guarded, -2.0),
+        "behavior_targets": _target_metrics06(samples, guarded, group_bias=-2.0),
+        "families": _family_metrics06(samples, guarded),
+    }
+
+
+def _delta_pp06(candidate: float, reference: float) -> float:
+    """필요 변수: 후보·기준 비율. 작동 원리: 채택 판단용 percentage-point 차이를 반환한다."""
+
+    return (candidate - reference) * 100.0
+
+
+def main() -> None:
+    """필요 변수: fit/validation/test writer split. 작동 원리: fit 학습·validation 선택 후 고정 winner만 official test에 적용한다."""
+
+    args = _parse_args()
+    fit, validation = writer_fit_validation(args.train_root, args.profile)
+    boundary_model, training = _fit_boundary_model(fit)
+    geometry_model = _fit_geometry(fit)
+    equality_model = EqualityVisualModel.load(args.equality_model)
+    cross_model = CrossVisualModel.load(args.cross_model)
+    validation_cache = load_cache_for_samples(
+        validation, args.cache_dir, split="validation", profile=args.profile,
+        bundle=args.bundle, version=2,
+    )
+    validation_prepared = _prepared_signals(
+        validation, validation_cache, geometry_model,
+        equality_model=equality_model, cross_model=cross_model,
+        cross_gap_ratio=0.40, multistroke_family_boost=6.0,
+    )
+    validation_probability = _boundary_probabilities(validation_prepared, boundary_model)
+    trials = [
+        _evaluate06(
+            validation, validation_prepared, validation_probability,
+            threshold=threshold, weight=weight,
+        )
+        for threshold in (0.30, 0.50, 0.65, 0.80, 0.90)
+        for weight in (0.0, 1.0, 2.0, 4.0, 6.0, 8.0, 12.0)
+    ]
+    reference = trials[0]
+    minimum_x = reference["behavior_targets"]["x"]["grouping_recall"] - args.maximum_x_regression_pp / 100.0
+    minimum_family = reference["families"]["grouping_recall"] - args.maximum_family_regression_pp / 100.0
+    minimum_pair_f1 = reference["global"]["pair_f1"] - args.maximum_pair_f1_regression_pp / 100.0
+    eligible = [
+        row for row in trials
+        if (
+            row["behavior_targets"]["x"]["grouping_recall"] >= minimum_x
+            and row["families"]["grouping_recall"] >= minimum_family
+            and row["global"]["pair_f1"] >= minimum_pair_f1
+        )
+    ]
+    winner = max(eligible, key=lambda row: (
+        row["global"]["exact_partition"], row["global"]["pair_f1"],
+        row["global"]["exact_group_recall"], -row["weight"], row["threshold"],
+    ))
+    test, test_cache = load_cached_split(
+        args.test_root, args.cache_dir, split="official_test", profile=args.profile,
+        bundle=args.bundle, version=2,
+    )
+    test_prepared = _prepared_signals(
+        test, test_cache, geometry_model,
+        equality_model=equality_model, cross_model=cross_model,
+        cross_gap_ratio=0.40, multistroke_family_boost=6.0,
+    )
+    test_probability = _boundary_probabilities(test_prepared, boundary_model)
+    official_reference = _evaluate06(
+        test, test_prepared, test_probability, threshold=0.30, weight=0.0,
+    )
+    official_winner = _evaluate06(
+        test, test_prepared, test_probability,
+        threshold=float(winner["threshold"]), weight=float(winner["weight"]),
+    )
+    deltas = {
+        "exact_partition_pp": _delta_pp06(
+            official_winner["global"]["exact_partition"], official_reference["global"]["exact_partition"],
+        ),
+        "pair_f1_pp": _delta_pp06(
+            official_winner["global"]["pair_f1"], official_reference["global"]["pair_f1"],
+        ),
+        "x_grouping_pp": _delta_pp06(
+            official_winner["behavior_targets"]["x"]["grouping_recall"],
+            official_reference["behavior_targets"]["x"]["grouping_recall"],
+        ),
+        "family_grouping_pp": _delta_pp06(
+            official_winner["families"]["grouping_recall"], official_reference["families"]["grouping_recall"],
+        ),
+    }
+    adopted = bool(
+        float(winner["weight"]) > 0.0
+        and deltas["exact_partition_pp"] > 0.0
+        and deltas["pair_f1_pp"] >= -args.maximum_pair_f1_regression_pp
+        and deltas["x_grouping_pp"] >= -args.maximum_x_regression_pp
+        and deltas["family_grouping_pp"] >= -args.maximum_family_regression_pp
+    )
+    artifact_path = args.output.parent / "boundary_behavior_guard.joblib"
+    artifact_path.parent.mkdir(parents=True, exist_ok=True)
+    joblib.dump({
+        "schema": "aiflow-math-ink-06-boundary-behavior-v1",
+        "feature_names": list(LATTICE_FEATURE_NAMES),
+        "model": boundary_model,
+        "threshold": float(winner["threshold"]) if adopted else None,
+        "weight": float(winner["weight"]) if adopted else 0.0,
+        "track": "R_noncommercial_only",
+    }, artifact_path)
+    report = {
+        "experiment": "R-MATH-INK-06-BOUNDARY-BEHAVIOR-GUARD-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "training": training,
+        "feature_names": list(LATTICE_FEATURE_NAMES),
+        "reference_validation": reference,
+        "winner_validation": winner,
+        "trials": trials,
+        "official_test_reference": official_reference,
+        "official_test_winner": official_winner,
+        "official_test_deltas": deltas,
+        "decision": {
+            "adopted": adopted,
+            "selected_threshold": float(winner["threshold"]) if adopted else None,
+            "selected_weight": float(winner["weight"]) if adopted else 0.0,
+        },
+        "artifact": str(artifact_path),
+        "track": "R_noncommercial_only",
+        "product_validation": False,
+    }
+    args.output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({key: value for key, value in report.items() if key != "trials"}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/segmentation_lattice.py

@@ -0,0 +1,256 @@
+"""획 grouping을 조기 확정하지 않고 복수 symbol 후보로 보존하는 연구용 lattice다."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Sequence
+import math
+
+import numpy as np
+
+
+def _stroke_box(stroke: dict[str, Any]) -> tuple[float, float, float, float]:
+    """필요 변수: point가 있는 stroke. 작동 원리: 후보 거리·정렬에 사용할 bbox를 계산한다."""
+
+    points = stroke.get("points") or []
+    xs = [float(point.get("x", 0.0) if isinstance(point, dict) else point[0]) for point in points]
+    ys = [float(point.get("y", 0.0) if isinstance(point, dict) else point[1]) for point in points]
+    if not xs:
+        raise ValueError("빈 stroke는 segmentation lattice에 넣을 수 없습니다.")
+    return min(xs), min(ys), max(xs), max(ys)
+
+
+def _group_box(indices: frozenset[int], boxes: Sequence[tuple[float, float, float, float]]) -> dict[str, float]:
+    """필요 변수: stroke index 집합·개별 bbox. 작동 원리: group 전체 bbox를 직렬화 가능한 값으로 합친다."""
+
+    return {
+        "left": min(boxes[index][0] for index in indices),
+        "top": min(boxes[index][1] for index in indices),
+        "right": max(boxes[index][2] for index in indices),
+        "bottom": max(boxes[index][3] for index in indices),
+    }
+
+
+def _box_gap(first: tuple[float, float, float, float], second: tuple[float, float, float, float]) -> float:
+    """필요 변수: 두 bbox. 작동 원리: 겹치면 0, 아니면 유클리드 외곽 간격을 반환한다."""
+
+    dx = max(first[0] - second[2], second[0] - first[2], 0.0)
+    dy = max(first[1] - second[3], second[1] - first[3], 0.0)
+    return math.hypot(dx, dy)
+
+
+def build_group_candidate_lattice(
+    strokes: Sequence[dict[str, Any]],
+    seed_partitions: Sequence[Sequence[dict[str, Any]]],
+    *,
+    temporal_window: int = 4,
+    spatial_neighbors: int = 3,
+) -> list[dict[str, Any]]:
+    """필요 변수: 원 stroke·여러 geometry partition. 작동 원리: singleton/시간창/공간이웃/기존 group을 중복 제거해 보존한다."""
+
+    usable = [(index, stroke) for index, stroke in enumerate(strokes) if stroke.get("points")]
+    if not usable:
+        return []
+    source_indices = [index for index, _stroke in usable]
+    stroke_by_index = {index: stroke for index, stroke in usable}
+    boxes_by_source = {index: _stroke_box(stroke) for index, stroke in usable}
+    dense_boxes = [boxes_by_source[index] for index in source_indices]
+    evidence: dict[frozenset[int], set[str]] = defaultdict(set)
+
+    def add(indices: frozenset[int], reason: str) -> None:
+        if indices and indices.issubset(stroke_by_index):
+            evidence[indices].add(reason)
+
+    for index in source_indices:
+        add(frozenset({index}), "singleton")
+    for partition_index, partition in enumerate(seed_partitions):
+        for segment in partition:
+            add(frozenset(int(index) for index in segment["source_indices"]), f"geometry:{partition_index}")
+
+    # 필기 순서가 인접한 다획 기호를 복구하되 지수 폭발을 막기 위해 짧은 연속 창만 만든다.
+    for start in range(len(source_indices)):
+        for length in range(2, min(temporal_window, len(source_indices) - start) + 1):
+            add(frozenset(source_indices[start:start + length]), f"temporal:{length}")
+
+    # 실제 기호 획이 시간상 끼어 쓰였을 때를 위해 각 획의 가까운 공간 이웃 pair를 추가한다.
+    for dense_index, source_index in enumerate(source_indices):
+        neighbor_order = sorted(
+            (other for other in range(len(source_indices)) if other != dense_index),
+            key=lambda other: (_box_gap(dense_boxes[dense_index], dense_boxes[other]), other),
+        )[:spatial_neighbors]
+        for other in neighbor_order:
+            add(frozenset({source_index, source_indices[other]}), "spatial_pair")
+
+    candidates = []
+    for indices, reasons in evidence.items():
+        box = _group_box(indices, boxes_by_source)
+        candidates.append({
+            "source_indices": sorted(indices),
+            "strokes": [stroke_by_index[index] for index in sorted(indices)],
+            "box": box,
+            "evidence": sorted(reasons),
+            "candidate_id": "g:" + ",".join(str(index) for index in sorted(indices)),
+        })
+    candidates.sort(key=lambda row: (row["box"]["left"], len(row["source_indices"]), row["source_indices"]))
+    return candidates
+
+
+def lattice_partition_oracle(
+    candidates: Sequence[dict[str, Any]], truth_groups: Sequence[frozenset[int]],
+) -> dict[str, Any]:
+    """필요 변수: 후보 lattice·정답 partition. 작동 원리: 점수와 무관한 후보 coverage 상한을 계산한다."""
+
+    candidate_groups = {frozenset(int(index) for index in row["source_indices"]) for row in candidates}
+    matched = [group for group in truth_groups if group in candidate_groups]
+    missing = [sorted(group) for group in truth_groups if group not in candidate_groups]
+    return {
+        "truth_groups": len(truth_groups),
+        "matched_groups": len(matched),
+        "group_recall": len(matched) / max(len(truth_groups), 1),
+        "exact_partition_recoverable": not missing,
+        "missing_groups": missing,
+    }
+
+
+LATTICE_FEATURE_NAMES = (
+    "stroke_count", "point_count_log", "width_ref", "height_ref", "aspect_log",
+    "temporal_span", "temporal_contiguous", "singleton", "geometry_votes",
+    "has_temporal", "has_spatial_pair", "pair_gap_mean", "pair_gap_max",
+    "stroke_width_mean", "stroke_width_std", "stroke_height_mean", "stroke_height_std",
+)
+
+LATTICE_OCR_FEATURE_NAMES = (
+    "ocr_top1", "ocr_margin", "ocr_top5_mass", "ocr_entropy", "family_top1",
+    "family_margin", "merge_top1_gain", "merge_entropy_gain", "label_alnum",
+    "label_operator", "label_container", "label_delimiter", "label_dot_like",
+)
+
+
+def lattice_candidate_features(
+    candidates: Sequence[dict[str, Any]], strokes: Sequence[dict[str, Any]],
+) -> np.ndarray:
+    """필요 변수: lattice 후보·원 stroke. 작동 원리: label 없이 공동 selector가 사용할 scale-normalized geometry feature를 만든다."""
+
+    boxes = [_stroke_box(stroke) for stroke in strokes]
+    nonzero_heights = [box[3] - box[1] for box in boxes if box[3] - box[1] > 1e-6]
+    reference_height = float(np.median(nonzero_heights)) if nonzero_heights else 1.0
+    rows = []
+    for candidate in candidates:
+        indices = [int(index) for index in candidate["source_indices"]]
+        selected = [boxes[index] for index in indices]
+        box = candidate["box"]
+        width = float(box["right"] - box["left"])
+        height = float(box["bottom"] - box["top"])
+        gaps = [_box_gap(selected[first], selected[second]) / reference_height
+                for first in range(len(selected)) for second in range(first + 1, len(selected))]
+        widths = [(value[2] - value[0]) / reference_height for value in selected]
+        heights = [(value[3] - value[1]) / reference_height for value in selected]
+        evidence = set(candidate.get("evidence") or [])
+        rows.append([
+            len(indices), math.log1p(sum(len(strokes[index].get("points") or []) for index in indices)),
+            width / reference_height, height / reference_height,
+            math.log(max(width, 1e-6) / max(height, 1e-6)),
+            max(indices) - min(indices) + 1, float(max(indices) - min(indices) + 1 == len(indices)),
+            float(len(indices) == 1), sum(value.startswith("geometry:") for value in evidence),
+            float(any(value.startswith("temporal:") for value in evidence)),
+            float("spatial_pair" in evidence), float(np.mean(gaps)) if gaps else 0.0,
+            max(gaps, default=0.0), float(np.mean(widths)), float(np.std(widths)),
+            float(np.mean(heights)), float(np.std(heights)),
+        ])
+    return np.asarray(rows, dtype=np.float32)
+
+
+def lattice_ocr_features(candidates: Sequence[dict[str, Any]]) -> np.ndarray:
+    """필요 변수: OCR summary가 부착된 lattice. 작동 원리: confidence와 singleton 대비 결합 이득을 label-coarse feature로 바꾼다."""
+
+    singleton = {
+        int(candidate["source_indices"][0]): candidate["ocr_summary"]
+        for candidate in candidates if len(candidate["source_indices"]) == 1
+    }
+    operators = {"+", "-", "=", "/", r"\times", r"\div", r"\pm", r"\neq", "<", ">"}
+    containers = {r"\sqrt{}", r"\sqrt", r"\sum", r"\int", r"\prod"}
+    delimiters = {"(", ")", "[", "]", r"\{", r"\}", r"\langle", r"\rangle", "|"}
+    dot_like = {".", ",", r"\dots", r"\dotsc", r"\cdot"}
+    rows = []
+    for candidate in candidates:
+        summary = candidate.get("ocr_summary")
+        if not isinstance(summary, dict):
+            raise ValueError("lattice OCR feature에는 ocr_summary가 필요합니다.")
+        indices = [int(index) for index in candidate["source_indices"]]
+        components = [singleton[index] for index in indices if index in singleton]
+        component_top1 = float(np.mean([row["top1"] for row in components])) if components else 0.0
+        component_entropy = float(np.mean([row["entropy"] for row in components])) if components else 0.0
+        label = str(summary["top_label"])
+        rows.append([
+            float(summary["top1"]), float(summary["top1"] - summary["top2"]),
+            float(summary["top5_mass"]), float(summary["entropy"]), float(summary["family_top1"]),
+            float(summary["family_top1"] - summary["family_top2"]),
+            float(summary["top1"] - component_top1) if len(indices) > 1 else 0.0,
+            float(component_entropy - summary["entropy"]) if len(indices) > 1 else 0.0,
+            float(label.isalnum()), float(label in operators), float(label in containers),
+            float(label in delimiters), float(label in dot_like),
+        ])
+    return np.asarray(rows, dtype=np.float32)
+
+
+def select_lattice_partition(
+    candidates: Sequence[dict[str, Any]], scores: Sequence[float], stroke_count: int,
+    *, beam_width: int = 128, group_bias: float = 0.0, options_per_stroke: int = 32,
+    transition_scores: np.ndarray | None = None,
+) -> list[frozenset[int]]:
+    """필요 변수: 후보·logit score·획 수. 작동 원리: 모든 획을 정확히 한 번 덮는 최고 점수 partition을 beam exact-cover로 찾는다."""
+
+    if len(candidates) != len(scores):
+        raise ValueError("lattice 후보와 score 수가 다릅니다.")
+    if stroke_count < 1:
+        return []
+    if transition_scores is not None and transition_scores.shape != (len(candidates), len(candidates)):
+        raise ValueError("candidate transition score 행렬 크기가 다릅니다.")
+    full_mask = (1 << stroke_count) - 1
+    prepared = []
+    by_stroke: dict[int, list[int]] = defaultdict(list)
+    for candidate_index, (candidate, score) in enumerate(zip(candidates, scores, strict=True)):
+        indices = tuple(int(index) for index in candidate["source_indices"])
+        if not indices or any(index < 0 or index >= stroke_count for index in indices):
+            continue
+        mask = sum(1 << index for index in indices)
+        prepared.append((candidate_index, mask, frozenset(indices), float(score) + group_bias))
+        for index in indices:
+            by_stroke[index].append(len(prepared) - 1)
+    for index in by_stroke:
+        by_stroke[index].sort(key=lambda row: prepared[row][3], reverse=True)
+        by_stroke[index] = by_stroke[index][:options_per_stroke]
+    if transition_scores is None:
+        beams: dict[Any, tuple[float, tuple[frozenset[int], ...]]] = {0: (0.0, ())}
+    else:
+        beams = {(0, -1): (0.0, ())}
+    for _step in range(stroke_count):
+        expanded: dict[Any, tuple[float, tuple[frozenset[int], ...]]] = {}
+        for state_key, (total_score, groups) in beams.items():
+            used_mask, previous_candidate = (state_key, -1) if transition_scores is None else state_key
+            if used_mask == full_mask:
+                expanded[state_key] = max(expanded.get(state_key, (-math.inf, ())), (total_score, groups), key=lambda row: row[0])
+                continue
+            first_uncovered = next(index for index in range(stroke_count) if not used_mask & (1 << index))
+            for prepared_index in by_stroke.get(first_uncovered, []):
+                candidate_index, mask, group, score = prepared[prepared_index]
+                if used_mask & mask:
+                    continue
+                new_mask = used_mask | mask
+                transition = 0.0 if transition_scores is None or previous_candidate < 0 else float(
+                    transition_scores[previous_candidate, candidate_index]
+                )
+                proposal = (total_score + score + transition, groups + (group,))
+                new_key: Any = new_mask if transition_scores is None else (new_mask, candidate_index)
+                if new_key not in expanded or proposal[0] > expanded[new_key][0]:
+                    expanded[new_key] = proposal
+        if not expanded:
+            raise ValueError("모든 stroke를 덮는 lattice partition을 찾지 못했습니다.")
+        beams = dict(sorted(expanded.items(), key=lambda row: row[1][0], reverse=True)[:beam_width])
+        complete_keys = [key for key in beams if (key if transition_scores is None else key[0]) == full_mask]
+        if complete_keys and all((key if transition_scores is None else key[0]) == full_mask for key in beams):
+            break
+    complete = [value for key, value in beams.items() if (key if transition_scores is None else key[0]) == full_mask]
+    if not complete:
+        raise ValueError("beam width 안에서 완전 partition을 찾지 못했습니다.")
+    return list(max(complete, key=lambda row: row[0])[1])

src/structure_relations.py

@@ -0,0 +1,203 @@
+"""기호 인식과 독립적으로 수식의 2D 배치 관계를 추론하는 연구용 레이어다."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Sequence
+
+import numpy as np
+
+from .math_tray import infer_math_trays
+
+
+RELATION_TYPES = ("RIGHT", "SUPERSCRIPT", "SUBSCRIPT", "ABOVE", "BELOW", "CONTAINS")
+STRUCTURAL_RELATION_TYPES = frozenset({"SUPERSCRIPT", "SUBSCRIPT", "ABOVE", "BELOW", "CONTAINS"})
+
+
+@dataclass(frozen=True, slots=True)
+class RelationConfig:
+    """필요 변수: 첨자 기하 임계값. 작동 원리: writer validation에서 고를 수 있도록 관계 판정값을 외부화한다."""
+
+    script_min_height_ratio: float = 0.18
+    script_max_height_ratio: float = 0.82
+    script_vertical_shift_ratio: float = 0.18
+    script_max_horizontal_gap_ratio: float = 0.75
+
+
+def _label(segment: dict[str, Any]) -> str:
+    """필요 변수: 인식된 segment. 작동 원리: 구조 힌트를 우선하고 첫 전문가의 top-1을 보조 라벨로 읽는다."""
+
+    hint = segment.get("structural_hint")
+    if hint:
+        return str(hint)
+    for result in (segment.get("results") or {}).values():
+        candidates = result.get("candidates") or []
+        if candidates:
+            return str(candidates[0]["label"])
+    return ""
+
+
+def _geometry(segment: dict[str, Any]) -> dict[str, float]:
+    """필요 변수: segment bbox. 작동 원리: 관계 판정에 필요한 폭·높이·중심 좌표를 한 번 계산한다."""
+
+    box = segment["box"]
+    left, top = float(box["left"]), float(box["top"])
+    right, bottom = float(box["right"]), float(box["bottom"])
+    return {
+        "left": left, "top": top, "right": right, "bottom": bottom,
+        "width": max(right - left, 1.0), "height": max(bottom - top, 1.0),
+        "cx": (left + right) * 0.5, "cy": (top + bottom) * 0.5,
+    }
+
+
+def infer_spatial_relations(
+    segments: Sequence[dict[str, Any]], config: RelationConfig | None = None,
+    *, trays: Sequence[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """필요 변수: geometry group과 선택적 OCR 결과. 작동 원리: 각 기호를 한 번만 자식으로 소비해 2D 관계 그래프를 만든다."""
+
+    relation_config = config or RelationConfig()
+    if len(segments) < 2:
+        return []
+    boxes = [_geometry(segment) for segment in segments]
+    labels = [_label(segment) for segment in segments]
+    maximum_height = max(box["height"] for box in boxes)
+    body_heights = [box["height"] for box in boxes if box["height"] >= maximum_height * 0.25]
+    reference_height = float(np.median(body_heights))
+    relations: list[dict[str, Any]] = []
+    assigned: set[int] = set()
+    structural_parents: set[int] = set()
+
+    # 근호는 내부 기호를 symbol group에 합치지 않고 CONTAINS edge로만 소유한다.
+    for parent, (box, label) in enumerate(zip(boxes, labels, strict=True)):
+        root_like = label in {r"\sqrt", r"\sqrt{}"}
+        if not root_like:
+            continue
+        structural_parents.add(parent)
+        for child, inner in enumerate(boxes):
+            if child == parent or child in assigned:
+                continue
+            inside_x = box["left"] + box["width"] * 0.20 <= inner["cx"] <= box["right"] + reference_height * 0.15
+            inside_y = inner["cy"] >= box["top"] and inner["top"] <= box["bottom"] + reference_height * 0.35
+            if inside_x and inside_y:
+                relations.append({"parent": parent, "child": child, "type": "CONTAINS", "confidence": 0.95})
+                assigned.add(child)
+
+    # 분수는 bar 단독이 아니라 분자·분모가 모두 점유된 원자적 Tray일 때만 관계를 만든다.
+    tray_rows = list(trays) if trays is not None else infer_math_trays(segments)
+    fraction_trays = [tray for tray in tray_rows if tray["type"] == "FRACTION"]
+    for tray in fraction_trays:
+        parent = int(tray["anchor"])
+        structural_parents.add(parent)
+        for slot, relation in (("numerator", "ABOVE"), ("denominator", "BELOW")):
+            for child in tray["slots"].get(slot, []):
+                if child in assigned:
+                    continue
+                relations.append({
+                    "parent": parent, "child": child, "type": relation,
+                    "confidence": float(tray["constraint_score"]),
+                })
+                assigned.add(child)
+
+    # 적분·합·곱·극한의 상하한은 일반 최근접 첨자보다 수학 Tray의 anchor 소유권을 우선한다.
+    operator_trays = [tray for tray in tray_rows if tray["type"] in {"INTEGRAL", "SUM", "PRODUCT", "LIM"}]
+    for tray in operator_trays:
+        parent = int(tray["anchor"])
+        structural_parents.add(parent)
+        for slot, relation in (("lower", "SUBSCRIPT"), ("upper", "SUPERSCRIPT")):
+            for child in tray["slots"].get(slot, []):
+                if child in assigned:
+                    continue
+                relations.append({
+                    "parent": parent, "child": int(child), "type": relation,
+                    "confidence": float(tray["constraint_score"]),
+                })
+                assigned.add(int(child))
+
+    # 남은 기호는 가장 가까운 왼쪽 기호를 기준으로 첨자 또는 RIGHT 관계를 갖는다.
+    for child, box in enumerate(boxes):
+        if child in assigned or child in structural_parents:
+            continue
+        candidates = [index for index, other in enumerate(boxes) if index != child and other["cx"] < box["cx"]]
+        if not candidates:
+            continue
+        parent = min(candidates, key=lambda index: max(0.0, box["left"] - boxes[index]["right"]))
+        base = boxes[parent]
+        horizontal_gap = max(0.0, box["left"] - base["right"])
+        script_sized = (
+            reference_height * relation_config.script_min_height_ratio
+            <= box["height"]
+            <= base["height"] * relation_config.script_max_height_ratio
+        )
+        script_near = horizontal_gap <= reference_height * relation_config.script_max_horizontal_gap_ratio
+        vertical_shift = base["height"] * relation_config.script_vertical_shift_ratio
+        if script_sized and script_near and box["cy"] < base["cy"] - vertical_shift:
+            relation = "SUPERSCRIPT"
+            confidence = 0.82
+        elif script_sized and script_near and box["cy"] > base["cy"] + vertical_shift:
+            relation = "SUBSCRIPT"
+            confidence = 0.82
+        else:
+            relation = "RIGHT"
+            confidence = 0.75
+        relations.append({"parent": parent, "child": child, "type": relation, "confidence": confidence})
+        assigned.add(child)
+
+    return sorted(relations, key=lambda item: (item["child"], item["parent"], item["type"]))
+
+
+def serialize_relation_graph(
+    labels: Sequence[str], segments: Sequence[dict[str, Any]], relations: Sequence[dict[str, Any]],
+) -> str:
+    """필요 변수: group별 라벨·bbox·관계 edge. 작동 원리: 구조 자식을 한 번만 소비해 2D graph를 LaTeX로 직렬화한다."""
+
+    if len(labels) != len(segments):
+        raise ValueError("관계 serializer의 label과 segment 수가 다릅니다.")
+    children: dict[int, dict[str, list[int]]] = {}
+    structural_children: set[int] = set()
+    for relation in relations:
+        relation_type = str(relation["type"])
+        if relation_type not in STRUCTURAL_RELATION_TYPES:
+            continue
+        parent, child = int(relation["parent"]), int(relation["child"])
+        if parent < 0 or child < 0 or parent >= len(labels) or child >= len(labels) or parent == child:
+            raise ValueError("관계 graph에 유효하지 않은 node index가 있습니다.")
+        children.setdefault(parent, {}).setdefault(relation_type, []).append(child)
+        structural_children.add(child)
+
+    def left(index: int) -> float:
+        """필요 변수: node index. 작동 원리: 같은 구조 슬롯 안의 기호를 원래 x 순서로 정렬한다."""
+
+        return float(segments[index]["box"]["left"])
+
+    def render_sequence(indices: Sequence[int], active: frozenset[int]) -> str:
+        """필요 변수: node index 열·재귀 경로. 작동 원리: 같은 슬롯의 node를 좌→우로 한 번씩 출력한다."""
+
+        return "".join(render_node(index, active) for index in sorted(set(indices), key=left))
+
+    def render_node(index: int, active: frozenset[int]) -> str:
+        """필요 변수: 현재 node·재귀 경로. 작동 원리: root/fraction/script 구조를 중첩 가능한 LaTeX node로 만든다."""
+
+        if index in active:
+            raise ValueError("관계 graph에 cycle이 있습니다.")
+        next_active = active | {index}
+        slots = children.get(index, {})
+        above = slots.get("ABOVE", [])
+        below = slots.get("BELOW", [])
+        contained = slots.get("CONTAINS", [])
+        if above and below:
+            base = rf"\frac{{{render_sequence(above, next_active)}}}{{{render_sequence(below, next_active)}}}"
+        elif contained and labels[index] in {r"\sqrt", r"\sqrt{}"}:
+            base = rf"\sqrt{{{render_sequence(contained, next_active)}}}"
+        else:
+            base = labels[index]
+        superscript = slots.get("SUPERSCRIPT", [])
+        subscript = slots.get("SUBSCRIPT", [])
+        if subscript:
+            base += rf"_{{{render_sequence(subscript, next_active)}}}"
+        if superscript:
+            base += rf"^{{{render_sequence(superscript, next_active)}}}"
+        return base
+
+    roots = [index for index in range(len(labels)) if index not in structural_children]
+    return render_sequence(roots, frozenset())

src/tray_joint.py

@@ -0,0 +1,393 @@
+"""OCR top-label과 Tray 슬롯 계약을 lattice candidate score로 변환한다."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from typing import Any, Sequence
+
+import numpy as np
+
+from .cross_visual import CrossVisualModel, cross_pair_feature_rows
+from .expression_contracts import horizontal_sides, segments_complete
+from .equality_visual import EqualityVisualModel, equality_pair_feature_rows
+from .math_tray import infer_math_trays
+from .segmentation_lattice import LATTICE_FEATURE_NAMES
+from .structure_relations import STRUCTURAL_RELATION_TYPES, infer_spatial_relations
+
+
+ANCHOR_TYPES = {
+    r"\sqrt": "ROOT", r"\sqrt{}": "ROOT",
+    r"\int": "INTEGRAL", r"\oint": "INTEGRAL", r"\iint": "INTEGRAL", r"\iiint": "INTEGRAL",
+    r"\sum": "LARGE_OPERATOR", r"\prod": "LARGE_OPERATOR", r"\lim": "LARGE_OPERATOR",
+}
+RELIABLE_MULTISTROKE = {"i", r"\pi", r"\rightarrow", r"\pm", r"\leq", r"\geq"}
+MULTISTROKE_FAMILY_LABELS = frozenset({
+    r"\sum", r"\Sigma", r"\pi", r"\Pi", r"\rightarrow", r"\shortrightarrow",
+    r"\longrightarrow", r"\Rightarrow", r"\neq",
+    r"\not\equiv", r"\pm",
+})
+MULTISTROKE_FAMILY_NAMES = frozenset({
+    r"\pi", r"\rightarrow", r"\shortrightarrow", r"\longrightarrow",
+    r"\Rightarrow", r"\neq", r"\not\equiv", r"\pm",
+})
+
+
+def _multistroke_family_geometry_guard(
+    label: str,
+    family: str,
+    feature_row: np.ndarray,
+) -> bool:
+    """필요 변수: 합친 OCR label/family·lattice geometry. 작동 원리: 완성 단일기호 열을 먹는 넓은 alias 후보를 차단한다."""
+
+    width_ref = float(feature_row[2])
+    height_ref = float(feature_row[3])
+    pair_gap_max = float(feature_row[12])
+    if label == r"\Sigma" and width_ref < 2.0:
+        return False
+    if (label == r"\pm" or family == r"\pm") and height_ref > 2.0:
+        return False
+    arrow_family = {
+        r"\rightarrow", r"\shortrightarrow", r"\longrightarrow", r"\Rightarrow",
+    }
+    if (label in arrow_family or family in arrow_family) and pair_gap_max > 0.50:
+        return False
+    return True
+
+
+@dataclass(frozen=True, slots=True)
+class TrayJointWeights:
+    """필요 변수: validation 선택 가중치. 작동 원리: 구조 보너스와 두 must-not-link 감점을 한 계약으로 고정한다."""
+
+    tray: float = 4.0
+    symbol: float = 4.0
+    fraction: float = 8.0
+    infix: float = 8.0
+    competition: float = 0.0
+    local_baseline: float = 0.0
+    group_bias: float = -2.0
+
+
+def component_competition_penalties(
+    candidates: Sequence[dict[str, Any]],
+    features: np.ndarray,
+    *,
+    mode: str = "joint",
+) -> np.ndarray:
+    """필요 변수: lattice 후보·OCR merge gain. 작동 원리: 합친 OCR이 구성획보다 약한 다획 후보에 must-not-link 값을 준다."""
+
+    if len(candidates) != len(features):
+        raise ValueError("component competition candidate/feature 수가 다릅니다.")
+    if mode not in {"top1", "joint"}:
+        raise ValueError(f"지원하지 않는 component competition mode입니다: {mode}")
+    merge_index = len(LATTICE_FEATURE_NAMES) + 6
+    entropy_index = len(LATTICE_FEATURE_NAMES) + 7
+    penalties = np.zeros(len(candidates), dtype=np.float32)
+    for index, candidate in enumerate(candidates):
+        if len(candidate["source_indices"]) <= 1:
+            continue
+        merge_gain = float(features[index][merge_index])
+        deficit = -merge_gain
+        if mode == "joint":
+            deficit -= 0.5 * float(features[index][entropy_index])
+        penalties[index] = min(1.0, max(0.0, deficit))
+    return penalties
+
+
+def _group_box(group: frozenset[int], strokes: Sequence[dict[str, Any]]) -> dict[str, float]:
+    """필요 변수: stroke group·좌표. 작동 원리: candidate와 context symbol의 bbox를 계산한다."""
+
+    points = [point for index in group for point in strokes[index]["points"]]
+    xs, ys = [float(point[0]) for point in points], [float(point[1]) for point in points]
+    return {"left": min(xs), "top": min(ys), "right": max(xs), "bottom": max(ys)}
+
+
+def _recognized_segment(box: dict[str, float], label: str, score: float, family: str = "") -> dict[str, Any]:
+    """필요 변수: 후보 bbox·top label/family·확률. 작동 원리: Tray와 부분식 parser용 최소 OCR segment를 만든다."""
+
+    return {"box": box, "results": {"expanded": {"candidates": [{
+        "label": label, "score": score, "visual_family": family,
+    }]}}}
+
+
+def local_baseline_boundary_penalties(
+    strokes: Sequence[dict[str, Any]],
+    candidates: Sequence[dict[str, Any]],
+    ocr_labels: Sequence[str],
+    features: np.ndarray,
+    base_partition: Sequence[frozenset[int]],
+    *,
+    ocr_families: Sequence[str] | None = None,
+) -> np.ndarray:
+    """필요 변수: 초기 partition·OCR segment·공간 관계. 작동 원리: 첨자·분수 등 구조 경계 양쪽을 동시에 먹는 병합만 감점한다."""
+
+    count = len(candidates)
+    if len(ocr_labels) != count or len(features) != count:
+        raise ValueError("local baseline candidate/label/feature 수가 다릅니다.")
+    families = list(ocr_families or [""] * count)
+    if len(families) != count:
+        raise ValueError("local baseline candidate/family 수가 다릅니다.")
+    index_by_group = {
+        frozenset(int(value) for value in candidate["source_indices"]): index
+        for index, candidate in enumerate(candidates)
+    }
+    partition_groups = [frozenset(group) for group in base_partition if frozenset(group) in index_by_group]
+    top1_index = len(LATTICE_FEATURE_NAMES)
+    segments = []
+    for group in partition_groups:
+        index = index_by_group[group]
+        segments.append(_recognized_segment(
+            _group_box(group, strokes), ocr_labels[index],
+            float(features[index][top1_index]), families[index],
+        ))
+    trays = infer_math_trays(segments)
+    relations = infer_spatial_relations(segments, trays=trays)
+    structural_edges = [
+        (
+            partition_groups[int(relation["parent"])],
+            partition_groups[int(relation["child"])],
+            float(relation["confidence"]),
+        )
+        for relation in relations
+        if str(relation["type"]) in STRUCTURAL_RELATION_TYPES
+    ]
+    penalties = np.zeros(count, dtype=np.float32)
+    for index, candidate in enumerate(candidates):
+        group = frozenset(int(value) for value in candidate["source_indices"])
+        if len(group) <= 1:
+            continue
+        penalties[index] = max(
+            (
+                confidence for parent, child, confidence in structural_edges
+                if group & parent and group & child
+            ),
+            default=0.0,
+        )
+    return penalties
+
+
+def _candidate_box(
+    candidate: dict[str, Any], group: frozenset[int], strokes: Sequence[dict[str, Any]],
+) -> dict[str, float]:
+    """필요 변수: lattice 후보·원 stroke. 작동 원리: cache bbox를 우선 재사용하고 최소 입력은 계산으로 호환한다."""
+
+    box = candidate.get("box")
+    return dict(box) if isinstance(box, dict) else _group_box(group, strokes)
+
+
+def _point_xy(point: Any) -> tuple[float, float]:
+    """필요 변수: 배열 또는 객체형 point. 작동 원리: 획 형태 계산용 좌표를 공통 형식으로 읽는다."""
+
+    if isinstance(point, dict):
+        return float(point.get("x", 0.0)), float(point.get("y", 0.0))
+    return float(point[0]), float(point[1])
+
+
+def _stroke_direction(stroke: dict[str, Any]) -> tuple[float, float]:
+    """필요 변수: 두 점 이상인 stroke. 작동 원리: 첫·끝점 벡터를 방향 정규화해 평행·교차 형태를 판정한다."""
+
+    points = stroke.get("points") or []
+    if len(points) < 2:
+        return 0.0, 0.0
+    start, end = _point_xy(points[0]), _point_xy(points[-1])
+    dx, dy = end[0] - start[0], end[1] - start[1]
+    length = math.hypot(dx, dy)
+    return (dx / length, dy / length) if length > 1e-6 else (0.0, 0.0)
+
+
+def _completed_operand_context_score(
+    group: frozenset[int], group_box: dict[str, float], context: Sequence[tuple[frozenset[int], dict[str, Any]]],
+) -> float:
+    """필요 변수: 중위 후보 bbox·초기 partition. 작동 원리: 좌변·우변이 모두 완료된 표현일 때만 구조 점수를 연다."""
+
+    usable = [(other_group, segment) for other_group, segment in context if not other_group & group]
+    left, right = horizontal_sides(group_box, usable)
+    return 1.0 if segments_complete(left) and segments_complete(right) else 0.0
+
+
+def _occupied_operand_context_score(
+    group: frozenset[int], group_box: dict[str, float], context: Sequence[tuple[frozenset[int], dict[str, Any]]],
+) -> float:
+    """필요 변수: 교차선 후보·현재 partition. 작동 원리: 곱셈은 OCR 문법을 강제하지 않고 같은 행의 양쪽 점유만 확인한다."""
+
+    usable = [(other_group, segment) for other_group, segment in context if not other_group & group]
+    left, right = horizontal_sides(group_box, usable)
+    return 1.0 if left and right else 0.0
+
+
+def _infix_shape_score(
+    group: frozenset[int], strokes: Sequence[dict[str, Any]], stroke_boxes: Sequence[dict[str, float]],
+) -> tuple[str, float]:
+    """필요 변수: 두 획 후보·사전 계산 bbox. 작동 원리: 평행선 equality와 교차선 multiply family를 분리해 반환한다."""
+
+    if len(group) != 2:
+        return "", 0.0
+    first_index, second_index = sorted(group)
+    first, second = strokes[first_index], strokes[second_index]
+    first_direction, second_direction = _stroke_direction(first), _stroke_direction(second)
+    horizontal = min(abs(first_direction[0]), abs(second_direction[0]))
+    vertical_leak = max(abs(first_direction[1]), abs(second_direction[1]))
+    first_box, second_box = stroke_boxes[first_index], stroke_boxes[second_index]
+    first_width = max(first_box["right"] - first_box["left"], 1e-6)
+    second_width = max(second_box["right"] - second_box["left"], 1e-6)
+    x_overlap = max(0.0, min(first_box["right"], second_box["right"]) - max(first_box["left"], second_box["left"]))
+    overlap_ratio = x_overlap / min(first_width, second_width)
+    length_ratio = min(first_width, second_width) / max(first_width, second_width)
+    first_y = (first_box["top"] + first_box["bottom"]) * 0.5
+    second_y = (second_box["top"] + second_box["bottom"]) * 0.5
+    separation_ratio = abs(first_y - second_y) / max((first_width + second_width) * 0.5, 1e-6)
+    parallel = abs(first_direction[0] * second_direction[0] + first_direction[1] * second_direction[1])
+    if (
+        horizontal >= 0.92 and vertical_leak <= 0.38 and parallel >= 0.94
+        and overlap_ratio >= 0.60 and length_ratio >= 0.60 and 0.04 <= separation_ratio <= 0.65
+    ):
+        return "equality", min(1.0, 0.35 + 0.25 * overlap_ratio + 0.20 * length_ratio + 0.20 * parallel)
+
+    diagonal = min(abs(first_direction[0] * first_direction[1]), abs(second_direction[0] * second_direction[1])) * 2.0
+    opposite_slopes = first_direction[0] * first_direction[1] * second_direction[0] * second_direction[1] < 0.0
+    x_intersects = max(first_box["left"], second_box["left"]) <= min(first_box["right"], second_box["right"])
+    y_intersects = max(first_box["top"], second_box["top"]) <= min(first_box["bottom"], second_box["bottom"])
+    if opposite_slopes and x_intersects and y_intersects and diagonal >= 0.55:
+        return "multiply", min(1.0, diagonal)
+    return "", 0.0
+
+
+def candidate_signals(
+    strokes: Sequence[dict[str, Any]], candidates: Sequence[dict[str, Any]],
+    ocr_labels: Sequence[str], features: np.ndarray, base_partition: Sequence[frozenset[int]],
+    *, ocr_families: Sequence[str] | None = None, strict_equality: bool = False,
+    equality_model: EqualityVisualModel | None = None, cross_model: CrossVisualModel | None = None,
+    cross_gap_ratio: float = 0.40,
+    multistroke_family_boost: float = 6.0,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """필요 변수: 원 stroke·후보/label/feature·cross/family 설정. 작동 원리: Tray·신뢰 label·중위식 evidence를 계산한다."""
+
+    count = len(candidates)
+    if len(ocr_labels) != count or len(features) != count:
+        raise ValueError("Tray joint candidate/label/feature 수가 다릅니다.")
+    if cross_gap_ratio < 0.0:
+        raise ValueError("cross gap ratio는 0 이상이어야 합니다.")
+    if multistroke_family_boost < 0.0:
+        raise ValueError("multistroke family boost는 0 이상이어야 합니다.")
+    families = list(ocr_families or [""] * count)
+    if len(families) != count:
+        raise ValueError("Tray joint candidate/family 수가 다릅니다.")
+    tray_signal = np.zeros(count, dtype=np.float32)
+    symbol_signal = np.zeros(count, dtype=np.float32)
+    infix_signal = np.zeros(count, dtype=np.float32)
+    top1 = features[:, len(LATTICE_FEATURE_NAMES)]
+    stroke_boxes = [_group_box(frozenset({index}), strokes) for index in range(len(strokes))]
+    index_by_group = {
+        frozenset(int(value) for value in candidate["source_indices"]): index
+        for index, candidate in enumerate(candidates)
+    }
+    pair_groups = [
+        frozenset(int(value) for value in candidate["source_indices"])
+        for candidate in candidates if len(candidate["source_indices"]) == 2
+    ]
+    equality_probability: dict[frozenset[int], float] = {}
+    cross_probability: dict[frozenset[int], float] = {}
+    if equality_model is not None and pair_groups:
+        ordered_pairs = [tuple(sorted(group)) for group in pair_groups]
+        pair_rows = equality_pair_feature_rows(ordered_pairs, strokes)
+        equality_probability = {
+            group: equality_model.probability(row) for group, row in zip(pair_groups, pair_rows, strict=True)
+        }
+    if cross_model is not None and pair_groups:
+        nonzero_heights = [box["bottom"] - box["top"] for box in stroke_boxes if box["bottom"] - box["top"] > 1e-5]
+        reference = float(np.median(nonzero_heights)) if nonzero_heights else 1.0
+        plausible_groups = []
+        for group in pair_groups:
+            first_index, second_index = sorted(group)
+            first_box, second_box = stroke_boxes[first_index], stroke_boxes[second_index]
+            x_gap = max(first_box["left"] - second_box["right"], second_box["left"] - first_box["right"], 0.0)
+            y_gap = max(first_box["top"] - second_box["bottom"], second_box["top"] - first_box["bottom"], 0.0)
+            if x_gap <= reference * cross_gap_ratio and y_gap <= reference * cross_gap_ratio:
+                plausible_groups.append(group)
+        ordered_pairs = [tuple(sorted(group)) for group in plausible_groups]
+        pair_rows = cross_pair_feature_rows(ordered_pairs, strokes)
+        cross_probability = {
+            group: cross_model.probability(row) for group, row in zip(plausible_groups, pair_rows, strict=True)
+        }
+    context = [
+        (
+            group,
+            _recognized_segment(
+                _candidate_box(candidates[index_by_group[group]], group, strokes),
+                ocr_labels[index_by_group[group]], float(top1[index_by_group[group]]), families[index_by_group[group]],
+            ),
+        )
+        for group in base_partition
+    ]
+    for index, candidate in enumerate(candidates):
+        group = frozenset(int(value) for value in candidate["source_indices"])
+        label = ocr_labels[index]
+        group_box = _candidate_box(candidate, group, strokes)
+        shape_family, shape_score = _infix_shape_score(group, strokes, stroke_boxes)
+        learned_equality = equality_probability.get(group, 0.0)
+        learned_cross = cross_probability.get(group, 0.0)
+        if equality_model is not None and learned_equality >= equality_model.threshold:
+            shape_family, shape_score = "equality", learned_equality
+        if cross_model is not None and learned_cross >= cross_model.threshold and learned_cross > learned_equality:
+            # threshold 직상단의 불확실한 pair가 큰 병합 보너스를 받지 않도록 초과 margin만 사용한다.
+            margin = (learned_cross - cross_model.threshold) / max(1.0 - cross_model.threshold, 1e-6)
+            shape_family, shape_score = "cross_visual", min(1.0, max(0.0, margin))
+        if shape_family == "equality":
+            # 등호 인식은 수식 완성 여부와 독립적이다. parser는 shadow 분석에서만 gating한다.
+            context_score = _completed_operand_context_score(group, group_box, context) if strict_equality else 1.0
+        elif shape_family == "cross_visual":
+            context_score = 1.0
+        else:
+            context_score = _occupied_operand_context_score(group, group_box, context)
+        infix_signal[index] = shape_score * context_score
+        if len(group) > 1:
+            if label in RELIABLE_MULTISTROKE:
+                symbol_signal[index] = float(top1[index])
+            if (
+                label in MULTISTROKE_FAMILY_LABELS
+                or families[index] in MULTISTROKE_FAMILY_NAMES
+            ) and _multistroke_family_geometry_guard(
+                label, families[index], features[index],
+            ):
+                # 합친 OCR family가 이미 살아 있을 때만 추가한다. 인접 획이라는 이유만으로 병합하지 않는다.
+                symbol_signal[index] += float(top1[index]) * multistroke_family_boost
+        tray_type = ANCHOR_TYPES.get(label)
+        if tray_type is None:
+            continue
+        anchor = _recognized_segment(_group_box(group, strokes), label, float(top1[index]), families[index])
+        segments = [anchor, *(segment for other_group, segment in context if not other_group & group)]
+        matches = (
+            tray for tray in infer_math_trays(segments)
+            if tray["anchor"] == 0 and tray["type"] == tray_type and tray["required_satisfied"]
+        )
+        tray_signal[index] = max((float(tray["constraint_score"]) for tray in matches), default=0.0)
+    return tray_signal, symbol_signal, infix_signal
+
+
+def adjusted_logits(
+    base_logits: np.ndarray, tray_signal: np.ndarray, symbol_signal: np.ndarray,
+    fraction_penalty: np.ndarray, weights: TrayJointWeights, infix_signal: np.ndarray | None = None,
+    competition_penalty: np.ndarray | None = None,
+    local_baseline_penalty: np.ndarray | None = None,
+) -> np.ndarray:
+    """필요 변수: base logit·구조 signal·세 penalty. 작동 원리: joint selector 목적함수의 candidate logit을 만든다."""
+
+    effective_infix = np.zeros_like(base_logits) if infix_signal is None else infix_signal
+    effective_competition = (
+        np.zeros_like(base_logits) if competition_penalty is None else competition_penalty
+    )
+    effective_local_baseline = (
+        np.zeros_like(base_logits) if local_baseline_penalty is None else local_baseline_penalty
+    )
+    arrays = (
+        base_logits, tray_signal, symbol_signal, fraction_penalty,
+        effective_infix, effective_competition, effective_local_baseline,
+    )
+    if len({len(values) for values in arrays}) != 1:
+        raise ValueError("Tray joint logit과 signal 길이가 다릅니다.")
+    return (
+        base_logits + weights.tray * tray_signal + weights.symbol * symbol_signal
+        + weights.infix * effective_infix - weights.fraction * fraction_penalty
+        - weights.competition * effective_competition
+        - weights.local_baseline * effective_local_baseline
+    )