IPE는 어떻게
문제를 만들고 검증할까?

builder.set_entry_point("architect")        # 시작: 출제자
builder.add_edge("architect", "designer")  # 출제자 → 설계자
builder.add_edge("designer",  "coder")     # 설계자 → 프로그래머
builder.add_edge("coder",     "executor")  # 프로그래머 → 검사기
builder.add_edge("executor",  "record")    # 검사기 → 기록

# 기록 후, 라우터가 "다음에 누구에게 갈지" 결정 (조건부 분기)
builder.add_conditional_edges("record", route_after_executor, ...)

# Dijkstra symbolic verifier — 4 invariants 결정론적 검증
# 1. non_negative_distance  : 거리는 음수일 수 없다
# 2. source_zero            : 출발=도착이면 거리는 0
# 3. reachability_consistent: 도달 불가인데 거리값이 있으면 모순
# 4. shortest_distance_optimal: 독립 알고리즘(Bellman-Ford)으로
#    다시 계산한 답과 일치해야 한다  ← 진짜 검산

def _shortest_distance_bellman_ford(graph):
    dist = [inf] * graph.V
    dist[graph.s] = 0.0          # 출발점만 0, 나머지 무한대
    for _ in range(graph.V - 1):
        for u, v, w in graph.edges:
            if dist[u] != inf and dist[u] + w < dist[v]:
                dist[v] = dist[u] + w   # 더 짧은 길 발견 → 갱신
    return int(dist[graph.t])           # s→t 최단 거리

golden = _shortest_distance_bellman_ford(graph)
if actual != golden:
    return InvariantViolation(
        invariant_kind="shortest_distance_optimal",
        description=f"actual={actual} != Bellman-Ford golden={golden}",
    )

class FailureMode(StrEnum):
    NONE                = "none"                # 통과
    SAMPLE_MISMATCH     = "sample_mismatch"     # 예시 답 불일치
    INVARIANT_VIOLATION = "invariant_violation" # 수학 법칙 위반
    BRUTE_DISAGREEMENT  = "brute_disagreement"  # 정해 vs 브루트 불일치
    SAMPLE_CRASH        = "sample_crash"        # 코드가 터짐

class StructuredFeedback(BaseModel):
    target_node:        TargetNode  # 누구에게 돌려보낼지 (enum)
    actionable_hint:    str         # 무엇을 고칠지
    blocking_signature: str         # 같은 실패 반복 감지용 '지문'

class TargetAlgorithm(StrEnum):
    DIJKSTRA = "dijkstra";  LIS = "lis";  SEGTREE = "segtree"
    TWO_SUM = "two_sum";  BFS = "bfs";  KNAPSACK = "knapsack"
    KRUSKAL_MST = "kruskal_mst";  FENWICK = "fenwick";  ...
    # … 총 19개. free str 대신 enum 으로 좁혀
    # symbolic verifier dispatch 의 silent fallback 회피

payload = {
    "failure_mode": v.failure_mode.value,        # 무엇이 틀렸나 (enum)
    "invariant_violations": [...],               # 어떤 수학 법칙 위반
    "feedback": {
        "target_node": ...,                       # 내가 고칠 차례인가
        "actionable_hint": ...,                   # 구체적 수정 방향
        "blocking_signature": ...,                # 같은 실패 반복 감지
    },
}
return "prev verification (structured JSON):\n" + json.dumps(payload, ...)

verifier = verifier_getter(state.target_algorithm)   # enum → 해당 검증기
if verifier is not None:
    violations = list(verifier.verify(spec=spec, design=...,
                                    attempt=attempt, sample_outputs=outputs))
    # 검증기가 '실제로' 검사한 예시 수도 센다 (장식 아님을 측정)
    samples_engaged = verifier.count_engaged_samples(spec)

# macOS:  T1(docker) → T2.5(sandbox-exec) → T3(rlimit)+경고
# Linux:  T1(docker) → T2(nsjail)         → T3(rlimit)
# 1) T1 Docker — 모든 OS에서 가장 강력 (네트워크 차단 + 읽기전용)
try:
    from ipe.sandbox.docker_runner import DockerRunner
    return DockerRunner()
except RuntimeError:
    ...   # Docker 없으면 다음 단계로
# 4) T3 fallback — 최소한의 자원 제한(RLIMIT)이라도
return RlimitRunner()

# 예시 답은 틀렸는데(SAMPLE_MISMATCH) 수학 invariant 는 전부 통과(violations 없음)?
# → 코드는 사실상 맞고 '출제자가 정답을 잘못 적은 것'이다.
if mode == FailureMode.SAMPLE_MISMATCH and not violations:
    target = TargetNode.ARCHITECT   # → 출제자에게 (코드 탓 아님!)
    routed_hint = f"{hint} (verifier invariants all pass — "
                  f"likely architect expected_output error, regenerate spec)"
else:
    target = TargetNode.CODER        # 그 외엔 프로그래머가 코드 수정

if v.overall_pass:
    return "end_success"                  # 통과 → 끝
...
target = v.feedback.target_node
if target == TargetNode.ARCHITECT:
    return "architect"                   # 출제자 다시
if target == TargetNode.DESIGNER:
    return "designer"                    # 설계자 다시
return "coder"                           # 기본: 프로그래머 다시

# 같은 '실패 지문(signature)'이 2번 이상 반복되면 = 제자리 맴돌이
same_sig_count = sum(1 for r in state.context.iterations
                     if r.blocking_signature == sig)
if same_sig_count >= OSCILLATION_THRESHOLD:   # 임계값 = 2
    return "end_oscillation"      # 깔끔히 포기 (헛돌지 않음)

if state.iteration >= state.max_iterations:
    return "end_budget"           # 시도 횟수 초과 → 중단

outputs/<run_id>/
├── problem.md          # 사람이 읽는 문제 (제목 + 지문 + 예시)
├── spec.json           # 출제자 서류 (ProblemSpec)
├── design.json         # 설계자 서류 (AlgorithmDesign)
├── attempt.py          # 정답 코드 (golden)
├── verification.json   # 검증 결과 (어떤 검증기가 통과했는지)
├── outcome.json        # 최종 상태 + 몇 번 만에 됐는지
└── samples/
    ├── 1.in / 1.out    # 채점용 입력·정답 (online judge 호환)
    └── 2.in / 2.out

g = run_code(runner, golden_code, inp, ...)
b = run_code(runner, brute_code, inp, ...)
# 둘 다 정상 종료 + 출력이 같을 때만 '일치'로 인정
agreed = g.status == "OK" and b.status == "OK" and g_out == b_out

# determinism : 같은 입력 재실행 → 동일 출력
#   (불안정한 정답지 = 채용 시험에서 치명적)
# well_formed : 정상 종료 + 빈 출력 아님 + 에러 누출(Traceback) 없음

if symbolic is TierAxis.PASS:
    tier = Tier.A    # 수학 검증 통과 → 완전 신뢰
elif symbolic is TierAxis.FAIL:
    tier = Tier.C    # 수학 검증 실패 → 출하 불가
elif diff_axis is TierAxis.PASS and meta_axis is TierAxis.PASS:
    tier = Tier.B    # 수학 검증기 없지만 차분+변형 통과 → 신뢰
else:
    tier = Tier.C    # 신호 부족 → 기업용 reject (폐기/강등)

# typed StrategySeed 로 반환 (자유 글 파싱 없음):
# - reduction_core: 숨길 핵심 알고리즘 — solver 가 지문만 보고
#                   바로 알아채지 못하게 할 대상
# - composition  : 추가로 섞을 기법 1~2개 (난이도·위장 강화)
# - domain       : 위장할 현실 도메인 (logistics, social-network …)
# - rationale    : 이 위장이 왜 reduction_core 를 숨기는지 한 줄 근거

# hidden=True (은닉, 기업용):
#   reduction_core(숨은 알고리즘) 이름을 **절대 언급하지 말 것**.
#   domain 의 자연스러운 상황으로 위장하되, 형식적으로는 정확히
#   그 알고리즘으로 환원되게.
# hidden=False (직접, 학습용): 알고리즘을 명시해도 됨 (토픽 드릴)

def route_after_faithfulness(state):
    f = state.faithfulness
    if f is not None and f.faithful:
        return "end_success"      # 충실 → 출하
    if state.iteration >= state.max_iterations:
        return "end_faithfulness" # 예산 소진 → 실패 종료
    return "regen"               # 왜곡 → 이야기만 다시 (싼 반복)

"ambiguity"  # 모호성 — 지문·입출력 형식이 유일하게 해석되는가
"fairness"   # 공정성 — 지문과 형식만으로 풀 수 있는가 (숨은 전제 X)
"leakage"    # 유출 — 유명 문제(저지·교재)와 사실상 동일하지 않은가
"difficulty" # 난이도 일관성 — 사실상 trivial 하게 풀리는 모순 없는가

def route_after_qa(state):
    r = state.qa_report
    if r is None:           return "end_qa"      # 집계 불능
    if r.overall_pass:        return "end_success" # 합격 → 출하
    if state.qa_routebacks < state.max_qa_routebacks:
        return "routeback"     # 지적 들고 이야기 재작성 → 재심사
    return "end_qa"            # 예산 소진 → 불합격 종료

@app.get("/healthz")                          # 서버 살아있나
@app.post("/v1/problems/generate", status_code=202)
def generate(req):
    ...
    return {"job_id": job.job_id}             # 즉시 접수증 (202 Accepted)

@app.get("/v1/jobs/{job_id}")                # 접수증으로 결과 조회
def get_job(job_id):
    ...   # running / 완료(문제 패키지) / 404