Datasets:
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 |
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.
- Paper:
paper/morphda_paper.pdfΒ· OpenReview - Poster:
paper/morphda_poster.pdf - Code (verifier, relations, agent harness, evaluation): https://github.com/prateekkohli2018-ampba/morphda
- Authors: Prateek Kohli, Karun Thankachan β NeurIPS 2026 Workshop Who Verifies the Agents?
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β scenariomarket01; 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β scenariomktg01; 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β scenarioops01; 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β scenariopayments01; 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β scenarioretail01; 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β scenariosaas01; 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β scenariosupport01; 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β scenarioweb01; 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β scenarioweb01; 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
- Evaluate an agent: give it
questionand the tables of a scenario (seed 42), run the program it writes, and compare withgold_seed42. Re-run the same program on seeds 7 and 123 and compare withgold_seed7/gold_seed123to find accidental corrects. - Evaluate a verifier or test suite: run it on
mutantsand count the seeded faults it catches, per fault family. The reference verifier is in the GitHub repository. - Study agent errors:
agent_programshas 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.
mutantshas 563 rows. Some rows are exact duplicates of others (the samemutant_id); deduplicate onmutant_idif 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_programscontains 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
- Dataset DOI: 10.57967/hf/11699
- Software DOI (code archive): 10.5281/zenodo.24356105
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