z-Tree

Design: Urs Fischbacher

Programming: Urs Fischbacher and Stefan Schmid
This slides by Ernesto Reuben

Web Resources
z-Tree
zTree hompage
http://www.iew.unizh.ch/ztree/index.php
zTree Wiki
https://www.uzh.ch/iew/ztree/ssl-dir/wiki/
zTree mailing list
send email to majordomo@id.uzh.ch with subscribe ztree_l in
the message body

Exp. 1: Measuring risk aversion

z-Tree
We are interested in measuring risk aversion.
Elicit certainty equivalent of a lottery using the Becker-DegrootMarschak mechanism:
Lottery: $0 with probability p and $X with probability (1 p).
Subjects are asked for their CE:
State the amount of money that makes you indifferent
between receiving that amount or playing the lottery
A number z is randomly drawn between 0 and X.
if z CE, the subject receives $z
if z < CE the subject plays the lottery

The Stage Tree

z-Tree
The description of a treatment is arranged in a tree structure:
The stage tree shows the sequence of stages:
Stages contain programs and the two screens.
Screens (active and waiting).
Used to input and display data (and messages).
Screens contain boxes.
Boxes contain items and buttons.
Programs.
Used to manipulate data.
Set treatment variables.

Background
z-Tree

Set number of subjects.

Set number of rounds.
Set exchange rate.
Default screens.
Treatment variables.

Add Stages
z-Tree
Each stage corresponds
(roughly) to one screen.
In this case we need 2
stages:
Decision stage.
Results stage.

Add Stages
z-Tree

Can subject enter stage?

Programs are executed.

Active screen is displayed.

Waiting screen is displayed

(if the next stage cannot be entered)

Input and Output

z-Tree
Items are used for the input and output of variables.
Label (text displayed)
Variable (for input or output)
Layout:
numbers
radio buttons
check boxes sliders
scrollbars
Note:
If the item is used for input
we also need a button.

Input and Tables

z-Tree

When subjects make an input, the data is transferred to z-Tree.

The data is stored in tables.
The tables can be viewed in a window in z-Tree (menu Treatment)
Most data is stored in the subjects table.
One row per subject.
For every period, there is a new subjects table.
Other tables: (contracts, session, globals, summary, and OLDsubjects)
Other tables can be accessed by table.tablefunction.

Programs
z-Tree
Programs can be executed at
the beginning of a stage and
when buttons are clicked.
Calculations are performed
by z-Tree and then sent to
the z-Leafs.
Programs are executed row
by row (i.e. subject by
subject).

Functions and statements

z-Tree
There is a good number of functions that can be used for
programming:
subjects.do{
z = random() * 200;
if( z >= CE ){
Profit = z;
}
else {
q = random();
Profit = if( q >= p, X, 0);
}
}

Exp. 2: A public goods game

z-Tree
In each period each subject gets y points.
Points can be kept or invested in a public good
The profit of each subject is:
i = y ci + (/N)jcj
The game is played for t periods.
Note:
if no one contributes: i = y
if everyone contributes y: i = y
If 1 > /n you are better off if you do not contribute

Table functions
z-Tree
Syntax 1: table function( expression )
Example: Profits in the public goods game:
subjects.do{
SumContribute = sum(Contribute);
N = count( );
GroupProfit = EfficiencyFactor * SumContribute / N;
Profit = Endowment - Contribute + GroupProfit;
}
Example: Maximum contribution
subjects.do{
MaxContribute = maximum(Contribute);
}

Table functions
z-Tree
Syntax 2: table function( condition, expression )
Example: Sum of all the contributions that exceed 10
subjects.do{
SumHighContribute = sum(Contribute > 10, Contribute );
}
Example: Subject who contributed the least
subjects.do{
CheapSubject = find(Contribute == minimum(Contribute), Subject );
}

Exp. 3: A public goods game in groups

z-Tree
In each period subjects are assigned to groups of n
Each subject gets y points.
Points can be kept or invested in a public good.
The profit of each subject is:
i = y ci + (/n)jcj
The game is played for t periods.

Groups
z-Tree
The variable Group determines the group matching.
The number of groups can be set in the background stage.
There are menu commands for different types of matchings
(treatment menu):
Partner
Stranger
absolute Stranger
typed absolute Stranger
Important:
Before running an experiment, check the Parameter table
(treatment menu).

Groups
z-Tree

The Group variable can also be changed:

Manually in the Parameter table
Double-click on each cell and set group
Through a program in the background stage
subjects.do{
if( Subject <= 5 ){
Group = 1;
}
elsif( Subject <= 9) {
Group = 2;
}
else {
Group = 3;
}
}

Same
z-Tree
same( ) can be used to make group calculations
Example: Profits in the public goods game:
subjects.do{
SumContribute = sum( same(Group), Contribute );
N = count( same(Group) );
GroupProfit = EfficiencyFactor * SumContribute / N;
Profit = Endowment - Contribute + GroupProfit;
}

Scope Operator
z-Tree
Alternatively, one can use the scope operator.
Sum contributions of all group members.
subjects.do{
SumContribute = sum(Group == :Group, Contribute );
}

Scope Operator
z-Tree
Building a ranking: incorrect
subjects.do{
RankContribute = count(Contribute <= Contribute);
}
Building a ranking: correct
subjects.do{
RankContribute = count(Contribute <= :Contribute);
}

Some useful matching programs

z-Tree
Groups of n, partners:
subjects.do{
Group = mod(Subject, n) + 1;
}

Some useful matching programs

z-Tree
Groups of n, strangers: incorrect
subjects.do{
RndNum = random();
Rank = count(RndNum <= :RndNum);
Group = mod(Rank, n) + 1;
}

Some useful matching programs

z-Tree
Groups of n, strangers: correct
subjects.do{
RndNum = random();
}
subjects.do{
Rank = count(RndNum <= :RndNum);
Group = mod(Rank, n) + 1;
}

Exp. 4: An ultimatum game

z-Tree
Subjects are matched in pairs
Each pair has 1 proposer and 1 responder.
Each pair receives y points.
Proposers offer responders x points from the y available points.
Responders can accept or reject the offer.
If the responder accepts:
Proposers earn: P = y x
Responders earn: R = x
If the responder rejects:
Both get 0 points.
Play for t periods.
Random matching and random assignment of roles.

Examples
z-Tree
Public goods exp
Contribution
decision

Profit display

Ultimatum game
Proposer offer

waiting

waiting

Responder
acceptance

Proposer profit
display

Responder
profit display

Simultaneous stages

Types
z-Tree
We need to assign types to players.
One proposer and one responder per group (randomly allocated)
subjects.do{
RndNum = random();
}
subjects.do{
RndOther = find(same(Group) & not( same(Subject) ) , RndNum);
Proposer = if( RndOther > RndNum, 1, 0);
}
Or easier ... You can also do this in the parameter table (less flexible)
period parameters, subject parameters, period subject parameters

Participate
z-Tree
The variable Participate can be
used to select who enters a stage.
Enter stage: Participate = 1.
Skip stage: Participate = 0.
For the ultimatum game we use:
Participate = if (Proposer == 1, 1, 0);
Additionally:
For the input of the responders
decision we can use radio buttons:
!radio: 0=Reject; 1=Accept;

Exp. 5: Another ultimatum game

z-Tree
Proposers offer responders x points from the y available points.
Responders state what is the minimum offer they would accept.
If the offer minimum acceptable offer:
Proposers earn: P = y x
Responders earn: R = x
If the offer < minimum acceptable offer:
Both get 0 points.
This is an example of using the strategy method.

z-Tree

Stage:
start options

Proposers and responders

decide simultaneously.
Stage start options:
Wait for all
general case
As soon as possible
simultaneous stages
stages that do not depend
on other participants

Some useful matching programs

z-Tree
k types of players, each group has one player of each type,
strangers:
subjects.do{
Type = mod( Subject 1, k) + 1;
RndNum = random();
}
subjects.do{
Group = count( same(Type) & RndNum <= :RndNum);
}

Exp. 6: A coordination game

z-Tree
Subjects are matched in pairs
Each pair has 1 row player and 1 column player.
Subjects can choose between a high risk, a low risk and a no risk
action. The higher payoffs are achieved when both subjects
choose the same action:
High Risk Low Risk

No Risk

High Risk

9,9

0,3

0,5

Low Risk

3,0

6,6

3,5

No Risk

5,0

5,3

5,5

Arrays
z-Tree
To calculate payoffs:
if(Action == 1) {
Profit = if( ActionOther == 1,
Pay11, if( ActionOther == 2,
Pay12, Pay13 ) );
}
Easier:
array Pay1[3];
if(Action == 1) {
Profit = Pay1[ActionOther];
}

Boxes
z-Tree
Box = rectangular area of the screen containing stuff
Boxes are positioned over each other.
standard box
header box
help box
grid box
history box

Boxes
z-Tree
Container Box = rectangular area containing other boxes
Very useful
move many boxes at the same time
Keep things in place with different resolutions
800p

600p

Boxes
z-Tree
Distances can be set as % of the screen or in pixels

Display condition
Used to make boxes appear (when true) or disappear (when false)

Boxes
z-Tree
Example

Variables integrated into text

z-Tree
To display:
You sold a share for $10.00!
or
You bought a share for $10.00!
Type:
<>You <Buyer |!text: 0=sold; 1=bought;>
a share for $<Price | 0.01>.

Variables integrated into text

z-Tree
To display:
Your profit in this period was 25.00 points.
or
Your profit in this period was 5.00 points.
Type:
<>{\rtf Your \i profit \i0 in this period was
<Profit |!text: 1=; 1=\b ;><Profit |0.01>
points<Profit |!text: 1=; 1=\b0 ;>.}

Most RTF is supported so you can do a lot of stuff

Exp. 7: A very simple auction

z-Tree
Subjects are all buyers.
Subjects get a (random) private value for the auctioned good
Subjects make bids
Winner pays the second highest price
The auction is terminated after a fixed timeout
Winner gets: B = y + vi b2
Sellers get: S = y
For market experiments we need:
contracts table
new types of boxes:
contract creation box, contract list box, and contract grid box

Contracts table
z-Tree
Table has a flexible number of records (records can be added).
New records are created in contract creation boxes.
or with the new command: contracts.new{ x=1; }
Buyer

Bid

Order

Remark

Contracts table
z-Tree
Table has a flexible number of records (records can be added).
New records are created in contract creation boxes.
or with the new command: contracts.new{ x=1; }
Buyer

Bid

Order

10

Remark
Subject 2 makes a bid (highest bid)

Contracts table
z-Tree
Table has a flexible number of records (records can be added).
New records are created in contract creation boxes.
or with the new command: contracts.new{ x=1; }
Buyer

Bid

Order

Remark

10

Subject 2 makes a bid (second highest bid)

12

Subject 5 makes a bid (highest bid)

Contracts table
z-Tree
Table has a flexible number of records (records can be added).
New records are created in contract creation boxes.
or with the new command: contracts.new{ x=1; }
Buyer

Bid

Order

Remark

10

Subject 2 makes a bid

12

Subject 5 makes a bid (second highest bid)

15

Subject 4 makes a bid (highest bid)

Contracts table
z-Tree
Table has a flexible number of records (records can be added).
New records are created in contract creation boxes.
or with the new command: contracts.new{ x=1; }
Buyer

Bid

Order

Remark

10

Subject 2 makes a bid

12

Subject 5 makes a bid

15

Subject 5 makes a bid (second highest bid)

17

Subject 2 makes another bid (highest offer)

Contracts table
z-Tree
The contents of the
contracts table can be
displayed with a
contracts list box or
with a contracts grid
box.

Exp. 8: A continuous public good game

z-Tree
In each period each subject gets 20 points.
Points can be kept or invested in a public good
Each point invested in the public good pays 0.5 to everyone.
The profit of each subject is:
i = 20 ci + 0.5 jcj
The game is played for 2 periods.
There are 90 sec to make non-binding contributions.
Contributions become binding when time expires or when the
subject chooses to commit him/herself.
Contributions are observer on real-time by everyone.

Exp. 8: A continuous public good game

z-Tree

More contracts table

z-Tree
Note that the contracts table can also be used for interaction
within the same screen.
Use the new command to create the table
Use contract grid boxes
Important: Changes to variables during the screen are NOT
recorded in the data

Other Features
z-Tree
Programming
Loops: while( condition ) { statements; }
Complex move structures
goto next stage if
Treatments with indefinite length
end with a given probability
end when a specific action is taken
Graphics
Charts
Display Pictures/Videos
Communication
Chat box

Questionnaires
z-Tree
Must be run so that the payoff file is written.
Questions with no consequence on payoff.
Different formats for the questions.
Layout is not screen oriented: indefinite end with scrollbar.
Text entry possible.
Typical Questionnaires:
Address form (writes the payment file)
Questions concerning their strategies
Profit display
Goodbye screen

Planning a simple session

z-Tree
Welcome treatment (welcome.ztt)
Set the show-up fee
Control questions
Public goods experiment (pg.ztt)
The main treatment
Ultimatum game (ug.ztt)
A second treatment
Questionnaires and payment (end.ztq)
payment file

How to build a test environment

z-Tree
Unzip ztree.zip folder.
If they are not there, you need to copy the files ztree.exe and
zleaf.exe to the folder programs

Open ztree with the batch file: openztree.bat

Open the file: Open Zleafs.exe

Set as many zLeafs as necessary

If needed, change screen
resolution and other options