Add fail-closed P formula student distillation path

MANIFEST.json

@@ -1,11 +1,11 @@
-{
-    "schema":  "aiflow-hf-research-snapshot-v18",
-    "generated_at":  "2026-07-23T21:57:32.2523498Z",
+{
+    "schema":  "aiflow-hf-research-snapshot-v19",
+    "generated_at":  "2026-07-23T22:08:08.2837334Z",
     "track":  "R_noncommercial_plus_rejected_P_proxy",
     "product_validation":  false,
     "public_release":  true,
     "contains_raw_dataset":  false,
-    "tests":  "312 passed",
+    "tests":  "318 passed",
     "retracted_paths":  [
                             "models/auxiliary/boundary_auxiliary_head.pt",
                             "models/auxiliary/seed17/boundary_joint_delta.pt",
@@ -13,15 +13,25 @@
                             "models/auxiliary/seed47/boundary_joint_delta.pt"
                         ],
     "files":  [
+                  {
+                      "path":  "scripts/audit_math_ink_06_local_baseline_overmerge.py",
+                      "bytes":  11900,
+                      "sha256":  "f32a18c8e7d3a0ea36379293e6be88bfb509b7df99846c38149fb8458e6cc994"
+                  },
+                  {
+                      "path":  "scripts/audit_math_ink_06_online_error_consensus.py",
+                      "bytes":  12174,
+                      "sha256":  "c562a8d0300aa358f9c3faaed274992c3548224347e1e875401eec93953d0807"
+                  },
                   {
                       "path":  "scripts/audit_math_ink_06_formula_context_contract.py",
                       "bytes":  12602,
                       "sha256":  "1a81c46465958e2ae5f8f8ef1c09d7cf664e6ecb951d7706db5ccce4084d4220"
                   },
                   {
-                      "path":  "scripts/audit_math_ink_06_local_baseline_overmerge.py",
-                      "bytes":  11900,
-                      "sha256":  "f32a18c8e7d3a0ea36379293e6be88bfb509b7df99846c38149fb8458e6cc994"
+                      "path":  "reports/RESEARCH_REPORT.md",
+                      "bytes":  49820,
+                      "sha256":  "d275203b0a1c094fbb6d8977a2f6d658998e67fe0794f1f012566fe68f3014a2"
                   },
                   {
                       "path":  "scripts/audit_math_ink_06_behavior_exact_gate.py",
@@ -29,19 +39,19 @@
                       "sha256":  "79feee00110eebb9429c1577df43e8747831cec897b0955e64dc5b5c5da1a018"
                   },
                   {
-                      "path":  "reports/p_proxy_shift_seed17.json",
-                      "bytes":  10788,
-                      "sha256":  "a2dac8be7a0fadf58a11e2c2d737ac6876e8d89310570ce0159d1b593039a99a"
+                      "path":  "scripts/audit_math_ink_06_p_proxy_shift.py",
+                      "bytes":  9362,
+                      "sha256":  "f34ca3b9809eeea06a1557073cae89f31ec58dcb7ecb9073517b4730f4311686"
                   },
                   {
-                      "path":  "reports/RESEARCH_REPORT.md",
-                      "bytes":  48108,
-                      "sha256":  "36e77b969c1b32e4b3d94a8f172331754907d116fd58d7c0110e3bcd46aa0093"
+                      "path":  "scripts/distill_math_ink_06_p_formula_student.py",
+                      "bytes":  21388,
+                      "sha256":  "6596f9a4114431dad97d64616c24ddec6a37c3de934562b7438e4fc900ad080f"
                   },
                   {
-                      "path":  "scripts/audit_math_ink_06_online_error_consensus.py",
-                      "bytes":  12174,
-                      "sha256":  "c562a8d0300aa358f9c3faaed274992c3548224347e1e875401eec93953d0807"
+                      "path":  "scripts/evaluate_crohme_tray_joint_selector.py",
+                      "bytes":  11671,
+                      "sha256":  "58c175a95cdeb9fc764fb96594a76888122b8f118f2f26da1283e743b1a7cd04"
                   },
                   {
                       "path":  "scripts/calibrate_math_ink_06_online_family_fusion.py",
@@ -49,9 +59,9 @@
                       "sha256":  "535c2b6197148fada9a1762f2c6db9a494e89b703a9e60b913348b7c7ffdc056"
                   },
                   {
-                      "path":  "scripts/evaluate_crohme_tray_joint_selector.py",
-                      "bytes":  11671,
-                      "sha256":  "58c175a95cdeb9fc764fb96594a76888122b8f118f2f26da1283e743b1a7cd04"
+                      "path":  "scripts/benchmark_math_ink_06_composite.py",
+                      "bytes":  7618,
+                      "sha256":  "6c5347fe68114116e0dfd29e55e3682f47b3ce42af1412009ab7883e2076887c"
                   },
                   {
                       "path":  "scripts/build_math_ink_06_litert_colab_bundle.py",
@@ -59,19 +69,19 @@
                       "sha256":  "f008635ab59344005f65f1394f56275e4c92610cd25781a2d95243d060010718"
                   },
                   {
-                      "path":  "scripts/audit_math_ink_06_p_proxy_shift.py",
-                      "bytes":  9362,
-                      "sha256":  "f34ca3b9809eeea06a1557073cae89f31ec58dcb7ecb9073517b4730f4311686"
+                      "path":  "reports/p_proxy_shift_seed17.json",
+                      "bytes":  10788,
+                      "sha256":  "a2dac8be7a0fadf58a11e2c2d737ac6876e8d89310570ce0159d1b593039a99a"
                   },
                   {
-                      "path":  "scripts/benchmark_math_ink_06_composite.py",
-                      "bytes":  7618,
-                      "sha256":  "6c5347fe68114116e0dfd29e55e3682f47b3ce42af1412009ab7883e2076887c"
+                      "path":  "reports/online_error_consensus_paired_test_3seed.json",
+                      "bytes":  12267,
+                      "sha256":  "ec624e9c96d7fa767b438ca2d555b5b0930edc0b80716ee740229ae894711f52"
                   },
                   {
-                      "path":  "reports/p_boundary_joint_sharedfix_3seed_summary.json",
-                      "bytes":  3056,
-                      "sha256":  "1ad9192d45218d4644f69a8f076487bd5fb36d5c2348f5225ee4ae06e9f4b127"
+                      "path":  "reports/online_family_fusion_calibration_3seed.json",
+                      "bytes":  2861,
+                      "sha256":  "50b06e65e9220639c68a2686c4b123697e3f4f8411755b9d9e9222e7f39f3042"
                   },
                   {
                       "path":  "reports/online_casecontext_seed47.json",
@@ -79,9 +89,9 @@
                       "sha256":  "c3dfd328d9ff0a55eed2cb74657ad87e5e164968fddd7fae8c8fd92e137a4557"
                   },
                   {
-                      "path":  "reports/online_error_consensus_paired_test_3seed.json",
-                      "bytes":  12267,
-                      "sha256":  "ec624e9c96d7fa767b438ca2d555b5b0930edc0b80716ee740229ae894711f52"
+                      "path":  "reports/online_casecontext_seed17.json",
+                      "bytes":  33805,
+                      "sha256":  "050c00c14df4712f55b0c76118dd11615b9129b078d56bd987e329c9edee1bda"
                   },
                   {
                       "path":  "reports/online_casecontext_seed31.json",
@@ -89,19 +99,19 @@
                       "sha256":  "30e6ca83aa4c04d1d257b0221fea7ac726f8e09e91906fdecbc12a2bd4d4d34b"
                   },
                   {
-                      "path":  "reports/multistroke_family_guard_report.json",
-                      "bytes":  15740,
-                      "sha256":  "27b31da71b9f39f7ded38aa1ce3694911af140d22854543d4ae2b5f9e709b479"
+                      "path":  "reports/p_boundary_auxiliary_smoke.json",
+                      "bytes":  16685,
+                      "sha256":  "9d250e5c75d4f104971551c07a702810bf94fb5b6e5e587035a624933766356e"
                   },
                   {
-                      "path":  "reports/online_casecontext_seed17.json",
-                      "bytes":  33805,
-                      "sha256":  "050c00c14df4712f55b0c76118dd11615b9129b078d56bd987e329c9edee1bda"
+                      "path":  "reports/p_boundary_joint_seed47.json",
+                      "bytes":  6809,
+                      "sha256":  "fd4ddcf71209cf59443e7a252a8337d7812ff66fae9482867f6eb0a21666e064"
                   },
                   {
-                      "path":  "reports/online_family_fusion_calibration_3seed.json",
-                      "bytes":  2861,
-                      "sha256":  "50b06e65e9220639c68a2686c4b123697e3f4f8411755b9d9e9222e7f39f3042"
+                      "path":  "reports/p_boundary_joint_sharedfix_3seed_summary.json",
+                      "bytes":  3056,
+                      "sha256":  "1ad9192d45218d4644f69a8f076487bd5fb36d5c2348f5225ee4ae06e9f4b127"
                   },
                   {
                       "path":  "reports/p_boundary_joint_seed31.json",
@@ -109,25 +119,15 @@
                       "sha256":  "4f842852093ca46b1942c942fd5e475ca6c19f044ba9e27b6d372f1aed56056e"
                   },
                   {
-                      "path":  "reports/p_boundary_joint_seed47.json",
-                      "bytes":  6809,
-                      "sha256":  "fd4ddcf71209cf59443e7a252a8337d7812ff66fae9482867f6eb0a21666e064"
+                      "path":  "reports/p_boundary_device_stress_sharedfix_3seed.json",
+                      "bytes":  10867,
+                      "sha256":  "3cad0c0e6aed77ebf2bd19a915fc3d898beb87d7b8a5e5ab29f2013b4184826e"
                   },
                   {
                       "path":  "reports/p_boundary_joint_seed17.json",
                       "bytes":  6920,
                       "sha256":  "7af3bb995041e5ea621d3c9535f3552e264860f12a7e6145637849f5cd0220a8"
                   },
-                  {
-                      "path":  "reports/p_boundary_auxiliary_smoke.json",
-                      "bytes":  16685,
-                      "sha256":  "9d250e5c75d4f104971551c07a702810bf94fb5b6e5e587035a624933766356e"
-                  },
-                  {
-                      "path":  "reports/p_boundary_device_stress_sharedfix_3seed.json",
-                      "bytes":  10867,
-                      "sha256":  "3cad0c0e6aed77ebf2bd19a915fc3d898beb87d7b8a5e5ab29f2013b4184826e"
-                  },
                   {
                       "path":  "src/ink06_export.py",
                       "bytes":  5348,
@@ -140,8 +140,8 @@
                   },
                   {
                       "path":  "scripts/train_math_ink_06_p_formula_adapter.py",
-                      "bytes":  14992,
-                      "sha256":  "faa7c8590a8202e98915c91c2fe1d206d69940a50a6e1e0d62b10487d6b6d84b"
+                      "bytes":  15489,
+                      "sha256":  "6aac2058f6cc69a577f59ab5e4746fe910e2595f11ecd7f1a72339330db8da8e"
                   },
                   {
                       "path":  "scripts/train_math_ink_06_p_boundary_auxiliary.py",
@@ -235,14 +235,19 @@
                   },
                   {
                       "path":  "scripts/summarize_math_ink_06_p_formula_seeds.py",
-                      "bytes":  4334,
-                      "sha256":  "837e026990ac4b96cac4e75689f5eabc98ba009ab0b3050841d8b603a0eaab10"
+                      "bytes":  4633,
+                      "sha256":  "fe4658a877489398c4f31fd8dfe76aecac34d13443fdc356587c6e6999e6ac73"
                   },
                   {
                       "path":  "scripts/sweep_math_ink_06_component_competition_guard.py",
                       "bytes":  9084,
                       "sha256":  "e2dee616e2c6ebdc32281624889017685648b7076515242e04a1452d98d1c7da"
                   },
+                  {
+                      "path":  "reports/multistroke_family_guard_report.json",
+                      "bytes":  15740,
+                      "sha256":  "27b31da71b9f39f7ded38aa1ce3694911af140d22854543d4ae2b5f9e709b479"
+                  },
                   {
                       "path":  "exports/seed17/export_manifest.json",
                       "bytes":  1069,
@@ -260,8 +265,8 @@
                   },
                   {
                       "path":  "configs/MATH-INK-06-P-FORMULA-v1.json",
-                      "bytes":  1446,
-                      "sha256":  "061d7c00288f8f063c65e8642a2ca958998c3f95d157f6f4fc5b6cdc252da227"
+                      "bytes":  1985,
+                      "sha256":  "4d365d18ef92ad01c4dccc26c37e8752a239cfb19ad9ec3387af65f1936ce0d2"
                   },
                   {
                       "path":  "contracts/aiflow_p_formula_annotation_v1.schema.json",
@@ -310,8 +315,8 @@
                   },
                   {
                       "path":  "README.md",
-                      "bytes":  18954,
-                      "sha256":  "b8b3f72ac9cb861aa68e3a86963a7bbc64d8e5111614bc517b3fd22a5f60f19d"
+                      "bytes":  19979,
+                      "sha256":  "0d3376547a35761c1004811d4dc76c654bb46f282ba0906ba0b3411e6599964f"
                   },
                   {
                       "path":  "NOTICE.md",
@@ -325,8 +330,8 @@
                   },
                   {
                       "path":  "MODEL_INDEX.json",
-                      "bytes":  6934,
-                      "sha256":  "d5472a63cf10a9161088dc9912fc085f8794f337a45e7183ce438dfdab1e25af"
+                      "bytes":  7349,
+                      "sha256":  "7272a5e11b08e391698fd68b88fb04da5e35b9665d6131d272dee923a086c535"
                   },
                   {
                       "path":  "artifacts/boundary_behavior_guard.joblib",
@@ -474,4 +479,4 @@
                       "sha256":  "7b0890e13164f170be02f519e3ffc56930486e2018cde050434286f769bfce83"
                   }
               ]
-}
+}

MODEL_INDEX.json

@@ -157,6 +157,7 @@
     "dataset": "src/p_formula_dataset06.py",
     "trainer": "scripts/train_math_ink_06_p_formula_adapter.py",
     "three_seed_summary": "scripts/summarize_math_ink_06_p_formula_seeds.py",
+    "student_distiller": "scripts/distill_math_ink_06_p_formula_student.py",
     "recipe": "configs/MATH-INK-06-P-FORMULA-v1.json",
     "seeds": [17, 31, 47],
     "formula_adapter_hidden_size": 64,
@@ -170,6 +171,15 @@
       "missing_metadata_drop_maximum_pp": 3.0
     },
     "student_distillation_requires_all_seeds": true,
+    "same_data_sha256_required_across_seeds": true,
+    "distillation": {
+      "teacher_probability_temperature": 2.0,
+      "teacher_weights_embedded": false,
+      "maximum_teacher_to_student_regression_pp": 1.0,
+      "cuda_fixture_path_passed": true,
+      "fixture_release_gate_passed": false,
+      "litert_exported": false
+    },
     "teacher_ensemble_mobile_deployment_allowed": false,
     "fixture_smoke_passed": true,
     "real_p_training_completed": false,

README.md

@@ -302,10 +302,16 @@ inverse-sqrt(source frequency × exact-label frequency) sampler
 validation-only checkpoint selection
 ```
 
-각 seed는 test exact top-1 92%, top-5 99%, macro-F1 90%, writer floor 75%, 결측 metadata slice 하락 3%p 이하를 모두 통과해야 한다. Seed 17·31·47이 개별 통과한 경우에만 single mobile student distillation을 허용한다. Teacher ensemble 자체는 기기에 탑재하지 않는다.
+각 seed는 test exact top-1 92%, top-5 99%, macro-F1 90%, writer floor 75%, 결측 metadata slice 하락 3%p 이하를 모두 통과해야 한다. Seed 17·31·47이 개별 통과하고 세 run의 원본 P Formula JSONL SHA-256이 정확히 같은 경우에만 single mobile student distillation을 허용한다. Teacher ensemble 자체는 기기에 탑재하지 않는다.
 
 실제 seed-17 composite와 GTX 1650을 사용한 1-epoch fixture smoke에서 CUDA 학습부터 report/checkpoint 생성까지 통과했다. Fixture checkpoint는 성능 근거가 아니므로 이 공개 저장소에 포함하지 않았다. 고정 recipe는 [`configs/MATH-INK-06-P-FORMULA-v1.json`](configs/MATH-INK-06-P-FORMULA-v1.json)에 있다.
 
+### Single-student distillation
+
+통과한 세 teacher는 base → shared online adapter → P formula adapter 순서로 합성한다. Temperature 2.0의 exact/family 확률을 seed 사이에서 평균하고 KL + hard-label CE로 hidden-64 formula adapter 하나만 학습한다. Student checkpoint에는 teacher weight를 포함하지 않는다.
+
+Student는 자체 92/99·macro-F1·writer/missing gate뿐 아니라 teacher ensemble 대비 exact top-1·top-5·visual-family 하락 1%p 이하를 모두 만족해야 한다. 2/2/2-symbol fixture의 3-teacher→student CUDA 실행 경로는 통과했지만 정식 student gate는 실패했다. Fixture와 checkpoint는 이 공개 저장소에 없으며, 실제 P 데이터 성능이나 제품 검증을 뜻하지 않는다. LiteRT 변환도 아직 수행하지 않았다.
+
 ## 알려진 한계
 
 - 378-label paired writer/device-disjoint top-1 목표 92%에 아직 미달한다.
@@ -356,4 +362,5 @@ PyTorch checkpoint와 joblib/pickle은 신뢰할 수 없는 출처에서 로드
 - 실제 P formula schema: [`contracts/aiflow_p_formula_v1.schema.json`](contracts/aiflow_p_formula_v1.schema.json)
 - P formula 사람 annotation schema: [`contracts/aiflow_p_formula_annotation_v1.schema.json`](contracts/aiflow_p_formula_annotation_v1.schema.json)
 - P-only formula 학습 recipe: [`configs/MATH-INK-06-P-FORMULA-v1.json`](configs/MATH-INK-06-P-FORMULA-v1.json)
+- P-only formula student distiller: [`scripts/distill_math_ink_06_p_formula_student.py`](scripts/distill_math_ink_06_p_formula_student.py)
 - 파일 checksum: [`MANIFEST.json`](MANIFEST.json)

configs/MATH-INK-06-P-FORMULA-v1.json

@@ -7,6 +7,7 @@
     "commercial_training_allowed": true,
     "minimum_independent_sources": 2,
     "required_splits": ["training", "validation", "test"],
+    "same_data_sha256_required_across_seeds": true,
     "identity_overlap_required": {
       "origin_id": 0,
       "writer_id": 0,
@@ -48,5 +49,20 @@
     "student_distillation_allowed_after_pass": true,
     "product_validation": false,
     "next_gate": "LiteRT parity and Android low/mid/high tier benchmark"
+  },
+  "distillation": {
+    "teacher_ensemble": "probability_mean",
+    "temperature": 2.0,
+    "teacher_exact_weight": 0.7,
+    "teacher_family_weight": 1.0,
+    "hard_exact_weight": 0.2,
+    "hard_family_weight": 0.5,
+    "student_seed": 17,
+    "student_formula_adapter_hidden_size": 64,
+    "teacher_weights_embedded": false,
+    "maximum_teacher_to_student_regression_pp": 1.0,
+    "student_must_pass_seed_gate": true,
+    "litert_exported": false,
+    "product_validation": false
   }
 }

reports/RESEARCH_REPORT.md

@@ -519,13 +519,24 @@ Materialize된 P Formula v1을 별도 가공 없이 소비하는 GPU trainer와
 - writer floor ≥75%
 - timestamp·pressure 결측 slice 하락 ≤3%p
 
-Seed 17·31·47 report가 정확히 하나씩 있고 모두 개별 gate를 통과한 경우에만 single mobile student distillation을 허용한다. Teacher ensemble 자체의 모바일 탑재는 항상 금지하며, 세 seed가 통과해도 LiteRT parity와 Android 3-tier gate 전까지 `product_validation=false`다.
+Seed 17·31·47 report가 정확히 하나씩 있고 모두 개별 gate를 통과한 경우에만 single mobile student distillation을 허용한다. 세 run의 원본 P Formula JSONL byte-level SHA-256도 반드시 같아야 하며, 빈 fingerprint나 서로 다른 corpus는 요약 단계에서 거부한다. Teacher ensemble 자체의 모바일 탑재는 항상 금지하며, 세 seed가 통과해도 LiteRT parity와 Android 3-tier gate 전까지 `product_validation=false`다.
 
 실제 seed-17 composite와 GTX 1650에서 2/2/2-symbol P fixture로 1-epoch end-to-end smoke를 실행했다. CUDA 학습, validation selection, test metric, 결측 slice, checkpoint/report 생성이 완료됐다. 극소 fixture의 seed gate는 예상대로 실패했고 checkpoint는 프로젝트 산출물·공개본에 포함하지 않았다. 이는 실행 계약 증거이며 성능 근거가 아니다.
 
+### 3-teacher 확률 증류·단일 모바일 student
+
+세 seed가 동일 P corpus의 개별 gate를 통과한 뒤 실행되는 fail-closed distiller를 추가했다. 각 teacher는 base → shared online adapter → P formula adapter 순서로 합성하며, exact vocabulary와 data SHA-256을 다시 대조한다. Temperature 2.0에서 seed별 softmax 확률을 평균하고 exact/family KL과 hard-label CE를 함께 사용해 hidden-64 formula adapter 하나만 학습한다.
+
+Student는 validation visual-family/exact 순서로 한 번 선택하고 test에 한 번만 적용한다. 최종 checkpoint는 teacher weight를 포함하지 않으며 다음 두 조건을 모두 요구한다.
+
+- student 자체 P seed gate: exact top-1 92%, top-5 99%, macro-F1 90%, writer floor 75%, 결측 slice 하락 3%p 이하
+- teacher 확률 ensemble 대비 exact top-1·top-5·visual-family 하락 각각 1%p 이하
+
+동일 2/2/2-symbol fixture를 seed 17·31·47로 각각 학습하고 요약한 뒤 GTX 1650에서 student까지 CUDA smoke를 완료했다. Data fingerprint·teacher load order·probability ensemble·student checkpoint/report 생성은 통과했다. 극소 fixture의 정식 student gate는 예상대로 실패했으며 checkpoint는 `D:\AiflowTools` 격리 경로에만 남고 프로젝트·공개 저장소에는 포함하지 않는다. `litert_exported=false`, `product_validation=false`이며 실제 P 성능 근거가 아니다.
+
 고정 recipe는 `research/configs/MATH-INK-06-P-FORMULA-v1.json`에 저장했다.
 
-전체 회귀는 312개가 통과했다.
+전체 회귀는 318개가 통과했다.
 
 ## 산출물
 
@@ -562,12 +573,14 @@ Seed 17·31·47 report가 정확히 하나씩 있고 모두 개별 gate를 통
 - `scripts/materialize_math_ink_06_p_formula.py`
 - `scripts/train_math_ink_06_p_formula_adapter.py`
 - `scripts/summarize_math_ink_06_p_formula_seeds.py`
+- `scripts/distill_math_ink_06_p_formula_student.py`
 - `scripts/preflight_math_ink_06_p_formula.py`
 - `scripts/analyze_crohme_lattice_failures.py`
 - `tests/test_behavior_context06.py`
 - `tests/test_behavior_role_head06.py`
 - `tests/test_p_formula_gate06.py`
 - `tests/test_p_formula_intake06.py`
+- `tests/test_distill_math_ink_06_p_formula_student.py`
 - `src/math_grid_drawer/research/p_formula_intake06.py`
 - `src/math_grid_drawer/research/p_formula_dataset06.py`
 - `research/contracts/aiflow_p_formula_v1.schema.json`

scripts/distill_math_ink_06_p_formula_student.py

@@ -0,0 +1,552 @@
+"""통과한 P Formula 3-seed teacher를 하나의 모바일 formula-adapter student로 증류한다."""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+from copy import deepcopy
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import random
+import sys
+from typing import Any, Sequence
+
+import numpy as np
+import torch
+from torch import Tensor
+from torch.utils.data import DataLoader, TensorDataset, WeightedRandomSampler
+
+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.external_corpus import read_jsonl
+from math_grid_drawer.research.p_formula_dataset06 import (
+    PFormulaTensorBatch06,
+    materialize_p_formula_split06,
+    p_formula_release_metrics06,
+    p_formula_seed_gate06,
+)
+from math_grid_drawer.research.p_formula_gate06 import audit_p_formula_records06
+from math_grid_drawer.research.skeleton_adapter06 import SkeletonTrajectoryAdapter06
+from scripts.audit_math_ink_06_case_context import _load_model06
+from scripts.train_math_ink_06_formula_adapter import _forward06, _targets06
+from scripts.train_math_ink_06_p_formula_adapter import _file_sha25606
+
+
+REQUIRED_SEEDS06 = frozenset({17, 31, 47})
+
+
+def validate_p_formula_distillation_inputs06(
+    summary: dict[str, Any],
+    reports: Sequence[dict[str, Any]],
+    *,
+    data_sha256: str,
+) -> list[dict[str, Any]]:
+    """필요 변수: 3-seed summary·teacher report·현재 data hash. 작동 원리: 동일 P corpus와 전 seed 통과를 AND로 검증한다."""
+
+    if summary.get("track") != "P_approved_formula_only":
+        raise ValueError("P Formula distillation에는 P-track summary만 허용합니다.")
+    decision = summary.get("decision") or {}
+    if decision.get("student_distillation_allowed") is not True:
+        raise ValueError("3-seed summary가 student distillation을 허용하지 않았습니다.")
+    if str(summary.get("data_sha256") or "") != data_sha256:
+        raise ValueError("현재 P Formula data SHA-256이 3-seed summary와 다릅니다.")
+    if len(reports) != 3 or {int(report["seed"]) for report in reports} != REQUIRED_SEEDS06:
+        raise ValueError("Teacher report는 seed 17·31·47이 정확히 하나씩 필요합니다.")
+    ordered = sorted(reports, key=lambda report: int(report["seed"]))
+    for report in ordered:
+        if report.get("track") != "P_approved_formula_only":
+            raise ValueError("R-track teacher를 P student에 증류할 수 없습니다.")
+        if str(report.get("data_sha256") or "") != data_sha256:
+            raise ValueError("Teacher report의 P Formula data SHA-256이 다릅니다.")
+        if report.get("seed_gate", {}).get("passed") is not True:
+            raise ValueError(f"seed {report['seed']} teacher가 개별 release gate를 통과하지 않았습니다.")
+    return ordered
+
+
+def ensemble_teacher_probability06(
+    logits: Sequence[Tensor],
+    *,
+    temperature: float,
+) -> Tensor:
+    """필요 변수: seed별 동일 shape logits·temperature. 작동 원리: logit 평균 대신 확률 평균으로 teacher target을 만든다."""
+
+    if not logits or temperature <= 0.0:
+        raise ValueError("Teacher logit과 양수 temperature가 필요합니다.")
+    shape = logits[0].shape
+    if any(value.shape != shape for value in logits):
+        raise ValueError("Teacher logit shape가 서로 다릅니다.")
+    return torch.stack([
+        (value / temperature).softmax(dim=1)
+        for value in logits
+    ]).mean(dim=0)
+
+
+def _parse_args() -> argparse.Namespace:
+    """필요 변수: P corpus·teacher reports/summary·student main adapter. 작동 원리: fail-closed distillation CLI를 만든다."""
+
+    parser = argparse.ArgumentParser(description="Distill Math Ink 0.6 P formula student")
+    parser.add_argument("--data", type=Path, required=True)
+    parser.add_argument("--teacher-report", type=Path, action="append", required=True)
+    parser.add_argument("--summary", type=Path, required=True)
+    parser.add_argument("--student-adapter", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--seed", type=int, default=17)
+    parser.add_argument("--epochs", type=int, default=20)
+    parser.add_argument("--batch-size", type=int, default=128)
+    parser.add_argument("--learning-rate", type=float, default=4e-4)
+    parser.add_argument("--weight-decay", type=float, default=2e-3)
+    parser.add_argument("--hidden-size", type=int, default=64)
+    parser.add_argument("--temperature", type=float, default=2.0)
+    parser.add_argument("--teacher-exact-weight", type=float, default=0.70)
+    parser.add_argument("--teacher-family-weight", type=float, default=1.00)
+    parser.add_argument("--hard-exact-weight", type=float, default=0.20)
+    parser.add_argument("--hard-family-weight", type=float, default=0.50)
+    parser.add_argument("--patience", type=int, default=5)
+    parser.add_argument("--minimum-independent-sources", type=int, default=2)
+    parser.add_argument("--distillation-regression-maximum-pp", type=float, default=1.0)
+    parser.add_argument("--device", choices=("cuda", "cpu"), default="cuda")
+    return parser.parse_args()
+
+
+def _seed06(seed: int) -> None:
+    """필요 변수: student seed. 작동 원리: Python·NumPy·PyTorch 초기화를 고정한다."""
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def _resolve_project_path06(value: str | Path, *, parent: Path | None = None) -> Path:
+    """필요 변수: checkpoint lineage 경로·선택 report parent. 작동 원리: 절대/상대 경로를 존재하는 실제 파일로 해석한다."""
+
+    path = Path(value)
+    candidates = [path] if path.is_absolute() else [
+        *((parent / path,) if parent is not None else ()),
+        PROJECT_ROOT / path,
+    ]
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(f"checkpoint 경로를 찾을 수 없습니다: {value}")
+
+
+def _load_teacher06(
+    report: dict[str, Any],
+    report_path: Path,
+    *,
+    device: torch.device,
+) -> tuple[Any, torch.nn.Module, SkeletonTrajectoryAdapter06, tuple[str, ...]]:
+    """필요 변수: 통과 teacher report/path. 작동 원리: base→shared online→P formula adapter 순서로 합성한다."""
+
+    formula_checkpoint = _resolve_project_path06(
+        str(report["checkpoint"]),
+        parent=report_path.parent,
+    )
+    payload = torch.load(formula_checkpoint, map_location="cpu", weights_only=False)
+    if payload.get("track") != "P_approved_formula_only":
+        raise ValueError("P Formula teacher checkpoint track이 올바르지 않습니다.")
+    if payload.get("seed_gate_passed") is not True:
+        raise ValueError("개별 gate를 통과하지 않은 teacher checkpoint입니다.")
+    if str(payload.get("data_sha256") or "") != str(report["data_sha256"]):
+        raise ValueError("Teacher checkpoint/report data SHA-256이 다릅니다.")
+    online_path = _resolve_project_path06(str(payload["online_adapter"]))
+    base_path = _resolve_project_path06(str(payload["base_checkpoint"]))
+    engine, online_adapter = _load_model06(base_path, online_path, device)
+    formula_adapter = SkeletonTrajectoryAdapter06(
+        hidden_size=int(payload["hidden_size"]),
+    ).to(device)
+    formula_adapter.load_state_dict(payload["state_dict"])
+    engine.model.eval()
+    online_adapter.eval()
+    formula_adapter.eval()
+    return engine, online_adapter, formula_adapter, tuple(str(label) for label in engine.labels)
+
+
+def _teacher_targets06(
+    teachers: Sequence[tuple[Any, torch.nn.Module, SkeletonTrajectoryAdapter06]],
+    features: Tensor,
+    *,
+    temperature: float,
+    device: torch.device,
+    batch_size: int,
+) -> tuple[Tensor, Tensor]:
+    """필요 변수: 세 teacher·한 split feature. 작동 원리: seed별 exact/family probability를 CPU에서 평균한다."""
+
+    exact_rows, family_rows = [], []
+    for engine, online_adapter, formula_adapter in teachers:
+        exact, family = _forward06(
+            engine.model,
+            online_adapter,
+            formula_adapter,
+            features,
+            device=device,
+            batch_size=batch_size,
+        )
+        exact_rows.append(exact)
+        family_rows.append(family)
+    return (
+        ensemble_teacher_probability06(exact_rows, temperature=temperature),
+        ensemble_teacher_probability06(family_rows, temperature=temperature),
+    )
+
+
+def _balanced_loader06(
+    batch: PFormulaTensorBatch06,
+    tensors: Sequence[Tensor],
+    *,
+    batch_size: int,
+    seed: int,
+) -> DataLoader:
+    """필요 변수: P batch·학습 tensor. 작동 원리: source×label 역제곱근 sampler로 distillation batch를 만든다."""
+
+    exact_targets = tensors[0]
+    label_counts = Counter(int(value) for value in exact_targets.tolist())
+    source_counts = Counter(batch.source_ids)
+    weights = torch.tensor([
+        1.0 / (
+            max(label_counts[int(label)], 1) ** 0.5
+            * max(source_counts[source], 1) ** 0.5
+        )
+        for label, source in zip(
+            exact_targets.tolist(),
+            batch.source_ids,
+            strict=True,
+        )
+    ])
+    sampler = WeightedRandomSampler(
+        weights,
+        num_samples=len(weights),
+        replacement=True,
+        generator=torch.Generator().manual_seed(seed),
+    )
+    return DataLoader(
+        TensorDataset(batch.features, *tensors),
+        batch_size=batch_size,
+        sampler=sampler,
+    )
+
+
+def _release_metrics06(
+    logits: Tensor,
+    targets: Tensor,
+    batch: PFormulaTensorBatch06,
+    labels: Sequence[str],
+) -> dict[str, Any]:
+    """필요 변수: student/teacher exact logit·split metadata. 작동 원리: 공통 P release metric을 호출한다."""
+
+    return p_formula_release_metrics06(
+        logits,
+        targets,
+        labels=labels,
+        writer_ids=batch.writer_ids,
+        source_ids=batch.source_ids,
+        timestamp_missing=batch.timestamp_missing,
+        pressure_missing=batch.pressure_missing,
+    )
+
+
+def main() -> None:
+    """필요 변수: 통과한 세 teacher와 동일 P corpus. 작동 원리: 하나의 formula adapter student를 학습하고 test regression을 판정한다."""
+
+    args = _parse_args()
+    device = torch.device(args.device)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA distillation을 요청했지만 사용할 수 없습니다.")
+    _seed06(args.seed)
+    data_sha256 = _file_sha25606(args.data)
+    summary = json.loads(args.summary.read_text(encoding="utf-8"))
+    reports = [
+        json.loads(path.read_text(encoding="utf-8"))
+        for path in args.teacher_report
+    ]
+    ordered_reports = validate_p_formula_distillation_inputs06(
+        summary,
+        reports,
+        data_sha256=data_sha256,
+    )
+    report_paths = {
+        int(json.loads(path.read_text(encoding="utf-8"))["seed"]): path
+        for path in args.teacher_report
+    }
+    loaded = [
+        _load_teacher06(
+            report,
+            report_paths[int(report["seed"])],
+            device=device,
+        )
+        for report in ordered_reports
+    ]
+    label_contracts = {labels for *_modules, labels in loaded}
+    if len(label_contracts) != 1:
+        raise ValueError("세 teacher의 exact vocabulary가 다릅니다.")
+    labels = next(iter(label_contracts))
+    teachers = [(engine, online, formula) for engine, online, formula, _labels in loaded]
+
+    records = list(read_jsonl(args.data))
+    audit = audit_p_formula_records06(
+        records,
+        minimum_independent_sources=args.minimum_independent_sources,
+    )
+    if not audit["eligible_for_product_evaluation"]:
+        raise ValueError("현재 P Formula corpus가 product preflight를 통과하지 못했습니다.")
+    split_records = {
+        split: [record for record in records if str(record["split"]) == split]
+        for split in ("training", "validation", "test")
+    }
+    batches = {
+        split: materialize_p_formula_split06(values, allowed_labels=labels)
+        for split, values in split_records.items()
+    }
+    targets = {
+        split: _targets06(batch.truths, labels, loaded[0][0].family_labels)
+        for split, batch in batches.items()
+    }
+    teacher_targets = {
+        split: _teacher_targets06(
+            teachers,
+            batch.features,
+            temperature=args.temperature,
+            device=device,
+            batch_size=args.batch_size,
+        )
+        for split, batch in batches.items()
+    }
+
+    student_adapter_path = _resolve_project_path06(args.student_adapter)
+    student_payload = torch.load(
+        student_adapter_path,
+        map_location="cpu",
+        weights_only=False,
+    )
+    student_base = _resolve_project_path06(str(student_payload["base_checkpoint"]))
+    student_engine, student_online = _load_model06(
+        student_base,
+        student_adapter_path,
+        device,
+    )
+    if tuple(str(label) for label in student_engine.labels) != labels:
+        raise ValueError("Student main vocabulary가 teacher와 다릅니다.")
+    for parameter in student_engine.model.parameters():
+        parameter.requires_grad_(False)
+    for parameter in student_online.parameters():
+        parameter.requires_grad_(False)
+    student_formula = SkeletonTrajectoryAdapter06(
+        hidden_size=args.hidden_size,
+    ).to(device)
+    train_exact, train_family = targets["training"]
+    train_teacher_exact, train_teacher_family = teacher_targets["training"]
+    loader = _balanced_loader06(
+        batches["training"],
+        (
+            train_exact,
+            train_family,
+            train_teacher_exact,
+            train_teacher_family,
+        ),
+        batch_size=args.batch_size,
+        seed=args.seed,
+    )
+    optimizer = torch.optim.AdamW(
+        student_formula.parameters(),
+        lr=args.learning_rate,
+        weight_decay=args.weight_decay,
+    )
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+        optimizer,
+        T_max=max(args.epochs, 1),
+        eta_min=args.learning_rate * 0.1,
+    )
+    best_key = (-1.0, -1.0)
+    best_state: dict[str, Tensor] | None = None
+    best_epoch = 0
+    stale = 0
+    history = []
+    for epoch in range(1, args.epochs + 1):
+        student_formula.train()
+        losses = []
+        for (
+            features,
+            exact_target,
+            family_target,
+            teacher_exact,
+            teacher_family,
+        ) in loader:
+            features = features.to(device)
+            exact_target = exact_target.to(device)
+            family_target = family_target.to(device)
+            teacher_exact = teacher_exact.to(device)
+            teacher_family = teacher_family.to(device)
+            optimizer.zero_grad(set_to_none=True)
+            with torch.no_grad():
+                online = student_online(features)
+            exact_logits, family_logits = student_engine.model.classify_trajectory(
+                student_formula(online),
+            )
+            temperature = args.temperature
+            exact_distill = torch.nn.functional.kl_div(
+                (exact_logits / temperature).log_softmax(dim=1),
+                teacher_exact,
+                reduction="batchmean",
+            ) * temperature ** 2
+            family_distill = torch.nn.functional.kl_div(
+                (family_logits / temperature).log_softmax(dim=1),
+                teacher_family,
+                reduction="batchmean",
+            ) * temperature ** 2
+            loss = (
+                args.teacher_exact_weight * exact_distill
+                + args.teacher_family_weight * family_distill
+                + args.hard_exact_weight
+                * torch.nn.functional.cross_entropy(exact_logits, exact_target)
+                + args.hard_family_weight
+                * torch.nn.functional.cross_entropy(family_logits, family_target)
+            )
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(student_formula.parameters(), 2.0)
+            optimizer.step()
+            losses.append(float(loss.detach()))
+        scheduler.step()
+        validation_logits = _forward06(
+            student_engine.model,
+            student_online,
+            student_formula,
+            batches["validation"].features,
+            device=device,
+            batch_size=args.batch_size,
+        )
+        validation_metrics = _release_metrics06(
+            validation_logits[0],
+            targets["validation"][0],
+            batches["validation"],
+            labels,
+        )
+        row = {
+            "epoch": epoch,
+            "loss": sum(losses) / max(len(losses), 1),
+            "validation": validation_metrics,
+        }
+        history.append(row)
+        print(json.dumps(row, ensure_ascii=False), flush=True)
+        key = (
+            float(validation_metrics["visual_family_top1"]),
+            float(validation_metrics["exact_top1"]),
+        )
+        if key > best_key:
+            best_key = key
+            best_epoch = epoch
+            best_state = deepcopy({
+                name: value.detach().cpu()
+                for name, value in student_formula.state_dict().items()
+            })
+            stale = 0
+        else:
+            stale += 1
+        if stale >= args.patience:
+            break
+    if best_state is None:
+        raise RuntimeError("Distilled student checkpoint가 선택되지 않았습니다.")
+    student_formula.load_state_dict(best_state)
+    student_test_logits = _forward06(
+        student_engine.model,
+        student_online,
+        student_formula,
+        batches["test"].features,
+        device=device,
+        batch_size=args.batch_size,
+    )[0]
+    student_test = _release_metrics06(
+        student_test_logits,
+        targets["test"][0],
+        batches["test"],
+        labels,
+    )
+    teacher_exact_probability = teacher_targets["test"][0]
+    teacher_test = _release_metrics06(
+        teacher_exact_probability.clamp_min(1e-9).log(),
+        targets["test"][0],
+        batches["test"],
+        labels,
+    )
+    seed_gate = p_formula_seed_gate06(student_test)
+    regression = {
+        metric: (
+            float(teacher_test[metric]) - float(student_test[metric])
+        ) * 100.0
+        for metric in ("exact_top1", "exact_top5", "visual_family_top1")
+    }
+    regression_passed = all(
+        drop <= args.distillation_regression_maximum_pp
+        for drop in regression.values()
+    )
+    distillation_gate_passed = bool(seed_gate["passed"] and regression_passed)
+    args.output.mkdir(parents=True, exist_ok=True)
+    checkpoint = args.output / "p_formula_student_adapter.pt"
+    torch.save({
+        "schema": "aiflow-math-ink-06-p-formula-student-v1",
+        "state_dict": best_state,
+        "hidden_size": args.hidden_size,
+        "student_base_checkpoint": str(student_base),
+        "student_online_adapter": str(student_adapter_path),
+        "teacher_seeds": [17, 31, 47],
+        "data_sha256": data_sha256,
+        "selected_epoch": best_epoch,
+        "distillation_gate_passed": distillation_gate_passed,
+        "track": "P_approved_formula_only",
+        "teacher_weights_embedded": False,
+        "litert_exported": False,
+        "product_validation": False,
+    }, checkpoint)
+    report = {
+        "experiment": "P-MATH-INK-06-FORMULA-STUDENT-DISTILL-001",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "student_seed": args.seed,
+        "teacher_seeds": [17, 31, 47],
+        "data": str(args.data),
+        "data_sha256": data_sha256,
+        "preflight": audit,
+        "temperature": args.temperature,
+        "loss_weights": {
+            "teacher_exact": args.teacher_exact_weight,
+            "teacher_family": args.teacher_family_weight,
+            "hard_exact": args.hard_exact_weight,
+            "hard_family": args.hard_family_weight,
+        },
+        "selected_epoch": best_epoch,
+        "teacher_test": teacher_test,
+        "student_test": student_test,
+        "student_seed_gate": seed_gate,
+        "teacher_to_student_drop_pp": regression,
+        "distillation_regression_maximum_pp": args.distillation_regression_maximum_pp,
+        "distillation_regression_passed": regression_passed,
+        "distillation_gate_passed": distillation_gate_passed,
+        "history": history,
+        "checkpoint": checkpoint.name,
+        "checkpoint_bytes": checkpoint.stat().st_size,
+        "teacher_weights_embedded": False,
+        "track": "P_approved_formula_only",
+        "litert_exported": False,
+        "product_validation": False,
+        "next_gate": "composite torch.export→LiteRT parity→Android 3-tier benchmark",
+    }
+    (args.output / "report.json").write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps({
+        "student_test": student_test,
+        "teacher_test": teacher_test,
+        "distillation_gate_passed": distillation_gate_passed,
+        "checkpoint": str(checkpoint),
+        "product_validation": False,
+    }, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/summarize_math_ink_06_p_formula_seeds.py

@@ -23,6 +23,9 @@ def summarize_p_formula_seeds06(reports: list[dict[str, Any]]) -> dict[str, Any]
         raise ValueError("R-track 또는 알 수 없는 formula adapter report를 distillation 요약에 섞을 수 없습니다.")
     if any(report.get("official_test") is None for report in reports):
         raise ValueError("official test를 생략한 seed는 3-seed gate에 사용할 수 없습니다.")
+    fingerprints = {str(report.get("data_sha256") or "") for report in reports}
+    if len(fingerprints) != 1 or "" in fingerprints:
+        raise ValueError("세 seed는 동일한 비어 있지 않은 P Formula data_sha256을 가져야 합니다.")
     ordered = sorted(reports, key=lambda report: int(report["seed"]))
 
     def aggregate(path: tuple[str, ...]) -> dict[str, Any]:
@@ -62,6 +65,7 @@ def summarize_p_formula_seeds06(reports: list[dict[str, Any]]) -> dict[str, Any]
         "experiment": "P-MATH-INK-06-FORMULA-ADAPTER-3SEED-001",
         "generated_at": datetime.now(timezone.utc).isoformat(),
         "seeds": [17, 31, 47],
+        "data_sha256": next(iter(fingerprints)),
         "metrics": metrics,
         "individual_seed_gates": individual,
         "decision": {

scripts/train_math_ink_06_p_formula_adapter.py

@@ -6,6 +6,7 @@ import argparse
 from collections import Counter
 from copy import deepcopy
 from datetime import datetime, timezone
+from hashlib import sha256
 import json
 from pathlib import Path
 import random
@@ -77,6 +78,16 @@ def _seed06(seed: int) -> None:
         torch.cuda.manual_seed_all(seed)
 
 
+def _file_sha25606(path: Path) -> str:
+    """필요 변수: P Formula JSONL. 작동 원리: seed 간 동일 corpus를 증명할 byte-level SHA-256을 계산한다."""
+
+    digest = sha256()
+    with path.open("rb") as file:
+        for chunk in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
 def _source_label_loader06(
     batch: PFormulaTensorBatch06,
     exact_targets: Tensor,
@@ -146,6 +157,7 @@ def main() -> None:
     _seed06(args.seed)
 
     records = list(read_jsonl(args.data))
+    data_sha256 = _file_sha25606(args.data)
     audit = audit_p_formula_records06(
         records,
         minimum_independent_sources=args.minimum_independent_sources,
@@ -360,6 +372,7 @@ def main() -> None:
         "seed_gate_passed": bool(seed_gate and seed_gate["passed"]),
         "product_validation": False,
         "distillation_allowed": False,
+        "data_sha256": data_sha256,
     }, checkpoint)
     report = {
         "experiment": "P-MATH-INK-06-FORMULA-ADAPTER-001",
@@ -370,6 +383,7 @@ def main() -> None:
             torch.cuda.get_device_name(device) if device.type == "cuda" else None
         ),
         "data": str(args.data),
+        "data_sha256": data_sha256,
         "preflight": audit,
         "samples": {
             "training": len(train_batch.truths),