Hugging Face's logo

Datasets:
chuxuan
/
REPRO-Bench

Tasks:
Image-Text-to-Text
Languages:
English
ArXiv:
Tags:
reproducibility
social-science
agents
Dataset card Files
xet
 Community
1
REPRO-Bench / 107 /replication_package /Code /MATLAB /gymGame.m
anonymous-submission-acl2025's picture
anonymous-submission-acl2025
107
b6c95bb
Raw History Blame Contribute Delete
14 kB
classdef gymGame
% Defines the outcomes of a T period game with a commitment contract
% that imposes penalty p if a_star attendances are not achieved, or
% instead with a piece-rate incentive of r per attendance
properties
% Game properties
T; % number of periods in game
a_star; % commitment contract attendance threshold
p; % commitment contract penalty
r; % per attendance reward
% Parameters for individuals taking up the contract
lambda; % 1/mean of exponential cost distribution
min_cost; % lower bound on support of cost distribution
beta; % actual present focus
betatilde; % perceived present focus
b; % health benefit
mu; % fraction of people taking up the contract
% Outcomes under commitment contract
utilities; % utilities in each period for each g
t1_utility; % period 1 utility
utilities_tilde; % perceived utilities in each future period
att; % distribution of attendances in simulation
avg_att; % average attendance in simulation
avg_costs; % average aggregate costs incurred
avg_t1_att; % average first period attendance
prob_success; % likelihood of meeting threshold in simulation
prob_att_c_b; % likelihood of attending when cost > benefit
prob_att_day; % likelihood of attending each day
% Outcomes under piece-rate incentive(s)
prob_att_r; % probability of attending on a given day
att_r; % expected attendance under incentive r
change_att_r; % expected increase in attendance due to r
benefits_r; % expected health benefits under incentive r
costs_r; % expected costs under incentive r
net_surplus_r; % surplus under incentive r, net of incentive
surplus_r; % total surplus under incentive r
% Identifier
spec;
end
properties (Constant)
seed = 12345; % seed for simulation
rounds = 10000; % number of iterations of the simulation
end
methods
function obj = gymGame(properties, parameters, min_cost, title)
% input properties
obj.T = properties.T;
obj.a_star = properties.a_star;
obj.p = properties.p;
% set parameters from data
obj.lambda = parameters.lambda;
obj.min_cost = min_cost;
obj.beta = parameters.beta;
obj.betatilde = parameters.betatilde;
obj.b = parameters.b;
obj.mu = parameters.mu;
% set identifier
obj.spec = title;
% compute matrix of utilities
obj = obj.compute_utilities();
% simulate behavior of participants
obj = obj.simulate_behavior();
end
function obj = compute_utilities(obj)
V_n = NaN([obj.a_star+1 obj.T]);
V_tilde = NaN([obj.a_star+1 obj.T]);
% set last period utilities
for g = 0:obj.a_star
g1 = g + 1; % 1-indexed
V_n(g1,obj.T) = obj.compute_T_utility(g, 'actual');
V_tilde(g1,obj.T) = obj.compute_T_utility(g, 'perceived');
end
% set all other period utilities
for period = 1:obj.T-1
t = obj.T - period; % go backwards
start = max(obj.a_star - t + 1, 0);
% iterate through remaining attendances
for g = start:obj.a_star
g1 = g + 1; % 1-indexed
% expected utility difference from attending
delta_V_tilde = V_tilde(max(g1-1,1),t+1) - V_tilde(g1,t+1);
delta_V_n = V_n(max(g1-1,1),t+1) - V_n(g1,t+1);
% perceived expected utility at period t
V_tilde(g1,t) = (obj.F(obj.betatilde.*(obj.b + delta_V_tilde)).* ...
(obj.b + delta_V_tilde)) + V_tilde(g1,t+1) - ...
obj.C(obj.betatilde.*(obj.b + delta_V_tilde));
% actual expected utility at period t
V_n(g1,t) = (obj.F(obj.beta.*(obj.b + delta_V_tilde)).* ...
(obj.b + delta_V_n)) + V_n(g1,t+1) - ...
obj.C(obj.beta.*(obj.b + delta_V_tilde));
end
end
obj.utilities = V_n;
obj.t1_utility = V_n(obj.a_star+1,1); % period 1 utility
obj.utilities_tilde = V_tilde;
end
function V_T = compute_T_utility(obj, g, focus)
% compute utility in the last period
% set present focus parameter
if strcmp(focus, 'actual')
B = obj.beta;
elseif strcmp(focus, 'perceived')
B = obj.betatilde;
end
if g == 0 % no attendances left
V_T = (obj.F(B.*obj.b).*obj.b) - obj.C(B.*obj.b);
elseif g == 1 % one attendance left
V_T = (obj.F(B.*(obj.b + obj.p)).*obj.b) - ...
obj.C(B.*(obj.b + obj.p)) - ...
((1 - obj.F(B.*(obj.b + obj.p))).*obj.p);
else % more than one attendance left
V_T = (obj.F(B.*obj.b).*obj.b) - obj.C(B.*obj.b) - obj.p;
end
end
function obj = simulate_behavior(obj)
% simulate behavior through T periods for a number of rounds to
% generate estimates of average attendance and the likelihood
% of meeting the contract threshold
rng(obj.seed); % set seed
obj.att = zeros(1,obj.rounds); % default no attendances
t1_att = obj.att;
att_day = zeros(obj.T,obj.rounds); % default no attendances
costs_day = zeros(obj.T,obj.rounds); % default no costs
met_goal = zeros(1,obj.rounds); % default failed to meet goal
obj.prob_att_c_b = zeros(1,obj.rounds); % default never attend
for round = 1:obj.rounds
c = obj.cost_draws(); % generate cost draws
g = obj.a_star; % all attendances initially left
a = 0; % total number of attendances
c_b = 0; % events where cost > benefit
att_c_b = 0; % attendance in those events
% check if the DM wants to go to the gym in each period
for t = 1:obj.T
g1 = g + 1; % 1-indexed
if t == obj.T && (g == 0 || g >= 2) % last period, case i
if c(t) <= (obj.beta * obj.b)
% update attendances & costs incurred
g = max(g - 1, 0);
a = a + 1;
att_day(t,round) = 1;
costs_day(t,round) = c(t);
if c(t) > obj.b
% cost is greater than benefit
att_c_b = att_c_b + 1;
end
end
elseif t == obj.T && g == 1 % last period, case ii
if c(t) <= (obj.beta * (obj.b + obj.p))
% update attendances & costs incurred
g = max(g - 1, 0);
a = a + 1;
att_day(t,round) = 1;
costs_day(t,round) = c(t);
if c(t) > obj.b
% cost is greater than benefit
att_c_b = att_c_b + 1;
end
end
else % all other periods
if c(t) <= (obj.beta * (obj.b + ...
obj.utilities_tilde(max(g1-1,1),t+1) - ...
obj.utilities_tilde(g1,t+1)))
% update attendances & costs incurred
g = max(g - 1, 0);
a = a + 1;
att_day(t,round) = 1;
costs_day(t,round) = c(t);
if c(t) > obj.b
% cost is greater than benefit
att_c_b = att_c_b + 1;
end
end
end
if c(t) > obj.b
% cost is greater than benefit
c_b = c_b + 1;
end
if t == 1 && g < obj.a_star
% period one attendances
t1_att(round) = 1;
end
end
if g == 0
met_goal(round) = 1; % input outcome
end
obj.att(round) = a; % input attendances
obj.prob_att_c_b(round) = att_c_b ./ c_b;
end
% return means
obj.avg_att = mean(obj.att);
obj.avg_t1_att = mean(t1_att);
obj.prob_success = mean(met_goal);
obj.prob_att_c_b = mean(obj.prob_att_c_b);
obj.prob_att_day = sum(att_day,2) ./ obj.rounds;
obj.avg_costs = mean(sum(costs_day,1));
end
function obj = compute_incentive_behavior(obj, r)
% compute expected attendance and total surplus given
% piece-rate incentive r
obj.r = r;
% compute expected attendance on a given day
obj.prob_att_r = obj.F(obj.beta .* (obj.b + r));
prob_att_no_r = obj.F(obj.beta .* (obj.b)); % without incentive
% compute expected attendance
obj.att_r = obj.T .* obj.prob_att_r;
% compute expected increase in attendance
obj.change_att_r = obj.T .* (obj.prob_att_r - prob_att_no_r);
% compute expected benefits
obj.benefits_r = obj.att_r .* obj.b;
% compute expected costs
obj.costs_r = obj.T .* obj.C(obj.beta .* (obj.b + r));
% compute surplus net of incentive
obj.net_surplus_r = obj.benefits_r - obj.costs_r;
% compute total surplus
obj.surplus_r = obj.net_surplus_r + (obj.att_r .* r);
end
function probability = F(obj, x)
% cumulative distribution function of costs
z = x - obj.min_cost;
z = gymGame.minzero(z);
probability = 1 - exp(-obj.lambda.*z);
end
function density = f(obj, x)
% cost density function
% returns zero when given x < lower bound on costs
z = x - obj.min_cost;
density = obj.lambda.*exp(-obj.lambda.*z);
density = density.*heaviside(heaviside(z));
end
function expectation = C(obj, x)
% expected cost function
z = x - obj.min_cost;
z = gymGame.minzero(z);
expectation = (1 ./ obj.lambda).*(1 - exp(-obj.lambda.*z)) ...
- (z.*exp(-obj.lambda.*z)) + obj.min_cost.*obj.F(x);
end
function c = cost_draws(obj)
% vector of random cost draws for each period
mean = 1 ./ obj.lambda;
c = exprnd(mean, [1 obj.T]) + obj.min_cost;
end
end
methods(Static)
function y = minzero(x)
% returns x if x is positive, 0 otherwise
y = x .* heaviside(heaviside(x));
end
end
end