papers/voting-leaderboards/sau.json

{
  "paper_id": "voting-leaderboards",
  "paper_title": "Exploring and Mitigating Adversarial Manipulation of Voting-Based Leaderboards",
  "D1": [
    {
      "id": "voting-leaderboards-D1-001",
      "claim": "Central experiment constants shared across all detector evaluations and simulations: 22 evaluated models (listed in Table 6, Appendix A.1); 5 identity-probing prompts; 1,000 queries per prompt for identity-probing evaluation; 8 prompt categories (Table 1: English, Chinese, Spanish, Indonesian, Persian, Coding, Math, Safety-violating); 200 prompts sampled per category; 50 responses collected per model per prompt; 512 output tokens per response; 80/20 train/test split; random_state=42; scikit-learn LogisticRegression with default hyperparameters; detection accuracy assumption of 95% with symmetric 5% FPR/FNR for simulations; attacker abstains when target model not detected; Bradley-Terry ranking computed from historical voting data; rankings recomputed every 1,000 simulated interactions.",
      "source": "Section 2.3, Section 3.1, Appendix A.3"
    },
    {
      "id": "voting-leaderboards-D1-002",
      "claim": "The 22 models used in all experiments, with organization and query method: claude-3-5-sonnet-20240620 (Anthropic API), claude-3-haiku-20240307 (Anthropic API), gemini-1.5-flash (Google AI studio), gemini-1.5-pro (Google AI studio), gemma-2-2b-it (Together AI), gemma-2-9b-it (Together AI), gemma-2-27b-it (Together AI), gpt-3.5-turbo (OpenAI), gpt-4-0125-preview (OpenAI), gpt-4-1106-preview (OpenAI), gpt-4-turbo-2024-04-09 (OpenAI), gpt-4o-2024-05-13 (OpenAI), gpt-4o-2024-08-06 (OpenAI), gpt-4o-mini-2024-07-18 (OpenAI), llama-3-8b-instruct (Together AI), llama-3-70b-instruct (Together AI), llama-3.1-8b-instruct (Together AI), llama-3.1-70b-instruct (Together AI), llama-3.1-405b-instruct (Together AI), mixtral-8x7b-instruct-v0.1 (Together AI), mixtral-8x22b-instruct-v0.1 (Together AI), qwen2-72b-instruct (Together AI).",
      "source": "Appendix A.1 (Table 6)"
    },
    {
      "id": "voting-leaderboards-D1-003",
      "claim": "Parameters for the identity-probing detector evaluation: 5 identity-probing prompts ('Who are you?', 'Which model are you?', 'What is your model name?', 'How should I refer to you as an AI?', 'How would you define your role or identity as an AI?'); 1,000 queries per prompt per model; string matching on model name (e.g., 'Llama') or organization (e.g., 'Meta') in response; average accuracy reported per prompt per model.",
      "source": "Section 2.3, Section 2.4.1"
    },
    {
      "id": "voting-leaderboards-D1-004",
      "claim": "Eight prompt categories used to build the training-based detector, their sources, and categories. Normal chats in high-resource languages: English, Chinese, Spanish (source: LMSYS-Chat-1M). Normal chats in low-resource languages: Indonesian, Persian (source: LMSYS-Chat-1M). Specialty chats: Coding (source: Alpaca Code), Math (source: MATH), Safety-violating (source: AdvBench). See Table 1 for examples.",
      "source": "Section 2.3 (Table 1)"
    },
    {
      "id": "voting-leaderboards-D1-005",
      "claim": "Three text feature types used to distinguish model responses for training-based detection: Length(R) measured in words or characters, TF-IDF(R) (Salton & Buckley, 1988), BoW(R) bag-of-words (Salton et al., 1975). Evaluated independently per (P, M) pair.",
      "source": "Section 2.3"
    },
    {
      "id": "voting-leaderboards-D1-006",
      "claim": "Fixed hyperparameters for the logistic regression classifier and hypothesis tests: scikit-learn LogisticRegression with default hyperparameters; random_state=42; 80/20 train/test split; 50 positive samples (target model M) and 50 uniformly sampled negative samples (other models) per (P, M) pair; alpha=0.01 significance level for hypothesis tests in malicious user detection (Section 4.2.3).",
      "source": "Section 2.3, Section 4.2.3"
    },
    {
      "id": "voting-leaderboards-D1-007",
      "claim": "Assumed detection accuracy and error rates used in the vote count simulation: 95% detection accuracy, symmetric 5% false positive rate and 5% false negative rate. Attacker remains passive (abstains) when failing to detect the target model in the sampled response pair.",
      "source": "Section 3.1"
    },
    {
      "id": "voting-leaderboards-D1-008",
      "claim": "Characteristics of the anonymized and deduplicated Chatbot Arena dataset used for the simulation testbed: 1,670,250 votes from 477,322 unique users; 1,093,875 votes resulting in wins, 576,375 in ties; 6,895 unique combinations of side-by-side model comparisons.",
      "source": "Appendix A.4"
    },
    {
      "id": "voting-leaderboards-D1-009",
      "claim": "Two manipulation objectives defined for the vote count simulation: Up(M, x) — manipulate model M to rise x positions in the leaderboard; Down(M, x) — manipulate model M to fall x positions in the leaderboard.",
      "source": "Section 3.1"
    },
    {
      "id": "voting-leaderboards-D1-010",
      "claim": "Token pricing rates used to calculate the upper-bound cost of building the detector: proprietary models $5.00 per 1M output tokens (via Anthropic/OpenAI/Google APIs); open-source models $1.80 per 1M output tokens (via Together AI Inference API). All models use default decoding hyperparameters (temperature, etc.). Output length set to 512 tokens per response. 50 responses collected per model per prompt. Upper-bound data collection cost estimated at ~$440 for 200 prompts across 22 models.",
      "source": "Appendix A.3"
    },
    {
      "id": "voting-leaderboards-D1-011",
      "claim": "Detection accuracy levels swept in the ablation study: 1.0 (perfect detector), 0.95 (baseline), 0.9. Target model: llama-13b (current rank #129, 2,443 base votes). Rank shift targets: 1, 2, 5, 10, 20, 50 positions. All other simulation parameters as in Section 3.1.",
      "source": "Appendix B.2 (Table 8)"
    },
    {
      "id": "voting-leaderboards-D1-012",
      "claim": "Four alternative strategies evaluated when the attacker fails to detect the target model: (1) do nothing / abstain; (2) randomly upvote one model in the pair; (3) vote tie; (4) vote tie (both bad). Tested on high-ranked model claude-3-5-sonnet-20240620 (rank #5, 7,703 base votes) with rank shifts 1-4, and low-ranked model llama-13b (rank #129, 2,443 base votes) with rank shifts 1, 2, 5, 10, 20, 50.",
      "source": "Appendix B.2 (Table 9)"
    },
    {
      "id": "voting-leaderboards-D1-013",
      "claim": "Parameters of the attack cost model c_total = ceil(N/m) * c_account + N * c_action + c_detector: N = total actions (interactions + votes), m = max actions per user account (rate limit), c_account = cost per account, c_action = cost per action, c_detector = one-time offline detector training cost (~$440). These are design parameters set by the defender. Without mitigations: m unlimited, c_action minimal, total cost dominated by c_detector.",
      "source": "Section 4.1"
    }
  ],
  "D2": [
    {
      "id": "voting-leaderboards-D2-001",
      "claim": "De-anonymization as Binary Classification | Problem: Given target model M from public model set M_set, build classifier f_M(P, R) -> {0, 1}\n\nFormal definition:\n  Input: prompt P, response R from unknown model\n  Output: 1 if R ~ M(P), 0 otherwise\n  \nAssumption: M(P) != M'(P) for distinct M != M'\n  (different models produce observably distinct output distributions given the same input prompt)\n\nClass labeling:\n  Class 1 = target model M (the model we want to de-anonymize)\n  Class 0 = all other mode",
      "source": "Section 2.1"
    },
    {
      "id": "voting-leaderboards-D2-002",
      "claim": "Identity-Probing Detector | Algorithm: identity_probing_detector(P, target_model_name, target_org_name, model_api)\n\n  # Step 1: Select an identity-probing prompt\n  prompts = [\n    \"Who are you?\",\n    \"Which model are you?\",\n    \"What is your model name?\",\n    \"How should I refer to you as an AI?\",\n    \"How would you define your role or identity as an AI?\"\n  ]\n  prompt = sample(prompts)\n  \n  # Step 2: Query the unknown model via the arena\n  response = query_arena(prompt)  # arena returns anonymiz",
      "source": "Section 2.2, Section 2.3"
    },
    {
      "id": "voting-leaderboards-D2-003",
      "claim": "Training-Based Detector — Data Collection and Feature Extraction | Phase 1: Data Collection\n\n  For each prompt P in selected_prompts:\n    # Collect positive samples from target model M\n    D_pos = []\n    For i = 1 to n_responses_per_model (n=50):\n      R ~ M(P)  # query target model M with prompt P, output 512 tokens\n      D_pos.append((P, R, label=1))\n    \n    # Collect negative samples from all other models\n    D_neg = []\n    For each M_other in M_set \\ {M}:\n      For i = 1 to n_responses_per_model (n=50):\n        R ~ M_other(P)  # query each other model with prompt P, output 512 tokens\n        D_neg.append((P, R, label=0))\n    \n    # Uniformly sample 50 negative responses from pool of all other models\n    D_neg_sampled = uniform_sample(D_neg, n=50)\n    \n    # Build balanced dataset for this (P, M) pair\n    D_P_M = D_pos + D_neg_sampled  # 100 samples total: 50 pos + 50 neg\n\n  Phase 2: Feature Extraction\n\n  Three text feature types evaluated independently for each response R:\n\n    (1) Length(R)_word     : response length in number of words\n    (2) Length(R)_character: response length in number of characters\n    (3) BoW(R)             : bag-of-words representation (Salton et al., 1975)\n    (4) TF-IDF(R)          : term frequency-inverse document frequency (Salton & Buckley, 1988)\n\n  For each feature type, extract feature matrix X and label vector y from D_P_M.\n  Proceed to Phase 3 for logistic regression training with 80/20 train/test split\n  (random_state=42, scikit-learn defaults).",
      "source": "Section 2.2, Section 2.3"
    },
    {
      "id": "voting-leaderboards-D2-004",
      "claim": "Training-Based Detector — Logistic Regression Classifier | Phase 3: Training and Evaluation (per prompt-model pair (P, M))\n\n  from sklearn.linear_model import LogisticRegression\n  from sklearn.model_selection import train_test_split\n  \n  # Extract features from balanced dataset D_P_M = D_pos + D_neg_sampled\n  X = []  # feature vectors (one of: length, BoW, or TF-IDF — evaluated independently)\n  y = []  # labels: 1 for target M, 0 for other models\n  for (prompt, response, label) in D_P_M:\n    X.a",
      "source": "Section 2.3"
    },
    {
      "id": "voting-leaderboards-D2-005",
      "claim": "Attack Cost Model | Total cost of attack:\n\n  c_total = ceil(N / m) * c_account + N * c_action + c_detector\n\nwhere:\n  N     : total number of actions (interactions + votes) required by the attack\n  m     : maximum actions permitted per user account (rate limit threshold)\n  c_account : cost of obtaining a single user account\n  c_action  : cost per individual action (vote or interaction)\n  c_detector : one-time offline cost of building the training-based target model detector\n\nWithout mitigations:",
      "source": "Section 4.1, Section 4.2"
    },
    {
      "id": "voting-leaderboards-D2-006",
      "claim": "Malicious User Detection — Scenario 1: Known Benign Distribution (Likelihood Ratio Test) | Scenario: Defender can estimate expected benign user behavior from historical voting data.\n\nGiven: observed vote sequence x = (x_1, x_2, ..., x_n) from a user\n       where each x_i is a vote for one of the available models\n\nHypotheses:\n  H_benign:  user's votes follow the known benign distribution\n  H_not_benign: user is from a different (malicious) source\n\nUnder H_benign (votes independent):\n\n  L(x | H_be",
      "source": "Section 4.2.3 (Eq 1, Eq 2, Eq 3)"
    },
    {
      "id": "voting-leaderboards-D2-007",
      "claim": "Bradley-Terry Win Probability | Given two models i and j with Bradley-Terry coefficient ratings Q_i and Q_j:\n\n  Pr(i preferred over j) = 1 / (1 + exp(-(Q_i - Q_j) / s))\n\nwhere:\n  Q_i, Q_j : Bradley-Terry coefficient ratings for models i and j\n  s        : scaling factor that determines sensitivity to rating difference\n             (larger s = less sensitive; default typically s = 400 in Elo-like systems)\n\nThis logistic function maps the rating difference (Q_i - Q_j) to a probability in (0, 1).",
      "source": "Section 4.2.3, Section 3.1"
    },
    {
      "id": "voting-leaderboards-D2-008",
      "claim": "Pr_B(i) Computation from Bradley-Terry Ratings (Benign User Vote Distribution) | Computing the probability that a benign user votes for model i:\n\n  Pr_B(i) = prod_{j != i} Pr(i preferred over j | true Bradley-Terry ratings)\n\nwhere:\n  Pr(i preferred over j) = 1 / (1 + exp(-(Q_i - Q_j) / s))\n  Q_i, Q_j : true (unperturbed) Bradley-Terry coefficient ratings\n  j iterates over all other models j != i\n\nThe product over all pairwise comparisons gives the joint probability that model i is preferred over all other models j (j != i).",
      "source": "Section 4.2.3"
    },
    {
      "id": "voting-leaderboards-D2-009",
      "claim": "Malicious User Detection — Scenario 2: Neyman-Pearson Likelihood Ratio Test (Perturbed Ratings) | Scenario: Defender releases perturbed Bradley-Terry ratings. Attacker who mimics the perturbed distribution can be detected via likelihood ratio.\n\nLikelihood Ratio (Neyman-Pearson Lemma):\n\n  Lambda(x) = Pr_negB(x) / Pr_B(x)\n\nwhere:\n  Pr_B(x)     = prod_{i=1}^{n} Pr_B(x_i)     # likelihood under benign distribution\n  Pr_negB(x)  = prod_{i=1}^{n} Pr_negB(x_i)  # likelihood under malicious distribution",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D2-010",
      "claim": "Vote Count Simulation Algorithm | Algorithm: simulate_adversarial_vote_count(target_model, objective, direction, \n                                       detection_accuracy, non_detection_strategy)\n\n  # Load historical voting data\n  data = load_chatbot_arena_data()  # anonymized, deduplicated, 1.67M votes\n  \n  # Initialize Bradley-Terry coefficients from historical data\n  bt_coefficients = compute_bradley_terry(data)\n  model_rankings = rank_by_bt(bt_coefficients)\n  initial_rank = model_rankings[t",
      "source": "Section 3.1, Section 3.2"
    }
  ],
  "D3": [
    {
      "id": "voting-leaderboards-D3-001",
      "claim": "Evaluate identity-probing detector accuracy on 22 models. For each identity-probing prompt, query each model 1,000 times, then apply string matching to check if the model's name (e.g., 'Llama') or organization (e.g., 'Meta') appears in the response. Report average detection accuracy per prompt per model. Note: Chatbot Arena already filters votes mentioning model names, making this detector less practical for real-world attacks. | Data: 22 evaluated models from 6 families (Claude, Gemini, GPT, LLaMA, Mixtral, Qwen) via provider APIs | Baselines: N/A (descriptive evaluation) | Metrics: detection accuracy (%) = (correct detections / 1000) * 100 | Results: Table 2 (Section 2.4.1) for 7 representative models, Table 7 (Appendix B.1) for all 22 models",
      "source": "Section 2.3, Section 2.4.1, Appendix B.1 (Table 7)"
    },
    {
      "id": "voting-leaderboards-D3-002",
      "claim": "Evaluate training-based detector accuracy on 22 models across 8 prompt categories. For each category, sample 200 prompts. For each (prompt, target_model) pair: collect 50 responses from target model M (class 1) and 50 uniformly sampled responses from other models (class 0); extract three feature types independently (response length in words/chars, Bag-of-Words, TF-IDF); train logistic regression classifier with scikit-learn defaults and random_state=42 on 80/20 train/test split; report test accuracy averaged across all prompts per category per model. Visualize model response clusters via PCA on BoW features. | Data: 22 models, 8 prompt categories (Table 1), 200 prompts per category, 50 responses per model per prompt | Baselines: N/A (descriptive evaluation) | Metrics: test accuracy (%) per (prompt, model, feature) triplet, averaged per category | Results: Table 3 for feature type comparison, Figure 3 for per-category per-model accuracy heatmap",
      "source": "Section 2.3, Section 2.4.2"
    },
    {
      "id": "voting-leaderboards-D3-003",
      "claim": "Simulate the number of adversarial votes and interactions needed to shift the leaderboard rank of high-ranked models (ranks 1-5). Using historical Chatbot Arena voting data with Bradley-Terry rankings, iteratively simulate attacker interactions under two objectives: Up(M,x) — raise model M by x positions; Down(M,x) — lower model M by x positions. The attacker operates with 95% detection accuracy (symmetric 5% false positive/negative rates), abstaining when the target model is not detected. Update Bradley-Terry coefficients and re-rank models after every 1,000 interactions. Track cumulative interactions and votes required to achieve each objective. | Data: Historical Chatbot Arena voting data (1.67M votes, anonymized and deduplicated) | Baselines: N/A (counterfactual simulation) | Metrics: number of adversarial votes and interactions required to move model by x positions | Results: Table 4 (high-ranked models: chatgpt-4o-latest, gemini-1.5-pro-exp-0801, gpt-4o-2024-05-13, gpt-4o-mini-2024-07-18, claude-3-5-sonnet-20240620)",
      "source": "Section 3.1, Section 3.2, Appendix A.4"
    },
    {
      "id": "voting-leaderboards-D3-004",
      "claim": "Same simulation protocol as for high-ranked models, but applied to low-ranked models (ranks 125-129) which receive fewer historical votes and are thus more vulnerable to adversarial manipulation. Compare vote requirements with high-ranked model results to quantify the rank-dependent vulnerability gradient. | Data: Historical Chatbot Arena voting data (same as high-ranked simulation), Low-ranked target models: chatglm-6b (rank 125, 4995 votes), fastchat-t5-3b (rank 126, 4304 votes), stablelm-tuned-alpha-7b (rank 127, 3334 votes), dolly-v2-12b (rank 128, 3484 votes), llama-13b (rank 129, 2443 votes) | Baselines: High-ranked model results from Table 4 | Metrics: number of adversarial votes and interactions required to move model by x positions | Results: Table 5. Low-ranked models require ~30% of the votes of high-ranked models for equivalent rank shifts",
      "source": "Section 3.2, Table 5"
    },
    {
      "id": "voting-leaderboards-D3-005",
      "claim": "Evaluate the effectiveness of Scenario 1 malicious user detection: the defender uses historical voting data to estimate benign user vote preferences. A likelihood ratio test (alpha=0.01) with Monte Carlo p-value computation is used to detect users whose voting patterns deviate from the benign distribution. Test two attacker types: (a) naive adversary who randomly chooses between two non-targeted models when the target is absent; (b) informed adversary who uses publicly available Bradley-Terry ratings to mimic benign voting proportions. Compare detection rates between naive and informed adversaries. | Data: Historical Chatbot Arena voting data (anonymized user voting records) | Baselines: Benign user vote distribution estimated from historical data | Metrics: detection rate (fraction of malicious users flagged at alpha=0.01) | Results: Figure 4. Naive adversary detectable via likelihood test; informed adversary evades detection when using public rankings",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D3-006",
      "claim": "Evaluate Scenario 2 malicious user detection: the defender releases a perturbed version of the Bradley-Terry leaderboard by adding scaled Gaussian noise to true model ratings. The attacker, when using these perturbed ratings to mimic benign behavior, can be distinguished from true benign users via a Neyman-Pearson likelihood ratio test. Sweep noise scales to characterize the security-utility tradeoff: higher noise improves detection but degrades leaderboard accuracy. Measure detection rate of malicious users and utility degradation (avg absolute rank change) for each noise scale. | Data: Historical Chatbot Arena voting data and Bradley-Terry coefficient ratings | Baselines: Scenario 1 (unperturbed ratings, informed adversary) | Metrics: detection rate, utility = avg |rank_true(i) - rank_perturbed(i)| across all models | Results: Figures 5 and 6. Detection improves with noise; utility degrades (larger noise significantly changes ranking order)",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D3-007",
      "claim": "Measure the one-time offline cost (c_detector) of building the training-based target model detector. Cost is computed as sum of API token fees for collecting responses from all 22 models across 200 prompts (50 responses per model per prompt, 512 output tokens per response). Proprietary and open-source models use different API pricing tiers. | Data: 22 models: proprietary (via provider APIs: Anthropic, Google AI Studio, OpenAI) + open-source (via Together AI Inference API) | Baselines: Upper bound based on most expensive model pricing: proprietary $5.00/1M tokens, open-source $1.80/1M tokens | Metrics: total cost in USD | Results: ~$0.128 per proprietary model per prompt, ~$0.046 per open-source model per prompt; ~$2.2 per prompt total; ~$440 total for 200 prompts",
      "source": "Appendix A.3"
    },
    {
      "id": "voting-leaderboards-D3-008",
      "claim": "Ablation study on detector accuracy: vary the assumed detection accuracy of the training-based detector (1.0, 0.95, 0.9) and measure how the required number of adversarial votes and interactions changes for shifting a low-ranked model (llama-13b, initial rank #129) by 1 to 50 positions. Tests the sensitivity of attack cost to detector quality. | Data: Historical Chatbot Arena voting data, Target model: llama-13b (rank #129, 2443 base votes) | Baselines: detector_acc = 1.0 (perfect detector), detector_acc = 0.95 (main experiment baseline), detector_acc = 0.9 (degraded detector) | Metrics: number of adversarial votes and interactions required | Results: Table 8. Dropping accuracy from 1.0 to 0.9 increases required votes by only ~150 for a 50-position shift, suggesting even imperfect detectors remain effective",
      "source": "Appendix B.2, Table 8"
    },
    {
      "id": "voting-leaderboards-D3-009",
      "claim": "Ablation study on non-detection actions: when the attacker fails to detect the target model in the comparison pair (due to FNR or absence), evaluate four alternative strategies for the attacker's behavior. Measure how each strategy affects the number of interactions required to shift a model's ranking. Tests robustness of simulation results to the attacker's fallback behavior. | Data: Historical Chatbot Arena voting data, High-ranked target model: claude-3-5-sonnet-20240620 (rank #5, 7703 base votes), Low-ranked target model: llama-13b (rank #129, 2443 base votes) | Baselines: do_nothing (abstain, used in main experiments) | Metrics: number of interactions required to achieve target rank | Results: Table 9. No clear patterns indicating any strategy significantly outperforms others",
      "source": "Appendix B.2, Table 9"
    }
  ],
  "D4": [
    {
      "id": "voting-leaderboards-D4-001",
      "claim": "Method sequence: Identity-Probing Detector -> Training-Based Detector -> De-anonymization as Binary Classification",
      "source": "Section 2.1, Section 2.2"
    },
    {
      "id": "voting-leaderboards-D4-002",
      "claim": "Method sequence: Training-Based Detector — Data Collection and Feature Extraction -> Training-Based Detector — Logistic Regression Classifier -> De-anonymization as Binary Classification",
      "source": "Section 2.2, Section 2.3"
    },
    {
      "id": "voting-leaderboards-D4-003",
      "claim": "Method sequence: Malicious User Detection — Scenario 2: Neyman-Pearson Likelihood Ratio Test (Perturbed Ratings) -> Bradley-Terry Win Probability -> Pr_B(i) Computation from Bradley-Terry Ratings (Benign User Vote Distribution)",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D4-004",
      "claim": "Identity-Probing Detector evaluation phases: For each of the 5 identity-probing prompts: ->   For each of the 22 models: ->     Query each model 1,000 times with the prompt (use default decoding hyperparameters) ->     Apply string matching: response contains model_name (e.g., 'Llama') OR organization name (e.g., 'Meta') ->     Compute accuracy = (correct detections / 1000) * 100% -> Report per-model averaged accuracy across 1,000 queries for each prompt",
      "source": "Section 2.3, Section 2.4.1, Appendix B.1 (Table 7)"
    },
    {
      "id": "voting-leaderboards-D4-005",
      "claim": "Experiment phases: For each of the 8 prompt categories: ->   Sample 200 prompts from the category's source dataset ->   For each prompt P: ->     For each target model M in 22 models: ->       Step 1 - Data collection: ->         Query M 50 times with P (512 output tokens, default decoding params) ->         Query each other model, uniformly sample 50 responses total as negative ->         Build balanced dataset: 50 positive + 50 negative = 100 samples ->       Step 2 - For each of the 3 feature types independently: ->         Extract features: length(Response) OR BoW(Response) OR TF-IDF(Response) ->         Split: 80% train, 20% test (random_state=42) ->         Train: sklearn.linear_model.LogisticRegression(random_state=42, default hyperparams) ->         Evaluate: test accuracy on held-out 20% ->       Step 3 - Record test accuracy for this (P, M, feature_type) triplet ->   Average per-category accuracy across all 200 prompts per model -> Visualize BoW features: compute PCA on BoW vectors across all models' responses for 3 selected prompts",
      "source": "Section 2.3, Section 2.4.2"
    },
    {
      "id": "voting-leaderboards-D4-006",
      "claim": "Experiment phases: Step 1: Initialize Bradley-Terry coefficients from historical voting data -> Step 2: For each target model M and each objective (Up/Down by 1-4 positions): ->   Set target_rank = current_rank +/- displacement ->   While current_rank != target_rank: ->     Simulate 1 interaction: ->       Randomly sample 2 models for the comparison ->       Attacker applies de-anonymization (detection_accuracy=0.95, symmetric FPR/FNR=0.05) ->       If target model detected: cast adversarial vote (upvote or downvote) ->       Else: abstain (do nothing) ->       Increment interactions counter ->     Every 1,000 interactions: ->       Recompute Bradley-Terry coefficients from all votes (including injected adversarial votes) ->       Re-rank models ->   Record final (interactions, adversarial_votes) for this objective -> Step 3: Report results per target model per target rank",
      "source": "Section 3.1, Section 3.2, Appendix A.4"
    },
    {
      "id": "voting-leaderboards-D4-007",
      "claim": "Experiment phases: Same as high-ranked simulation protocol, applied to the 5 low-ranked target models (chatglm-6b rank #125, fastchat-t5-3b rank #126, stablelm-tuned-alpha-7b rank #127, dolly-v2-12b rank #128, llama-13b rank #129). Compare: low-ranked models require ~30% of votes needed by high-ranked models to move the same number of positions",
      "source": "Section 3.2, Table 5"
    },
    {
      "id": "voting-leaderboards-D4-008",
      "claim": "Experiment phases: Step 1: Estimate benign vote distribution Pr_B(i) from historical voting data -> Step 2: Simulate naive adversary: ->   For each target model, adversary always votes for target when detected ->   When target not in pair: randomly choose between the two non-targeted models ->   Compute likelihood L(x|H_benign) and test statistic T(x) for the observed vote sequence ->   Compute empirical p-value via m Monte Carlo simulations under H_benign ->   Flag as malicious when p < alpha=0.01 -> Step 3: Simulate informed adversary: ->   Adversary uses publicly available Bradley-Terry ratings to compute expected behavior ->   When target not in pair: vote proportionally to public rankings to mimic benign users ->   Repeat likelihood ratio detection process -> Step 4: Compare detection effectiveness for naive vs. informed adversary",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D4-009",
      "claim": "Experiment phases: Step 1: For each noise scale sigma in [sigma_min, ..., sigma_max]: ->   Generate perturbed ratings: Q'_i = Q_i + N(0, sigma^2) for each model i ->   Release Q'_i as the public leaderboard ->   Measure utility: avg |rank_true(i) - rank_perturbed(i)| across all models -> Step 2: Simulate adversary using perturbed ratings: ->   Compute Pr_negB(i) from perturbed Q'_i using Bradley-Terry formula ->   Generate adversarial vote sequences following Pr_negB(i) -> Step 3: Apply Neyman-Pearson likelihood ratio test: ->   Lambda(x) = Pr_negB(x) / Pr_B(x) ->   Flag as malicious when Lambda(x) > threshold (set by desired FPR) ->   Measure detection rate -> Step 4: Plot detection rate vs. utility for each noise scale",
      "source": "Section 4.2.3, Section 4.3"
    },
    {
      "id": "voting-leaderboards-D4-010",
      "claim": "Experiment phases: Step 1: Determine query method and pricing tier for each of the 22 models -> Step 2: For each prompt P (out of 200): ->   For each model M: ->     Query M with P, 512 output tokens, 50 times ->     Tally cost: cost += price_per_1M_tokens * (512 * 50) / 1e6 -> Step 3: Sum costs across all models and prompts -> Step 4: Report total c_detector and per-prompt cost breakdown",
      "source": "Appendix A.3"
    },
    {
      "id": "voting-leaderboards-D4-011",
      "claim": "Experiment phases: For each detector_acc in [1.0, 0.95, 0.9]: ->   For each rank shift target in [1, 2, 5, 10, 20, 50]: ->     Run the vote count simulation (same protocol as high-ranked and low-ranked rank-shift simulations) ->     with detection_accuracy = detector_acc ->     target_rank = 129 - rank_shift ->     Record (votes, interactions) upon achieving the target rank -> Compare vote counts across detector accuracy levels",
      "source": "Appendix B.2, Table 8"
    },
    {
      "id": "voting-leaderboards-D4-012",
      "claim": "Experiment phases: For each non_detection_strategy in [do_nothing, randomly_upvote_one, vote_tie, vote_tie_both_bad]: ->   For high-ranked model (claude-3-5-sonnet): ->     Run simulation with target rank shifts 1, 2, 3, 4 (up) ->     Record interactions required ->   For low-ranked model (llama-13b): ->     Run simulation with target rank shifts 1, 2, 5, 10, 20, 50 (up) ->     Record interactions required -> Compare: no clear patterns favoring any strategy over others",
      "source": "Appendix B.2, Table 9"
    }
  ]
}