OpenDeepThink: Parallel Reasoning via Bradley--Terry Aggregation

# 논문에서 제공한 pairwise comparison 프롬프트 템플릿
comparison_prompt = """
You are a competitive programming expert.

## Problem Statement
{problem}

## Solution A
```cpp
{code_a}
```

## Solution B
```cpp
{code_b}
```

Which solution is more likely to receive an Accepted verdict from an online judge ---
meaning it produces correct output within the time and memory limits for all valid inputs?

If both solutions appear incorrect (wrong answer, TLE, or other issues), choose the
one that requires fewer modifications to become Accepted.

If they are fundamentally identical or equally likely to be Accepted, output TIE.

Respond with a JSON object and nothing else, in exactly this format:
{
  "feedback_a": "one sentence on Solution A's key strength or critical flaw",
  "feedback_b": "one sentence on Solution B's key strength or critical flaw",
  "winner": "A or B or TIE"
}
"""

# mutation 프롬프트 (네거티브 피드백 포함)
mutation_prompt = """
## Problem
{problem}

## Solution
```cpp
{code}
```

## Pairwise Feedback
This solution was compared against other solutions multiple times:

### Wins (this solution was judged better):
- {wins_feedback}

### Losses (this solution was judged worse):
- {losses_feedback}

## Task
Write a solution that maximizes the probability of Accepted.
You may refine the existing solution or take a different approach
if the current one is fundamentally flawed.

Think briefly, then output your final solution as a single ```cpp ... ``` block.
"""

# Bradley-Terry 점수 계산 (scipy 사용)
from scipy.optimize import minimize
import numpy as np

def fit_bradley_terry(comparisons, n_candidates, lambda_reg=0.01):
    """
    comparisons: list of (i, j, outcome) where outcome=1 if i wins, 0 if j wins, 0.5 if tie
    n_candidates: number of candidates
    returns: score vector s of shape (n_candidates,)
    """
    def neg_log_likelihood(s):
        loss = 0
        for i, j, outcome in comparisons:
            diff = s[i] - s[j]
            log_prob = outcome * diff - np.log(1 + np.exp(diff))
            loss -= log_prob
        loss += 0.5 * lambda_reg * np.sum(s**2)  # L2 regularization
        return loss
    
    s0 = np.zeros(n_candidates)
    result = minimize(neg_log_likelihood, s0, method='L-BFGS-B')
    return result.x

# 사용 예시
# comparisons = [(0, 1, 1), (1, 2, 0.5), (0, 2, 1)]  # (후보i, 후보j, 결과)
# scores = fit_bradley_terry(comparisons, n_candidates=3)
# best_candidate_idx = np.argmax(scores)