GPQA: A Graduate-Level Google-Proof Q&A Benchmark
Paper • 2311.12022 • Published • 36
domain stringclasses 5
values | prompt stringlengths 409 9.12k | rubrics listlengths 6 15 | golden_answer stringlengths 1.14k 23.3k |
|---|---|---|---|
Machine Learning & Artificial Intelligence | # Hybrid Efficiency Block — Forward Pass Computation
A hybrid efficiency block processes $T = 4$ tokens in a $d = 8$-dimensional embedding space. The input $X \in \mathbb{R}^{4 \times 8}$ is sampled from `numpy.random.RandomState(37).randn(4, 8)`.
The block integrates four components. The input $X$ is first normalize... | [
{
"criterion": "Does the answer compute x_n[0,0] = -0.0638 and x_n[1,3] = 1.8106 from the RMSNorm step (values rounded to 4 decimal places)?",
"weight": 10
},
{
"criterion": "Does the answer compute y_ssm[0,0] = -0.3166 and y_ssm[2,3] = -0.1890 from the selective SSM recurrence (values rounded to 4 ... | ## Step 1: RMSNorm
Compute $\text{RMS}[i] = \sqrt{\frac{1}{8}\sum_j X[i,j]^2 + 10^{-5}}$, then $x_n[i,:] = X[i,:] / \text{RMS}[i]$.
- Token 0: $\text{RMS} = 0.85387136$, $x_n[0] = [-0.06378433,\; 0.78970686,\; 0.40597102,\; -1.52288300,\; 1.77838484,\; 1.15921877,\; 0.32520226,\; -0.52535941]$
- Token 1: $\text{RMS} ... |
Computer Systems & Operating Systems | # Distributed Operating Systems - Coordinated Execution Analysis (Deterministic Trace, Derived-Constants Spec)
## 0) Reading rules (AUTHORITATIVE)
This document contains:
- AUTHORITATIVE rules (must be followed)
- LEGACY notes (included for realism; must be ignored if they conflict)
If any statement conflicts, AUTHO... | [
{
"criterion": "Does the answer contain the exact line 'SNAPSHOT_TIMES_MS = [0,10,35,48,50]'?",
"weight": 5
},
{
"criterion": "Does the answer contain the exact line 'INTERVALS = [[0,10),[10,12),[12,20),[20,28),[28,30),[30,35),[35,38),[38,40),[40,45),[45,46),[46,48),[48,50)]'?",
"weight": 5
},... | ## 1) Compute derived timestamps from Q=10 and HALFQ=5
Q=10, HALFQ=5, ONE=1, TWO=2
t_P3_spawn = Q + TWO = 12
t_gc_read = 2*Q + (Q - TWO) = 20 + 8 = 28
t_pf_start = 28
t_pf_end = t_pf_start + Q = 28 + 10 = 38
t_timeout = 4*Q + HALFQ = 40 + 5 = 45
t_sleep_end = t_timeout + ONE = 46
t_cleanup_end = t_sleep_end + TWO = 4... |
Algorithms & Data Structures | ## Problem
You are given an `n × m` grid (`1 ≤ n,m ≤ 200`) filled with digits `0..9`.
For each digit `d` (`0..9`), you are also given a move vector `(a[d], b[d])` (each component in `[-200,200]`).
Define Wilbur’s movement rule:
- If Wilbur is currently at cell `(x,y)` and the digit there is `d`, then his **forced n... | [
{
"criterion": "The answer models the forced movement as a directed graph on the grid cells in which every vertex has outdegree exactly 1.",
"weight": 10
},
{
"criterion": "The answer states that when the forced next position is outside the grid, the transition is a self-loop (the cell transitions t... | ### 1) Build the functional graph of forced moves
Index each cell `(x,y)` as a vertex `v` (total `V = n*m ≤ 40000`).
Let `dig[v]` be its digit.
Compute the forced transition `to[v]`:
- Let `d = dig[v]`.
- Candidate `(nx, ny) = (x + a[d], y + b[d])`.
- If inside the grid: `to[v] = id(nx,ny)`, else `to[v] = v` (self-... |
Algorithms & Data Structures | You are given a tree with `n` vertices (`1` to `n`). Vertex `v` has color `c_v ∈ [1..n]`.
A simple path is **beautiful** if:
1. it has at least 2 vertices;
2. its endpoints have the same color;
3. no other vertex on the path has that endpoint color.
Paths are **undirected**.
### Input
- `n` (`2 ≤ n ≤ 2·10^5`)
- colo... | [
{
"criterion": "Does the answer define a rooted tree (choose any root, e.g. 1) and process vertices in postorder (children before parent)?",
"weight": 10
},
{
"criterion": "Does the answer define cnt[v][x] as the number of vertices of color x in subtree(v) such that the path from v to that vertex co... | ### Expert Solution
Root the tree arbitrarily (e.g. at vertex 1) and process vertices in postorder.
#### 1) Top-level counts
For each vertex `v`, maintain a map `cnt[v]` where:
`cnt[v][x] = #{ w ∈ subtree(v) : c_w = x and there is no other x on the path v → w }`
So `w` is **`x`-top-level w.r.t. `v`**.
This “top-le... |
Algorithms & Data Structures | ## Problem: Maximum Possible Score of One Player Under Greedy Picks
You are given `n` distinct items labeled `1..n`, with exactly one copy of each item. Each item `i` has an integer score `v[i]` (scores may be negative).
Two players, **A** and **B**, each have a complete ranking (a permutation) of the items:
- `A[1.... | [
{
"criterion": "Does the response define p[i] as Bob’s position of item a[i] in Bob’s permutation?",
"weight": 10
},
{
"criterion": "Does the response state the DP initialization dp[0] = 0?",
"weight": 10
},
{
"criterion": "Does the response state that the final answer equals max(dp[j]) ... | ### 1) Renaming so that Alice’s list becomes `1,2,...,n`
Let the original item IDs be `1..n`. Define:
- `a[1..n]`: Alice’s permutation (most preferred first)
- `b[1..n]`: Bob’s permutation
- `v[id]`: value of item `id`
Relabel items by **Alice-rank**:
- The item with Alice-rank `i` is `id = a[i]`.
- Define `val[i] ... |
Algorithms & Data Structures | You have a strip of `1 × 10^9` cells numbered `1` to `10^9`.
There are `n` snakes (numbered `1` to `n`). Initially, each snake occupies exactly one cell, and no two snakes can be placed in the same cell. After placement, the game runs for `q` seconds. Each second exactly one event occurs:
- **Snake `s_i` enlarges:** ... | [
{
"criterion": "Does the solution state the final answer as min over last of ( d[(1<<n)-1][last] + plusCount[last] ), where plusCount[k] is the number of '+' events of snake k?",
"weight": 20
},
{
"criterion": "Does the solution state the score for a fixed permutation p1..pn as 1 + (sum of gaps betw... | ## Expert Answer
Key idea: placing snakes left-to-right defines a permutation; for any fixed order the best placement is greedy (minimum feasible gaps), and we can compute the required minimum gaps from the event log.
### 1) Reduce to an order (permutation)
In any valid placement, the snakes appear left-to-right in s... |
Algorithms & Data Structures | ## Problem
Denis defines a non-commutative “multiplication” of strings.
For a string `s` of length `m` and a string `t`, define:
\[
s \cdot t = t + s_1 + t + s_2 + \dots + t + s_m + t
\]
where \(s_i\) is the \(i\)-th character of `s`, and `+` means concatenation.
Examples:
- `"abc" ⋅ "de" = "deadebdecde"`
- `"ab"... | [
{
"criterion": "The answer states that the operation satisfies associativity: (a·b)·c = a·(b·c).",
"weight": 10
},
{
"criterion": "The answer computes the product by folding from right to left using P_n = p_n and P_i = p_i · P_{i+1}?",
"weight": 10
},
{
"criterion": "The answer introduce... | ### 1) Use associativity and fold from right to left
The operation is associative:
\[
(a\cdot b)\cdot c = a\cdot(b\cdot c)
\]
(you can verify by expanding both sides; both produce alternating blocks of the right operand with single characters of the left operands inserted in the same order).
So instead of building th... |
Algorithms & Data Structures | An autonomous vehicle navigation system uses a bidirectional time-dependent Dijkstra algorithm to compute an optimal route on a directed graph
G with 12 nodes labeled N0 through N11 and the following directed edges with base travel times in seconds:
(N0,N1,45), (N0,N2,60), (N1,N3,50), (N1,N4,70), (N2,N4,55), (N2,N5,80... | [
{
"criterion": "Does the answer state the forward expansion sequence exactly as [N0, N1, N2, N3, N5, N4, N6, N8, N9]?",
"weight": 20
},
{
"criterion": "Does the answer state the backward expansion sequence exactly as [N11, N10, N9, N7, N6, N8, N5, N4]?",
"weight": 20
},
{
"criterion": "D... | (1) Forward Expansion Sequence
Forward search starts at N0 at time t = 0 and applies time-dependent weights.
Expand N0 (0)
→ insert N1(45), N2(60)
Expand N1 (45)
→ insert N3(95), N4(171) [70 × 1.8 due to N4 window]
Expand N2 (60)
→ update N4(159) [55 × 1.8], insert N5(140)
Expand N3 (95)
→ insert N6(160)
Expand N... |
Algorithms & Data Structures | A miner is searching a rooted underground shaft system that forms a **tree** of `n` chambers (nodes) connected by one-way-less tunnels (undirected edges). A single phantom hides in exactly one chamber; initially it may be in any chamber. The miner can perform two kinds of actions. After each action, the phantom may (or... | [
{
"criterion": "Does the solution include a postorder coloring procedure that specifies how to label each node as 'green', 'yellow', or 'black' using only information from its children?",
"weight": 10
},
{
"criterion": "Does the solution assert that after removing every node labeled 'black', every c... | **Idea in one line.**
Cut a carefully chosen small set of nodes so the remaining connected pieces are simple paths, then “sweep” each path by checking its nodes from one end to the other. Do all cuts first (they only restrict the phantom), then do the sweeps. The number of cuts is at most `⌊n/4⌋`, so the total number... |
Algorithms & Data Structures | An Arbor Network is an undirected, connected, acyclic graph (i.e., a tree) with N junctions numbered 1 through N.
Every morning, R rival couriers traverse the network simultaneously. Rival i starts at junction s_i and travels to junction t_i along the unique shortest path in the tree. If that path is the vertex sequen... | [
{
"criterion": "Does the answer explicitly state the finite search horizon bound t* ≤ 2N + 1?",
"weight": 1
},
{
"criterion": "Does the answer explicitly define a forbidden pair (u, t) as: some rival occupies vertex u at integer time t during its travel?",
"weight": 1
},
{
"criterion": "... | Explicit finite time horizon: t* ≤ 2N + 1
Let t* be the earliest arrival time at B among all collision-free schedules, if any exist.
Claim. If a collision-free schedule exists, then t* ≤ 2N + 1.
Reason (sketch). Each rival walks a simple tree path of length at most N, so all rivals have finished moving by time ≤ N, h... |
Algorithms & Data Structures | Consider an n x m grid (2 <= n <= 12, 2 <= m <= 1000) where some cells are blocked. A Hamiltonian path visits every non-blocked cell exactly once. The task is to count Hamiltonian paths from cell (0,0) to cell (n-1, m-1), modulo 10^9+7. The grid is given as n lines of m characters where '.' is empty and '#' is blocked.... | [
{
"criterion": "The response states that the broken profile has exactly n+1 plug positions for an n-row grid, and describes the profile as consisting of n horizontal segments and 1 vertical segment (or equivalently as a staircase or L-shaped boundary).",
"weight": 10
},
{
"criterion": "The response ... | 1. PROFILE STRUCTURE:
The broken profile is the boundary between processed cells (above and to the left of the current cell in column-major order) and unprocessed cells (below and to the right). It forms a staircase or L-shaped boundary consisting of exactly n horizontal segments and 1 vertical segment. The profile has... |
Algorithms & Data Structures | You are fighting a vertical column of `n` enemies arranged in a single stack.
- Enemy `1` is at the bottom, enemy `n` is at the top.
- Enemy `i` starts with health `h[i]`.
### Attack rule
In one hit, you may choose **any currently alive enemy** (in any stack that exists at that moment) and reduce its health by `1`.
... | [
{
"criterion": "Does the answer define dp[i] as the minimum number of attacks needed to eliminate mobs 1 through i?",
"weight": 10
},
{
"criterion": "Does the answer state that the final output for a test case equals dp[n]?",
"weight": 10
},
{
"criterion": "Does the answer state that a m... | ### Key observations
1. **A creature can receive fall damage at most once.**
After it falls, it becomes the bottom of its new stack, and nothing can later fall “under it” again.
2. **If a creature ever receives fall damage greater than 1,** then the creature directly below it must have been killed by sword hits (... |
Algorithms & Data Structures | You are given a tree with `n` nodes. Node `i` has an allowed initial value interval `[l_i, r_i]`.
You choose initial values `a_i` such that:
`l_i ≤ a_i ≤ r_i`
A tree is **balanced** if all node values are equal; the balanced value is that common value.
**Operation:** choose two nodes `u` and `v`. Consider the tree ro... | [
{
"criterion": "Does the answer state that for an edge between parent p and child v (in a chosen rooting), choosing (u=p,v=v) increases (a_v−a_p) by 1 and choosing (u=v,v=p) decreases (a_v−a_p) by 1 (i.e., one operation changes the edge difference by exactly ±1)?",
"weight": 10
},
{
"criterion": "Do... | ### Expert Solution
Root the tree at node `1`. Let `p(v)` be the parent of `v`.
---
### A) Final balanced value for fixed initial values `a`
Consider an edge `(p, v)`.
An operation “increment subtree of `v` when rooted at `u`” can be used in two relevant ways for this edge:
- Choose `u = p`, `v = v`: increments t... |
Algorithms & Data Structures | ## Problem: Eliminate “+1 Later” Conflicts
You are given an integer sequence `a` of length `n`. Call a sequence `b` **valid** if there are **no** positions `i < j` such that:
\[
b_j = b_i + 1
\]
In other words, you must avoid any situation where a value appears and **somewhere later** a value exactly **one larger** ... | [
{
"criterion": "Does the answer state the forbidden pattern as existence of indices i<j with b[j] = b[i] + 1?",
"weight": 1
},
{
"criterion": "Does the answer sort the pair list by value in non-decreasing order?",
"weight": 1
},
{
"criterion": "Does the answer define dp[i] as the maximum... | ### Key reformulation
We want to keep as many elements as possible. Let `keep` be the maximum size of a subsequence that is **good**; then the answer is:
\[
\text{removed} = n - keep
\]
A subsequence is **not good** exactly when it contains two chosen indices `p<q` with `a[q]=a[p]+1`.
So, if we choose some elements o... |
Programming Languages, Compilers & Formal Methods | You are given a linear scan register allocation problem with 3 physical registers: R0, R1, R2.
Live intervals for virtual registers:
V0: [0,7]
V1: [1,5]
V2: [2,9]
V3: [3,6]
V4: [4,11]
V5: [6,10]
V6: [8,14]
V7: [10,13]
V8: [12,15]
V9: [1,3]
Use the following deterministic rules:
1. Process intervals in ascending ord... | [
{
"criterion": "Lists the processing order exactly as V0, V9, V1, V2, V3, V4, V5, V6, V7, V8.",
"weight": 15
},
{
"criterion": "States that the total number of spill events is exactly 2.",
"weight": 10
},
{
"criterion": "Identifies the first spill event as V2.",
"weight": 10
},
{... | Processing Order: V0, V9, V1, V2, V3, V4, V5, V6, V7, V8
Spill Events: V2, V4
Active Count 3 At: 1, 2, 3, 4, 12
Final Register Assignments:
V0 -> R0
V1 -> R2
V3 -> R1
V5 -> R1
V6 -> R0
V7 -> R1
V8 -> R2
V9 -> R1
Explanation
Step 1: Determine processing order
Intervals are sorted by increasing start point, and ties a... |
Algorithms & Data Structures | Steve is trapped in a tunnel filled with hostile creepers. There are n creepers standing in a straight line, indexed from 1 to n.
For each position i, the creeper at that position has an explosive power e_i.
We use the term “creepers” consistently throughout; all entities referred to are the same.
Explosion Rule:
If ... | [
{
"criterion": "Does the answer explicitly define the detonation interval of creeper i as [i − e_i + 1, i + e_i − 1]?",
"weight": 10
},
{
"criterion": "Does the answer state that two creepers cannot both be detonated if one lies inside the other’s detonation interval ?",
"weight": 10
},
{
... | Notation:
We use e_i to denote the explosive power of the creeper at position i, exactly as defined in the task prompt.
Detonation Interval:
Detonating creeper i kills all creepers in the interval:
[i − e_i + 1, i + e_i − 1]
Two creepers cannot both be detonated if their detonation intervals overlap in a way that one... |
Algorithms & Data Structures | # Odd-Quorum Rewrite Maximization — Extended Deterministic Output
You are given `t` test cases. In each test case:
- an array `a` of `n` **positive integers**
- a positive integer `k`
You may apply a "rewrite" operation that overwrites selected elements by a median.
---
## Rewrite game (per test case)
1. Choose on... | [
{
"criterion": "The reasoning contains an exhaustive enumeration of F(i, y) for every valid (i, y) pair in every one of the five test cases, i.e. for each test case and for every i in [1, n] every y in [0, min(i-1, n-i)] is listed together with its computed L, leftGain, rightLoss, and F(i, y) value. A partial e... | # Golden Answer
## Approach
We follow the computation path mandated by the prompt: sort the array, build prefix sums, apply the fixed reduction `F(i, y) = S + L·b[i] - p[L] - (p[i+y] - p[i]) + y·b[i]` with `L = min(k·y, i-1)`, and then **exhaustively enumerate every valid `(i, y)` pair** with `1 ≤ i ≤ n` and `0 ≤ y ≤... |
Computer Systems & Operating Systems | # PROMPT
Simulate Tomasulo's Algorithm for out-of-order execution with the following configuration:
EXECUTION LATENCIES (by instruction type):
- ADD/SUB: 2 cycles
- MUL: 4 cycles
- DIV: 8 cycles
- LOAD: 3 cycles (includes memory access)
RESERVATION STATIONS:
- 3 Add/Sub stations: Add1, Add2, Add3
- 2 Mul/Div station... | [
{
"criterion": "The response states that I3 (MUL) begins execution in exactly cycle 7.",
"weight": 10
},
{
"criterion": "The response states that I5 (DIV) writes its result in exactly cycle 20.",
"weight": 10
},
{
"criterion": "The response states that the sum of write cycles for all 8 i... | # GOLDEN ANSWER
## Step-by-step Trace
**I1: LOAD F2, 0(R1)** - Issues cycle 1 to Load1. R1 always ready, no data dependency. Cannot execute same cycle as issue (Rule 6), so execution starts cycle 2. Execution latency = 3 cycles: executes cycles 2-4. Writes cycle 5. F2 available from cycle 5 (usable for execution star... |
Algorithms & Data Structures | Construct and analyze the FM-index of a cipher-transformed string.
Original: S = "abracadabra" (length 11)
Cipher at 0-indexed position i, where each character's alphabetic position is p (a=0, b=1, ..., z=25):
- i mod 3 = 0: shift forward by (i mod 5), i.e., new position = (p + (i mod 5)) mod 26
- i mod 3 = 1: shift... | [
{
"criterion": "The response correctly transforms S = 'abracadabra' to produce T' = 'azidczeyyva' (before appending '$'), yielding T = 'azidczeyyva$'.",
"weight": 10
},
{
"criterion": "The response identifies that the characters 'b' and 'r' from S do not appear in the transformed string T'.",
"w... | PHASE 1: CIPHER TRANSFORMATION
Original: S = "abracadabra" (length 11)
Rules:
- i mod 3 = 0: new_p = (p + (i mod 5)) mod 26
- i mod 3 = 1: new_p = (p - ((i*2) mod 4)) mod 26
- i mod 3 = 2: new_p = 25 - p
Character-by-character:
i=0: 'a' (p=0) Rule 0: shift = 0 mod 5 = 0. new_p = (0+0) mod 26 = 0 -> 'a'
i=1: 'b... |
Algorithms & Data Structures | You are given `k` simple undirected graphs `G1..Gk` on the *same* labeled vertex set `V = {1,2,...,n}`.
We say a graph `Q` is a **blow-up pattern** (called a *fun graph*) of a graph `H` if there exists a partition of `V(H)` into `|V(Q)|` nonempty parts, one part per vertex of `Q`, such that:
1. Each part induces eith... | [
{
"criterion": "Does the solution define a Type-A twin pair as a nonedge pair (a,b) with identical open neighborhoods?",
"weight": 10
},
{
"criterion": "Does the solution define a Type-B twin pair as an edge pair (a,b) with identical closed neighborhoods?",
"weight": 10
},
{
"criterion":... | ## Expert Solution (DSA — Graphs / 2-SAT)
### Key structural notion: twins inside `Gi`
Fix one graph `Gi` on vertex set `{1..n}`.
- **Type-A twin pair (open twins):** vertices `a ≠ b` such that
`ab ∉ E(Gi)` and `N(a) = N(b)` (open neighborhoods identical).
- **Type-B twin pair (closed twins):** vertices `a ≠ b`... |
Algorithms & Data Structures | You are given an undirected connected graph G with n vertices and exactly n edges. The graph has no self-loops and no multiple edges. All edges have unit weight. Each edge has a state: **on** or **off**. Initially all edges are **off**.
You are given m queries (v, u). For each query, you must **toggle** (change on to ... | [
{
"criterion": "For the input \"6 3\\n1 2\\n2 3\\n3 4\\n4 1\\n2 5\\n4 6\\n2 4\\n5 6\\n3 1\\n\", does the answer output exactly \"4\\n4\\n2\"?",
"weight": 15
},
{
"criterion": "For the input \"5 4\\n1 2\\n2 3\\n3 1\\n3 4\\n4 5\\n1 2\\n2 3\\n1 3\\n5 1\\n\", does the answer output exactly \"4\\n3\\n3\\... | ## 1) Graph structure
A connected graph with n vertices and n edges contains exactly one simple cycle. All other edges are bridges forming trees attached to cycle vertices.
Let:
- C = set of cycle vertices, k = |C|
- onTreeEdges = number of ON edges not on the cycle
- onCycleEdges = number of ON edges on the cycle
##... |
Machine Learning & Artificial Intelligence | A Deep Belief Network processes 784-dimensional inputs to 10 output classes. The architecture connects Input → L1 → L2 → L3 → Output, where each connection has a weight matrix.\n\n**Configurations:**\n\n| Config | L1 | L2 | L3 | η | k | epochs |\n|--------|-----|-----|-----|------|---|--------|\n| A | 500 | 500 | 500 |... | [
{
"criterion": "The response states that Config K is the optimal valid configuration.",
"weight": 10
},
{
"criterion": "The response states that Config K has Ψ equal to 71.0 or a value between 70.9 and 71.1.",
"weight": 10
},
{
"criterion": "The response derives that M equals 0.002 multi... | Solution: DBN Configuration Optimization
Step 1: Derive the Memory formula
Calculate total parameters P for each calibration config:
- Config A: P = 784×500 + 500×500 + 500×500 + 500×10 = 897,000
- Config B: P = 784×600 + 600×400 + 400×200 + 200×10 = 792,400
- Config D: P = 784×580 + 580×480 + 480×380 + 380×10 = 919,... |
End of preview. Expand in Data Studio
Rubrics-Graded Reasoning — Computer Science, Data Science, Chemistry
A multi-domain reasoning dataset built to improve frontier models by revealing their failures and turning expert grading into training signal.
The dataset pairs self-contained tasks with weighted rubrics across three domains — Computer Science, Data Science, and Chemistry — turning expert evaluation into training signals that boost frontier-model reasoning.
Explore the full Rubric-based reasoning data pack: https://go.turing.com/advanced-reasoning-rubrics
Goal
This release exists to showcase Turing's rubrics-based advanced PhD-level reasoning datasets capability. Every task is the product of doctoral-level expert authorship and review, paired with atomic process-level rubrics that turn correctness into machine-verifiable signal. The 150 tasks here (50 per domain) are a public sample of the methodology and quality bar Turing applies across thousands of RL tasks delivered to frontier-model partners.
Why This Dataset
Standard benchmarks are useful, but they are limited for model improvement when scoring is mostly final-answer based, reasoning visibility is partial, or process-level rubrics are missing. This dataset addresses those gaps with three strengths:
- Productive difficulty: 0%–50% pass rates across 16 evaluation rounds against recent frontier models.
- Visible reasoning: open-ended tasks stress derivations, mechanisms, calculations, units, and structure/product identification.
- Training signal: atomic weighted rubrics score both final answers and intermediate reasoning steps.
This dataset is high-quality with unique prompts, weighted rubrics, expert-authored content, and broad domain coverage.
Configurations
The repository contains three configurations:
| Config | Tasks | Schema |
|---|---|---|
Rubric-CS |
50 | domain, prompt, rubrics, golden_answer |
Rubric-DS |
50 | domain, prompt, rubrics, golden_answer, datasets |
Rubric-Chem |
50 | domain, prompt, rubrics, golden_answer |
Load any configuration with:
from datasets import load_dataset
cs = load_dataset("TuringEnterprises/Rubric-Graded-Reasoning", "Rubric-CS")
ds = load_dataset("TuringEnterprises/Rubric-Graded-Reasoning", "Rubric-DS")
chem = load_dataset("TuringEnterprises/Rubric-Graded-Reasoning", "Rubric-Chem")
print(cs["train"][0]["prompt"])
print(cs["train"][0]["rubrics"])
Each rubrics entry is an object with two fields:
criterion— one atomic verification criterionweight— relative score weight for that criterion
Rubric-CS — Computer Science
A sample of off-the-shelf rubric-based reasoning data covering algorithms, systems, databases, machine learning, and programming languages / compilers.
Every task was authored and reviewed by subject-matter experts, paired with atomic weighted rubrics that target precise correctness and intermediate reasoning, and accompanied by a golden_answer that derives every quantity from first principles.
CS Subdomain Coverage
| Subdomain | Tasks |
|---|---|
| Algorithms & Data Structures | 33 |
| Computer Systems & Operating Systems | 8 |
| Machine Learning & Artificial Intelligence | 4 |
| Programming Languages, Compilers & Formal Methods | 3 |
| Database Systems & Data Engineering | 2 |
Tasks span classical material (recovery protocols, scheduling, cache coherence, complexity bounds) and modern engineering scenarios (distributed storage, kernel simulation, model architectures, compiler IR transformations).
Rubric-DS — Data Science
A sample of off-the-shelf rubric-based reasoning data covering real-world analytical scenarios across business operations, finance, healthcare, supply chain, HR analytics, scientific research, and IT operations.
Most tasks are grounded in a real dataset (referenced by the datasets field) — a small number of tasks (e.g., simulation or estimator-comparison problems) have no companion files and operate entirely on prompt-provided parameters. The model is expected to read the data (when provided), design and execute a multi-step analysis, and produce a structured output. The golden_answer is a runnable, deterministic implementation of the full pipeline.
DS Subdomain Coverage
| Subdomain | Tasks |
|---|---|
| Business Operations & Analytics | 23 |
| Financial & Accounting | 10 |
| Science, Environment & Research | 6 |
| Healthcare | 4 |
| Inventory & Supply Chain | 3 |
| Human Resources & Employee Management | 3 |
| IT & Support | 1 |
Data Files
Each DS task references one or more data files in its datasets field. The companion files live in Rubric-DS/files/<descriptive_name>/ inside the repository, with one subfolder per task named after the task's analytical context:
Rubric-DS/files/
├── financials_inverse_valuation_signal/
│ └── Financials.csv
├── orders_data_quality_risk_ranking/
│ ├── Orders.csv
│ └── Details.csv
├── hospital_staffing_optimization/
│ ├── doctors.csv
│ ├── locums.csv
│ ├── patients.csv
│ └── ...
└── ...
Resolve a relative path against the repo root:
import os
from huggingface_hub import snapshot_download
from datasets import load_dataset
# Get the repo files (data.jsonl + the actual CSVs)
repo_root = snapshot_download(repo_id="TuringEnterprises/Rubric-Graded-Reasoning",
repo_type="dataset")
ds = load_dataset("TuringEnterprises/Rubric-Graded-Reasoning", "Rubric-DS")
task = ds["train"][0]
for file_ref in task["datasets"]:
full_path = os.path.join(repo_root, file_ref)
# ... read the file at full_path with pandas / csv / etc.
Rubric-Chem — Chemistry
A chemistry reasoning subset pairing self-contained tasks with weighted rubrics, turning expert evaluation into training signals that boost frontier-model reasoning. This subset is the 50-task curated demo of a larger 500-task chemistry rubric corpus.
Comparison to Other Chemistry Benchmarks
| Benchmark | Reasoning Visibility | Process-Level Rubrics | RL Training Value |
|---|---|---|---|
| MMLU Chemistry | Low: mostly final-answer selection | No | Low for frontier-model improvement |
| GPQA Chemistry | Medium: expert-level questions, limited reasoning trace | No | Useful for hard eval, limited for process supervision |
| ChemBench | Medium: broad chemistry coverage | Varies by task | Useful for eval, less compact for RL reward data |
| Rubric-Chem | High: derivations, mechanisms, calculations, and units | Yes: atomic weighted rubrics | High: final-answer and process-credit reward signals |
Chemistry Subset Coverage
The 50-task demo subset is deliberately broad, sampling across the full breadth of chemistry rather than concentrating on any single subfield. Tasks span 37 distinct subdomains spanning organic, inorganic, organometallic, polymer, physical, and analytical chemistry:
Analytical chemistry, Biochemical redox chemistry, Boron cluster chemistry, Chemical kinetics, Combustion spectroscopy, Computational chemistry, Coordination chemistry, Electron-transfer kinetics, Heterocyclic synthesis, Inorganic main-group chemistry, Kinetic theory, Liquid-phase equilibrium, Main-group chemistry, Medicinal organic chemistry, Nuclear / reactor chemistry, Organic / heterocyclic chemistry, Organic redox chemistry, Organic synthesis, Organic synthesis / HRMS, Organogallium chemistry, Organometallic chemistry, Organometallic synthesis, Photopolymerization, Physical chemistry, Polymer chemistry, Polymer kinetics, Polymer networks, Polymer physical chemistry, Polymer statistics, Quantum chemistry, Reaction dynamics, Solution kinetics, Statistical thermodynamics, Supramolecular coordination chemistry, Thermal analysis / materials, Thermodynamics, Thermodynamics / heat recovery.
The full 500-task dataset extends this rubric-based coverage across all subfields. This demo includes quantitative tasks (kinetics, thermodynamics, spectroscopy, polymer calculations) and structural/mechanistic tasks (reaction pathways, product identification, organometallic structure, electrochemical synthesis, pharmacophore analysis).
Intended Uses
- RL reward modeling and post-training
- Process-level evaluation across CS, DS, and Chemistry
- Model comparison and regression testing
- Reasoning failure analysis for scientific and engineering QA systems
Authors
Juhi Parekh, Nicolas Morant, Jiyuan Liu, Gabriel Araujo, Govind K Rajesh, Ben Steinberg, Anubhav Elhence and the Pearl team at Turing Enterprise.
Citation
@dataset{turing_2026_rubric_graded_reasoning,
title = {Rubric-Graded-Reasoning: A Curated Multi-Domain Reasoning Dataset for Advancing Frontier LLMs},
author = {
Parekh, Juhi and
Morant, Nicolas and
Liu, Jiyuan and
Araujo, Gabriel and
K Rajesh, Govind and
Steinberg, Ben and
Elhence, Anubhav and
Pearl Team at Turing Enterprise
},
year = {2026},
publisher = {Hugging Face}
}
Contact
For inquiries, please open a discussion on the dataset repository.
License
MIT
- Downloads last month
- -