Dataset Viewer
Auto-converted to Parquet Duplicate
model
stringclasses
3 values
task_id
stringlengths
12
17
scenario_id
stringclasses
8 values
generated_program
stringlengths
86
3.64k
executed_on_seed42
bool
2 classes
correct_seed42
bool
2 classes
correct_seed7
bool
2 classes
correct_seed123
bool
2 classes
claude-haiku-4-5
market01_l1_029
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] return df['order_value'].sum()
true
true
true
true
claude-haiku-4-5
market01_l1_030
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] return df['order_value'].mean()
true
true
true
true
claude-haiku-4-5
market01_l1_031
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] return df['seller_id'].nunique()
true
true
true
true
claude-haiku-4-5
market01_l2_032
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Group by category and sum the order_value category_order_value = df.groupby('category')['order_value'].sum() # Find the category with the highest total order_value highest_category = category_order_value.idxmax() ...
true
true
true
true
claude-haiku-4-5
market01_l2_033
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Filter for eligible records (non-null seller_id based on schema) eligible = df[df['seller_id'].notna()] # Group by category and sum the order_value category_order_value = eligible.groupby('category')['order_value'].sum() ...
true
true
null
null
claude-haiku-4-5
market01_l2_034
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Group by category and sum the order_value category_order_value = df.groupby('category')['order_value'].sum() # Find the category with the highest total order_value highest_category = category_order_value.idxmax() ...
true
true
true
false
claude-haiku-4-5
market01_l2_035
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Filter for eligible records - assuming eligible means order_status is not 'returned' # and order_date represents the current period (all records are considered current) eligible_df = df[df['order_status'] != 'returned'].copy() ...
true
true
true
false
claude-haiku-4-5
market01_l2_036
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Filter for eligible records (non-null seller_id) eligible = df[df['seller_id'].notna()] # Group by category and sum order_value category_order_value = eligible.groupby('category')['order_value'].sum() # Find categ...
true
true
false
false
claude-haiku-4-5
market01_l2_037
market01
def analyze(tables: dict) -> object: df = tables['seller_orders'] # Filter eligible records - assuming eligible means non-null seller_id eligible_df = df[df['seller_id'].notna()] # Group by category and sum order_value category_order_value = eligible_df.groupby('category')['order_value'].s...
true
false
false
false
claude-haiku-4-5
market01_l3_038
market01
def analyze(tables: dict) -> str: df = tables['seller_orders'] # Convert order_date to datetime df['order_date'] = pd.to_datetime(df['order_date']) # Filter for 2025 orders df_2025 = df[df['order_date'].dt.year == 2025] # Filter for eligible orders (assuming "eligible" means not r...
true
false
true
false
claude-haiku-4-5
market01_l4_039
market01
def analyze(tables: dict) -> object: import pandas as pd df = tables['seller_orders'] # Convert order_date to datetime df['order_date'] = pd.to_datetime(df['order_date']) # Extract year and quarter df['year'] = df['order_date'].dt.year df['quarter'] = df['order_date'].dt.quart...
true
true
true
true
claude-haiku-4-5
market01_l4_040
market01
def analyze(tables: dict) -> object: import pandas as pd df = tables['seller_orders'] # Convert order_date to datetime df['order_date'] = pd.to_datetime(df['order_date']) # Extract year and quarter df['year'] = df['order_date'].dt.year df['quarter'] = df['order_date'].dt.quart...
true
false
true
true
claude-haiku-4-5
mktg01_l1_053
mktg01
def analyze(tables: dict) -> object: campaigns = tables['campaigns'] return campaigns['spend'].sum()
true
true
true
true
claude-haiku-4-5
mktg01_l1_054
mktg01
def analyze(tables: dict) -> object: campaigns = tables['campaigns'] mean_spend = campaigns['spend'].mean() return round(mean_spend, 2)
true
false
false
false
claude-haiku-4-5
mktg01_l1_055
mktg01
def analyze(tables: dict) -> object: campaigns_df = tables['campaigns'] count_distinct_campaign_id = campaigns_df['campaign_id'].nunique() return count_distinct_campaign_id
true
true
true
true
claude-haiku-4-5
mktg01_l2_056
mktg01
def analyze(tables: dict) -> object: campaigns = tables['campaigns'] channel_spend = campaigns.groupby('channel')['spend'].sum() highest_channel = channel_spend.idxmax() return highest_channel
true
true
true
true
claude-haiku-4-5
mktg01_l2_057
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Group by channel and sum the spend channel_spend = df.groupby('channel')['spend'].sum() # Find the channel with the highest total spend highest_channel = channel_spend.idxmax() return highest_channel
true
false
false
true
claude-haiku-4-5
mktg01_l2_058
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Filter for 2025 data df['event_date'] = pd.to_datetime(df['event_date']) df_2025 = df[df['event_date'].dt.year == 2025] # Group by channel and sum the spend channel_spend = df_2025.groupby('channel')['spend'].sum() ...
true
true
true
true
claude-haiku-4-5
mktg01_l2_059
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Filter for 2025 records df['event_date'] = pd.to_datetime(df['event_date']) df_2025 = df[df['event_date'].dt.year == 2025] # Group by channel and sum spend channel_spend = df_2025.groupby('channel')['spend'].sum() ...
true
false
false
false
claude-haiku-4-5
mktg01_l2_060
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Filter for 2025 records df['event_date'] = pd.to_datetime(df['event_date']) df_2025 = df[df['event_date'].dt.year == 2025] # Group by channel and sum spend channel_spend = df_2025.groupby('channel')['spend'].sum() ...
true
true
true
false
claude-haiku-4-5
mktg01_l2_061
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Filter for 2025 records df['event_date'] = pd.to_datetime(df['event_date']) df_2025 = df[df['event_date'].dt.year == 2025] # Group by channel and sum the spend channel_spend = df_2025.groupby('channel')['spend'].sum().sort...
true
false
false
false
claude-haiku-4-5
mktg01_l3_062
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Filter for 2025 records df['event_date'] = pd.to_datetime(df['event_date']) df_2025 = df[df['event_date'].dt.year == 2025] # Group by channel and calculate average spend and count channel_stats = df_2025.groupby('channel')...
true
false
true
true
claude-haiku-4-5
mktg01_l4_063
mktg01
def analyze(tables: dict) -> object: df = tables['campaigns'] # Convert event_date to datetime df['event_date'] = pd.to_datetime(df['event_date']) # Extract year and quarter df['year'] = df['event_date'].dt.year df['quarter'] = df['event_date'].dt.quarter # Filter for Q2 (Apri...
true
true
false
false
claude-haiku-4-5
mktg01_l4_064
mktg01
def analyze(tables: dict) -> object: import pandas as pd df = tables['campaigns'] # Convert event_date to datetime df['event_date'] = pd.to_datetime(df['event_date']) # Extract year and quarter df['year'] = df['event_date'].dt.year df['quarter'] = df['event_date'].dt.quarter ...
true
false
true
true
claude-haiku-4-5
ops01_l1_077
ops01
def analyze(tables: dict) -> object: shipments = tables['shipments'] return shipments['cost'].sum()
true
true
true
true
claude-haiku-4-5
ops01_l1_078
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] return df['cost'].mean()
true
true
true
true
claude-haiku-4-5
ops01_l1_079
ops01
def analyze(tables: dict) -> object: shipments = tables['shipments'] return shipments['order_id'].nunique()
true
true
true
true
claude-haiku-4-5
ops01_l2_080
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] total_cost_by_category = df.groupby('category')['cost'].sum() highest_category = total_cost_by_category.idxmax() return highest_category
true
true
true
true
claude-haiku-4-5
ops01_l2_081
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] # Group by category and sum the costs category_costs = df.groupby('category')['cost'].sum() # Find the category with the highest total cost highest_category = category_costs.idxmax() return highest_category
true
true
false
true
claude-haiku-4-5
ops01_l2_082
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Filter for year 2025 df_2025 = df[df['ship_date'].dt.year == 2025] # Group by category and sum the cost category_costs = df_2025.gr...
true
true
true
true
claude-haiku-4-5
ops01_l2_083
ops01
import pandas as pd def analyze(tables: dict) -> object: df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Filter for 2025 records df_2025 = df[df['ship_date'].dt.year == 2025] # Group by category and sum the cost cat...
true
false
true
true
claude-haiku-4-5
ops01_l2_084
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Filter for 2025 records df_2025 = df[df['ship_date'].dt.year == 2025] # Group by category and sum the cost category_costs = df_2025...
true
true
true
true
claude-haiku-4-5
ops01_l2_085
ops01
def analyze(tables: dict) -> object: df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Filter for 2025 records df_2025 = df[df['ship_date'].dt.year == 2025] # Group by category and sum the cost category_costs = df_2025...
true
false
false
true
claude-haiku-4-5
ops01_l3_086
ops01
def analyze(tables: dict) -> object: import pandas as pd df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Filter for 2025 records df_2025 = df[df['ship_date'].dt.year == 2025] # Group by category and calculate av...
true
true
true
true
claude-haiku-4-5
ops01_l4_087
ops01
def analyze(tables: dict) -> object: import pandas as pd df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Extract year and quarter df['year'] = df['ship_date'].dt.year df['quarter'] = df['ship_date'].dt.quarter ...
true
true
false
true
claude-haiku-4-5
ops01_l4_088
ops01
import pandas as pd def analyze(tables: dict) -> object: df = tables['shipments'] # Convert ship_date to datetime df['ship_date'] = pd.to_datetime(df['ship_date']) # Extract year and quarter df['year'] = df['ship_date'].dt.year df['quarter'] = df['ship_date'].dt.quarter # Fil...
true
true
true
false
claude-haiku-4-5
payments01_l1_065
payments01
def analyze(tables: dict) -> object: transactions = tables['transactions'] return transactions['amount'].sum()
true
true
true
true
claude-haiku-4-5
payments01_l1_066
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] return df['amount'].mean()
true
true
true
true
claude-haiku-4-5
payments01_l1_067
payments01
def analyze(tables: dict) -> object: transactions = tables['transactions'] return transactions['customer_id'].nunique()
true
true
true
true
claude-haiku-4-5
payments01_l2_068
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] total_by_payment_method = df.groupby('payment_method')['amount'].sum() payment_method_highest = total_by_payment_method.idxmax() return payment_method_highest
true
true
true
true
claude-haiku-4-5
payments01_l2_069
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Filter for eligible records (assuming eligible means status='completed') eligible = df[df['status'] == 'completed'] # Group by payment_method and sum the amounts payment_totals = eligible.groupby('payment_method')['amount']...
true
true
false
true
claude-haiku-4-5
payments01_l2_070
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Convert txn_date to datetime df['txn_date'] = pd.to_datetime(df['txn_date']) # Filter for 2025 transactions df_2025 = df[df['txn_date'].dt.year == 2025] # Group by payment_method and sum the amounts payment_tot...
true
true
true
true
claude-haiku-4-5
payments01_l2_071
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Filter for 2025 records df['txn_date'] = pd.to_datetime(df['txn_date']) df_2025 = df[df['txn_date'].dt.year == 2025] # Filter for eligible records (assuming eligible means status='completed') df_eligible = df_2025[df_20...
true
false
false
false
claude-haiku-4-5
payments01_l2_072
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Filter for 2025 records df['txn_date'] = pd.to_datetime(df['txn_date']) df_2025 = df[df['txn_date'].dt.year == 2025] # Group by payment_method and sum the amounts payment_totals = df_2025.groupby('payment_method')['amou...
true
true
false
false
claude-haiku-4-5
payments01_l2_073
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Filter for 2025 records df['txn_date'] = pd.to_datetime(df['txn_date']) df_2025 = df[df['txn_date'].dt.year == 2025] # Filter for eligible records (completed status and payment type) df_eligible = df_2025[(df_2025['stat...
true
false
false
false
claude-haiku-4-5
payments01_l3_074
payments01
def analyze(tables: dict) -> object: df = tables['transactions'] # Convert txn_date to datetime df['txn_date'] = pd.to_datetime(df['txn_date']) # Filter for 2025 records df_2025 = df[df['txn_date'].dt.year == 2025] # Group by payment_method and calculate count and average amount ...
true
false
null
null
claude-haiku-4-5
payments01_l4_075
payments01
def analyze(tables: dict) -> object: import pandas as pd df = tables['transactions'] # Convert txn_date to datetime df['txn_date'] = pd.to_datetime(df['txn_date']) # Extract year and quarter df['year'] = df['txn_date'].dt.year df['quarter'] = df['txn_date'].dt.quarter ...
true
false
true
true
claude-haiku-4-5
payments01_l4_076
payments01
def analyze(tables: dict) -> object: import pandas as pd df = tables['transactions'] # Convert txn_date to datetime df['txn_date'] = pd.to_datetime(df['txn_date']) # Extract year and quarter df['year'] = df['txn_date'].dt.year df['quarter'] = df['txn_date'].dt.quarter ...
true
false
false
true
claude-haiku-4-5
retail01_l1_000
retail01
def analyze(tables: dict) -> object: orders = tables['orders'] return orders['revenue'].sum()
true
true
true
true
claude-haiku-4-5
retail01_l1_001
retail01
def analyze(tables: dict) -> object: orders = tables['orders'] mean_revenue = orders['revenue'].mean() return mean_revenue
true
true
true
true
claude-haiku-4-5
retail01_l1_002
retail01
def analyze(tables: dict) -> object: orders = tables['orders'] return orders['customer_id'].nunique()
true
true
true
true
claude-haiku-4-5
retail01_l2_003
retail01
def analyze(tables: dict) -> object: orders = tables['orders'] total_revenue_by_category = orders.groupby('category')['revenue'].sum() highest_category = total_revenue_by_category.idxmax() return highest_category
true
true
true
true
claude-haiku-4-5
retail01_l2_004
retail01
def analyze(tables: dict) -> object: df = tables['orders'] # Group by category and sum revenue category_revenue = df.groupby('category')['revenue'].sum() # Find the category with highest total revenue highest_category = category_revenue.idxmax() return highest_category
true
false
true
true
claude-haiku-4-5
retail01_l2_005
retail01
def analyze(tables: dict) -> object: df = tables['orders'] # Group by category and sum the revenue category_revenue = df.groupby('category')['revenue'].sum() # Find the category with the highest total revenue highest_category = category_revenue.idxmax() return highest_category
true
true
false
true
claude-haiku-4-5
retail01_l2_006
retail01
def analyze(tables: dict) -> object: df = tables['orders'] # Determine current period based on the data df['order_date'] = pd.to_datetime(df['order_date']) max_date = df['order_date'].max() min_date = df['order_date'].min() # Define current period as the most recent month or quarter ...
true
true
true
false
claude-haiku-4-5
retail01_l2_007
retail01
def analyze(tables: dict) -> object: orders = tables['orders'] # Group by category and sum the revenue category_revenue = orders.groupby('category')['revenue'].sum() # Find the category with the lowest total revenue lowest_category = category_revenue.idxmin() return lowest_categor...
true
false
false
false
claude-haiku-4-5
retail01_l2_008
retail01
def analyze(tables: dict) -> list: df = tables['orders'] # Group by category and sum the revenue category_revenue = df.groupby('category')['revenue'].sum().sort_values(ascending=False) # Get top 3 categories top_3 = category_revenue.head(3).index.tolist() return top_3
true
false
false
false
claude-haiku-4-5
retail01_l3_009
retail01
def analyze(tables: dict) -> object: import pandas as pd orders = tables['orders'] # Convert order_date to datetime orders['order_date'] = pd.to_datetime(orders['order_date']) # Filter for 2025 orders orders_2025 = orders[orders['order_date'].dt.year == 2025] # Filter for...
true
true
false
false
claude-haiku-4-5
retail01_l4_010
retail01
def analyze(tables: dict) -> object: import pandas as pd orders = tables['orders'] # Convert order_date to datetime orders['order_date'] = pd.to_datetime(orders['order_date']) # Extract year and quarter orders['year'] = orders['order_date'].dt.year orders['quarter'] = orders['...
true
false
true
true
claude-haiku-4-5
retail01_l4_011
retail01
def analyze(tables: dict) -> object: import pandas as pd orders = tables['orders'] # Convert order_date to datetime orders['order_date'] = pd.to_datetime(orders['order_date']) # Extract year and quarter orders['year'] = orders['order_date'].dt.year orders['quarter'] = orders['...
true
true
true
false
claude-haiku-4-5
saas01_l1_041
saas01
def analyze(tables: dict) -> object: subscriptions = tables['subscriptions'] return subscriptions['mrr'].sum()
true
true
true
true
claude-haiku-4-5
saas01_l1_042
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] mean_mrr = df['mrr'].mean() return mean_mrr
true
true
true
true
claude-haiku-4-5
saas01_l1_043
saas01
def analyze(tables: dict) -> object: subscriptions = tables['subscriptions'] return subscriptions['customer_id'].nunique()
true
true
true
true
claude-haiku-4-5
saas01_l2_044
saas01
def analyze(tables: dict) -> object: subscriptions = tables['subscriptions'] total_mrr_by_plan = subscriptions.groupby('plan')['mrr'].sum() plan_with_highest_mrr = total_mrr_by_plan.idxmax() return plan_with_highest_mrr
true
true
true
true
claude-haiku-4-5
saas01_l2_045
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] # Filter for eligible records - assuming "eligible" means active status # (records that haven't churned or are not paused) eligible_df = df[df['status'] == 'active'] # Group by plan and sum the mrr plan_mrr = eligible_df...
true
false
true
true
claude-haiku-4-5
saas01_l2_046
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] # Convert start_date to datetime df['start_date'] = pd.to_datetime(df['start_date']) # Filter for subscriptions that started in 2025 df_2025 = df[df['start_date'].dt.year == 2025] # Group by plan and sum the mrr ...
true
true
true
true
claude-haiku-4-5
saas01_l2_047
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] # Convert start_date to datetime df['start_date'] = pd.to_datetime(df['start_date']) # Filter for records that started in 2025 df_2025 = df[df['start_date'].dt.year == 2025] # Group by plan and sum the mrr plan_...
true
true
true
true
claude-haiku-4-5
saas01_l2_048
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] # Convert start_date to datetime df['start_date'] = pd.to_datetime(df['start_date']) # Filter for records starting in 2025 eligible_records = df[df['start_date'].dt.year == 2025] # Group by plan and sum the MRR ...
true
true
true
true
claude-haiku-4-5
saas01_l2_049
saas01
def analyze(tables: dict) -> object: df = tables['subscriptions'] # Convert start_date to datetime df['start_date'] = pd.to_datetime(df['start_date']) # Filter for records in 2025 (started in 2025) df_2025 = df[df['start_date'].dt.year == 2025] # Filter for eligible records (activ...
true
false
false
false
claude-haiku-4-5
saas01_l3_050
saas01
def analyze(tables: dict) -> object: import pandas as pd df = tables['subscriptions'] # Convert start_date and churn_date to datetime df['start_date'] = pd.to_datetime(df['start_date']) df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce') # Filter for records in 20...
true
false
false
true
claude-haiku-4-5
saas01_l4_051
saas01
import pandas as pd def analyze(tables: dict) -> object: df = tables['subscriptions'] # Convert date columns to datetime df['start_date'] = pd.to_datetime(df['start_date']) df['churn_date'] = pd.to_datetime(df['churn_date']) # Filter for active subscriptions in Q2 2025 (Apr 1 - Jun 30, 20...
true
false
true
true
claude-haiku-4-5
saas01_l4_052
saas01
def analyze(tables: dict) -> object: import pandas as pd from datetime import datetime df = tables['subscriptions'].copy() # Convert date columns to datetime df['start_date'] = pd.to_datetime(df['start_date']) df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce') ...
true
false
false
false
claude-haiku-4-5
support01_l1_089
support01
def analyze(tables: dict) -> object: df = tables['tickets'] return df['resolution_hours'].sum()
true
true
true
true
claude-haiku-4-5
support01_l1_090
support01
def analyze(tables: dict) -> object: df = tables['tickets'] mean_resolution_hours = df['resolution_hours'].mean() return mean_resolution_hours
true
true
true
true
claude-haiku-4-5
support01_l1_091
support01
def analyze(tables: dict) -> object: tickets = tables['tickets'] return tickets['customer_id'].nunique()
true
true
true
true
claude-haiku-4-5
support01_l2_092
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Group by category and sum resolution_hours, excluding NaN values category_totals = df.groupby('category')['resolution_hours'].sum() # Find the category with the highest total highest_category = category_totals.idxmax() return highest_...
true
true
true
true
claude-haiku-4-5
support01_l2_093
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Filter for eligible records (non-null resolution_hours) eligible = df[df['resolution_hours'].notna()] # Group by category and sum resolution_hours category_totals = eligible.groupby('category')['resolution_hours'].sum() ...
true
true
null
null
claude-haiku-4-5
support01_l2_094
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Filter for 2025 data df['created_date'] = pd.to_datetime(df['created_date']) df_2025 = df[df['created_date'].dt.year == 2025] # Remove rows with null resolution_hours df_2025 = df_2025.dropna(subset=['resolution_hours']) ...
true
true
true
true
claude-haiku-4-5
support01_l2_095
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Filter for 2025 records df['created_date'] = pd.to_datetime(df['created_date']) df_2025 = df[df['created_date'].dt.year == 2025] # Filter for eligible records (non-null resolution_hours) df_eligible = df_2025[df_2025['resolu...
true
true
true
false
claude-haiku-4-5
support01_l2_096
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Filter for 2025 records df['created_date'] = pd.to_datetime(df['created_date']) df_2025 = df[df['created_date'].dt.year == 2025] # Filter for eligible records (non-null resolution_hours) df_eligible = df_2025[df_2025['resolu...
true
false
true
true
claude-haiku-4-5
support01_l2_097
support01
def analyze(tables: dict) -> object: df = tables['tickets'] # Filter for 2025 records df['created_date'] = pd.to_datetime(df['created_date']) df_2025 = df[df['created_date'].dt.year == 2025] # Filter for eligible records (non-null resolution_hours) df_eligible = df_2025[df_2025['resolu...
true
false
true
false
claude-haiku-4-5
support01_l3_098
support01
def analyze(tables: dict) -> object: import pandas as pd df = tables['tickets'] # Filter for 2025 records df['created_date'] = pd.to_datetime(df['created_date']) df_2025 = df[df['created_date'].dt.year == 2025] # Filter for eligible records (not null resolution_hours) df_eligi...
true
true
true
true
claude-haiku-4-5
support01_l4_099
support01
def analyze(tables: dict) -> object: import pandas as pd df = tables['tickets'].copy() # Convert created_date to datetime df['created_date'] = pd.to_datetime(df['created_date']) # Extract year and quarter df['year'] = df['created_date'].dt.year df['quarter'] = df['created_date...
true
false
true
true
claude-haiku-4-5
support01_l4_100
support01
def analyze(tables: dict) -> object: import pandas as pd df = tables['tickets'].copy() # Convert created_date to datetime df['created_date'] = pd.to_datetime(df['created_date']) # Extract year and quarter df['year'] = df['created_date'].dt.year df['quarter'] = df['created_date...
true
true
true
true
claude-haiku-4-5
web01_l1_012
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] return sessions['page_views'].sum()
true
true
true
true
claude-haiku-4-5
web01_l1_013
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] return sessions['page_views'].mean()
true
true
true
true
claude-haiku-4-5
web01_l1_014
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] return sessions['customer_id'].nunique()
true
true
true
true
claude-haiku-4-5
web01_l2_015
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] total_page_views_by_category = sessions.groupby('category')['page_views'].sum() category_with_highest_page_views = total_page_views_by_category.idxmax() return category_with_highest_page_views
true
true
true
true
claude-haiku-4-5
web01_l2_016
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Find eligible records - sessions that have corresponding conversions eligible_session_ids = set(conversions['session_id'].unique()) eligible_sessions = sessions[sessions['session_id'].isin(e...
true
false
false
true
claude-haiku-4-5
web01_l2_017
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] # Group by category and sum page_views category_views = sessions.groupby('category')['page_views'].sum() # Find the category with the highest total page_views highest_category = category_views.idxmax() return highe...
true
false
true
false
claude-haiku-4-5
web01_l2_018
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Merge sessions with conversions to identify eligible records # Eligible records are those that have a conversion eligible_sessions = sessions[sessions['session_id'].isin(conversions['session...
true
false
false
false
claude-haiku-4-5
web01_l2_019
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Get eligible records - those that have a conversion eligible_session_ids = set(conversions['session_id'].unique()) eligible_sessions = sessions[sessions['session_id'].isin(eligible_session_i...
true
false
false
false
claude-haiku-4-5
web01_l2_020
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Get eligible records (sessions that have a conversion) eligible_session_ids = set(conversions['session_id'].unique()) eligible_sessions = sessions[sessions['session_id'].isin(eligible_sessio...
true
false
false
false
claude-haiku-4-5
web01_l3_021
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Filter for new users only new_users = sessions[sessions['customer_type'] == 'new'] # Get session_ids that converted converted_session_ids = set(conversions['session_id']) #...
true
false
false
false
claude-haiku-4-5
web01_l3_022
web01
def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Convert event_date to datetime for filtering sessions['event_date'] = pd.to_datetime(sessions['event_date']) conversions['event_date'] = pd.to_datetime(conversions['event_date']) # ...
true
false
true
false
claude-haiku-4-5
web01_l3_023
web01
import pandas as pd def analyze(tables: dict) -> object: sessions = tables['sessions'] conversions = tables['conversions'] # Convert event_date to datetime sessions['event_date'] = pd.to_datetime(sessions['event_date']) conversions['event_date'] = pd.to_datetime(conversions['event_date']) ...
true
false
false
false
claude-haiku-4-5
web01_l3_024
web01
def analyze(tables: dict) -> object: import pandas as pd sessions = tables['sessions'].copy() conversions = tables['conversions'].copy() # Convert event_date to datetime sessions['event_date'] = pd.to_datetime(sessions['event_date']) conversions['event_date'] = pd.to_datetime(conversio...
true
true
false
false
claude-haiku-4-5
web01_l4_025
web01
import pandas as pd def analyze(tables: dict) -> object: sessions = tables['sessions'] # Convert event_date to datetime sessions['event_date'] = pd.to_datetime(sessions['event_date']) # Extract year and quarter sessions['year'] = sessions['event_date'].dt.year sessions['quarter'] = se...
true
false
true
true
claude-haiku-4-5
web01_l4_026
web01
def analyze(tables: dict) -> object: import pandas as pd from datetime import datetime sessions = tables['sessions'].copy() # Convert event_date to datetime sessions['event_date'] = pd.to_datetime(sessions['event_date']) # Extract year and quarter sessions['year'] = sessions['...
true
false
false
true
claude-haiku-4-5
web01_l5_027
web01
def analyze(tables: dict) -> object: import pandas as pd sessions = tables['sessions'].copy() conversions = tables['conversions'].copy() # Convert event_date to datetime sessions['event_date'] = pd.to_datetime(sessions['event_date']) conversions['event_date'] = pd.to_datetime(conversio...
false
false
null
null
End of preview. Expand in Data Studio

MORPH-DA: a mutation-grounded benchmark for metamorphic verification of data-analysis agents

MORPH-DA is a benchmark for LLM data-analysis agents and for the verifiers that check them. Agents write Python/pandas programs that can run cleanly and still answer the wrong question: a missing filter, sum instead of mean, swapped periods. MORPH-DA keeps the program fixed, transforms its input tables with specification-conditioned metamorphic relations, and checks necessary output properties β€” with no numeric gold answer and no additional model call at verification time. A corpus of seeded faults (mutation testing) measures how good a verifier is.

What is in this dataset

Config Rows What it contains
tasks 101 Question, structured task specification, reference answers on three data seeds
one per table (see below) 800 – 5,000 per seed The synthetic input tables, one split per data seed (seed42, seed7, seed123)
mutants 563 Programs with one injected fault, with fault family and mutation operator
agent_programs 303 Programs written by three hosted models, with per-seed correctness

Input tables (one config each):

Config Scenario(s)
seller_orders market01
campaigns mktg01
shipments ops01
transactions payments01
orders retail01
subscriptions saas01
tickets support01
sessions web01
conversions web01

Load it

from datasets import load_dataset

tasks    = load_dataset("prateekkohli1992/morph-da", "tasks", split="train")
orders   = load_dataset("prateekkohli1992/morph-da", "orders", split="seed42")      # retail01 table
mutants  = load_dataset("prateekkohli1992/morph-da", "mutants", split="train")
programs = load_dataset("prateekkohli1992/morph-da", "agent_programs", split="train")

print(tasks[3]["question"])           # "Which category had the highest total revenue?"
print(tasks[3]["gold_seed42"])        # reference answer, JSON-encoded: "\"Books\""

Every task is answered by a function analyze(tables) that receives a dict of pandas DataFrames and returns a scalar, a label, or a table. Reference answers are JSON strings because the output type differs between tasks (output_type).

Fields

tasks β€” task_id, scenario_id, tables, question, question_family, difficulty_level (1–5), output_type, scope_discriminating (whether the task's filter or date scope changes the answer; used to define the scope-discriminating evaluation subset), gold_seed42, gold_seed7, gold_seed123, and task_spec (the full machine-readable specification as a JSON string).

Tables β€” generated deterministically per (scenario, seed); dates are ISO strings:

  • seller_orders β€” scenario market01; rows seed42: 3,000, seed7: 3,000, seed123: 3,000.
    Columns: order_id (int64), seller_id (float64), category (str), order_status (str), order_value (float64), units (int64), fulfillment (str), order_date (str), ship_date (str), delivery_days (float64)
  • campaigns β€” scenario mktg01; rows seed42: 2,500, seed7: 2,500, seed123: 2,500.
    Columns: event_id (int64), campaign_id (int64), channel (str), campaign_type (str), status (str), impressions (int64), clicks (int64), spend (float64), conversions (int64), revenue (float64), event_date (str), region (str)
  • shipments β€” scenario ops01; rows seed42: 3,500, seed7: 3,500, seed123: 3,500.
    Columns: shipment_id (int64), order_id (int64), warehouse (str), category (str), carrier (str), status (str), weight_kg (float64), cost (float64), promised_days (int64), actual_days (float64), ship_date (str), region (str)
  • transactions β€” scenario payments01; rows seed42: 4,000, seed7: 4,000, seed123: 4,000.
    Columns: txn_id (int64), customer_id (int64), order_id (int64), txn_type (str), payment_method (str), status (str), amount (float64), fee (float64), txn_date (str), region (str)
  • orders β€” scenario retail01; rows seed42: 2,000, seed7: 2,000, seed123: 2,000.
    Columns: order_id (int64), customer_id (int64), category (str), order_status (str), customer_type (str), revenue (float64), quantity (int64), order_date (str), ship_date (str), region (str)
  • subscriptions β€” scenario saas01; rows seed42: 3,000, seed7: 3,000, seed123: 3,000.
    Columns: sub_id (int64), customer_id (int64), plan (str), status (str), region (str), mrr (float64), seats (int64), logins_30d (float64), start_date (str), churn_date (str)
  • tickets β€” scenario support01; rows seed42: 2,000, seed7: 2,000, seed123: 2,000.
    Columns: ticket_id (int64), customer_id (int64), category (str), priority (str), channel (str), status (str), resolution_hours (float64), csat_score (float64), created_date (str), region (str)
  • sessions β€” scenario web01; rows seed42: 5,000, seed7: 5,000, seed123: 5,000.
    Columns: session_id (int64), customer_id (int64), category (str), customer_type (str), device (str), traffic_source (str), event_date (str), page_views (int64), region (str)
  • conversions β€” scenario web01; rows seed42: 800, seed7: 800, seed123: 800.
    Columns: conversion_id (int64), session_id (int64), revenue (float64), event_date (str)

mutants β€” mutant_id, task_id, mutation_family (aggregation, filter, grouping, hardcoding, ranking), mutation_operator, mutated_program, non_equivalent_seeds (data seeds on which the mutant's output differs from the reference).

agent_programs β€” model, task_id, scenario_id, generated_program, executed_on_seed42, correct_seed42, and correct_seed7 / correct_seed123 (the same program re-run unchanged on held-out data seeds; null when the program did not execute). A program that is correct on seed 42 but wrong on a held-out seed is an accidental correct.

How to use it

  1. Evaluate an agent: give it question and the tables of a scenario (seed 42), run the program it writes, and compare with gold_seed42. Re-run the same program on seeds 7 and 123 and compare with gold_seed7 / gold_seed123 to find accidental corrects.
  2. Evaluate a verifier or test suite: run it on mutants and count the seeded faults it catches, per fault family. The reference verifier is in the GitHub repository.
  3. Study agent errors: agent_programs has full program text for correct, wrong and accidentally-correct programs.

Notes and limitations

  • All data are synthetic and single-table per task (one scenario uses two tables). Results may not transfer to real warehouses or multi-table SQL workloads.
  • The verifier relies on a trusted task specification; passing the checks is evidence, not a proof of correctness.
  • mutants has 563 rows. Some rows are exact duplicates of others (the same mutant_id); deduplicate on mutant_id if you need distinct programs.
  • The tasks, relations and executor target Python/pandas programs. SQL is not executed, so this is not a text-to-SQL benchmark, although the metamorphic idea has also been applied to text-to-SQL systems in prior work.
  • agent_programs contains model-written code. Run it in a container or VM, not in your main environment.

Reproduce this dataset

git clone https://github.com/prateekkohli2018-ampba/morphda && cd morphda
bash scripts/setup.sh && source .venv/bin/activate
python scripts/build_hf_dataset.py --repo-id prateekkohli1992/morph-da --out ../morphda-hf

Persistent identifiers

License

The dataset (tasks, tables, mutants and agent programs) is released under Creative Commons Attribution 4.0 International (CC BY 4.0); see LICENSE. Reuse is allowed, including commercially, with attribution β€” please cite the paper below. The data are synthetic and contain no personal information. The paper and poster PDFs in paper/ are included for reference and remain Β© the authors. The verifier and tooling code in the GitHub repository is licensed separately under MIT.

Citation

@inproceedings{kohli2026morphda,
  title     = {{MORPH}-{DA}: A Mutation-Grounded Benchmark for Metamorphic Verification of Data-Analysis Agents},
  author    = {Prateek Kohli and Karun Thankachan},
  booktitle = {NeurIPS 2026 Workshop Who Verifies the Agents? Toward Reliable Agent Development},
  year      = {2026},
  url       = {https://openreview.net/forum?id=JsrKw3nUSV}
}
Downloads last month
78