Virtual implementation :
simulation by prolog
23 Nov 2003
Kenryo INDO
Kanto Gakuen University
Game theory and mechanism design
• Game theory has been widely used in economic /management
sciences since von Neumann and Morgenstern’s work in 1947.
• Mechanism design (or implementation) theory [4,5] is a subfield of
game theory which has been applied to the social choice theory and
other mathematical economic theories including some management
technologies such as auction, accounting and congestion control.
• Game theorists (or their role as the social planner) tried to achieve to
match the given desirable goal for the model of society (i.e., the
social choice rule (SCF) for small sized team or market economy)
with their autonomous, rational, selfish, or opportunistic behaviors,
i.e., the set of Nash equilibrium, of the individual members.
• They found implementation theorems and developed game forms in
order for the above objective. Lottery (or stage) mechanism with
small fines [1—4] is known as the most powerful in that it can
implement almost any SCF. Whereas other non-lottery (or singlestage) mechanisms are required so that the SCF satisfies
monotonicity and if you further want to qualify unique equilibrium
then the impossibility results in general unrestricted environment (i.e.,
only dictatorial or constant SCFs are implementable).
Logic programming and Prolog
• We will utilize Prolog, a logic programming technique, in order for
modeling game theoretic ( autonomous, and rational) agents and
mechanisms for the coordination of agents society.
• Prolog is an abbreviation of “programming language in logic.”
• The standard syntax is called Edinburgh-prolog or ISO-prolog.
• A sentence of Prolog code is a definite clause which is the pair of
head, goal :- body, which can be seen as a disjunctive with one
positive literal (i.e., Horn clause), `goal Or negation of body’ in logic.
• Goal of a clause is a predicate with some arity, and body is
predicates separated with comma which is the sufficient condition of
the goal.
– Ex. city(X):- ancient_capital(X,Japan), X \= nara.
• Prolog is driven by the SLD-resolution technique that is developed in
the joint-field of natural language processing and automated theorem
proving systems.
an agency model
(mere descriptive)
% a descriptive model of agency
%-------------------------------member_of_agency(manager).
member_of_agency(worker1).
member_of_agency(worker2).
possible_result_of_business(success(1)).
possible_result_of_business(success(2)).
possible_result_of_business(fail).
possible_decision_of_manager(reward(a)).
possible_decision_of_manager(reward(b)).
possible_level_of_effort_of_worker(high).
possible_level_of_effort_of_worker(low).
a game theoretical modeling by
prolog
% the base model of agency
%-----------------------------------------------------game(agency(0),
players([worker1,worker2]),
acts([report(S1),report(S2)]),
payoffs(Y)
):member([S1,S2,Y],
[
[success1,success1,[180,120]],
[success1,success2,[0,0]],
[success2,success1,[0,0]],
[success2,success2,[120,180]]
]
).
Nash equilibrium and best
response
best_response(G,J,N,S,P):game(G,
players(N),acts(S),payoffs(P)
),
member(J,N),
\+ defeated_by(G,J,N,[S,P],_).
nash(G,J,N,S,P):best_response(G,J,N,S,P).
nash(G,players(N),acts(S),payoffs(P)):game(G,
players(N),acts(S),payoffs(P)
),
\+ (
member(J,N),
\+ best_response(G,J,N,S,P)
).
mutate(G,S,J,S1):game(G,players(N),acts(S),_),
game(G,players(N),acts(S1),_),
subtract(N,[J],NJ),%write(remains(NJ)),nl,
forall(member(J1,NJ),
(
nth1(K,N,J1),%write(j1(J1,k(J))),
nth1(K,S,SK),%write(s(SK)),
nth1(K,S1,SK1),%write(s1(SK1)),nl,
SK = SK1
)).
defeated_by(G,J,N,[S,P],[S1,P1]):game(G,players(N),acts(S),payoffs(P)),
nth1(K,N,J),
(
mutate(G,S,J,S1),
game(G,players(N),acts(S1),payoffs(P1)),
nth1(K,P1,PK1),
nth1(K,P,PK),
PK < PK1
).
The Nash equilibria of four: two pair
of truth-telling and of joint-fraud
?- nash(A,B,C,D).
A = agency(0)
B = players([worker1, worker2])
C = acts([report(success1), report(success1)])
D = payoffs([180, 120]) ;
A = agency(0)
B = players([worker1, worker2])
C = acts([report(success2), report(success2)])
D = payoffs([120, 180]) ;
A = agency(1, true_state(success1))
B = players([worker1, worker2])
C = acts([report(success1), report(success1)])
D = payoffs([361, 120]) ;
A = agency(1, true_state(success2))
B = players([worker1, worker2])
C = acts([report(success2), report(success2)])
D = payoffs([301, 180]) ;
No
a simple mechanism with large aux.
reward
game(parameter,true_state,nature,S):member(S,[success1,success2]).
% a run.
?- nash(agency(1,S),B,C,D).
game(parameter,auxiliary_reward1,worker1,181).
game(agency(1,true_state(S)),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([Y1,Y2])
):game(agency(0),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([X1,X2])
),
game(parameter,true_state,nature,S),
game(parameter,auxiliary_reward1,worker1,M),
(R1 =S -> Bonus =M ; Bonus =0),
Y1 is X1 + Bonus,
Y2 = X2.
S = true_state(success1)
B = [worker1, worker2]
C = [report(success1), report(success1)]
D = [361, 120] ;
S = true_state(success2)
B = [worker1, worker2]
C = [report(success2), report(success2)]
D = [301, 180] ;
No
?-
Virtual implementation in iteratively
undominated strategies under
complete information
•
•
•
A-M mechanism was developed by Abreu and Matsushima [1,2] for two or
more agents is the stage game with small fines which yields a lottery of
choice objects where each agent (simultaneously or iteratively) reports
own preference and a sequence of finite length K preference profiles.
For any small positive probability, e, arbitrarily close to 0, the mechanism
selects dictatorial outcomes in the last messages each of which is
implementable, and for each stage less than K the mechanism perturbs
pure objective x in the original SCF mixed with another object, say, x-bar.
If unanimous the origial is the case. Only if the cases of a single deviated
agent who reports different profile from others, the same lottery will be
selected and a small fine $(1/K) for the deviator. Otherwise x-bar to be
selected. Other than the disagree fine, additional fine, $1, penalty for the
last revision. Truthful equilibrium brings about the right outcome with
probability, (1-Ne), i.e., almost 1.
Abreu and Matsushima[1] proved the theorem by using above mechanism
that assuming that for any pair of preference profile (w,w1) such that each
agent has same preference under w and w1 iff the SCF has same value,
the truth-telling in every stage is a unique iteratively undominated strategy
message profiles (if N>2 or if N=2 and truth-telling profiles is NE). The
assumption may be dropped if renegotiation is available[3].
On advantages and criticisms
•
•
•
•
•
This type of mechanism is very powerful and robust because it can implement any
social choice rule approximately in iteratively undominated strategy equilibrium [1].
(Cf., Single stage implementation model requires that SCF must be monotonic given
possible preference profiles.)
By making use of Dekel-Fundenberg-Bogers procedure which permits an elimination
of weakly dominated strategies only at the first step in the mechanism, it yields unique
outcome which is order independent for the sequence of reports [2].
Criticism for the A-M mechanism was firstly pointed out by Glazer and Rosenthal with
response by Abreu and Matsushima in Econometrica 60, pp.1435-42, 1992. They
make a case where the principal can implement a non-Pareto optimal outcome by
using AM mechanism. Apparently, the problem is not that of suggesting
vulnerableness of the AM mechanism.
Since no longer the constraint on the set of implementable SCFs, as stated by one of
the authors [4], it would be issued that the design of SCF itself with the focal set, i.e.,
which SCF should be implemented including that seems, at least at first glance,
irrational.
Virtual Bayesian implementation is incomplete information analogue of virtual
implementation under complete information. It is questionable whether Bayesian
monotonicity can be dispensed as well as Maskin monotonicity in the complete
information environment[6]. Sufficient conditions has been argued by Abreu and
Matsushima (A-M measurability), Duggan (incentive consistency), and Serrano and
Vohra.
A variant of AM mechanism for two
agent case[3]
• Each agent reports a sequence of own willing effort
levels. (message process as negotiation)
• After message process the manager should decide a
small bonus for agent 1 according to the last report from
agent 1 which is a unit of known implementable (i.e.,
dictatorial) outcome.
• Rewards are scaled proportionally to the time interval
the profile being reported.
• Fine for the final revision of the report during negotiation.
• Fine agent 2 if disagree as a side-payment to agent 1.
• These fines will vanish in the equilibrium ( iterated
dominance, correctly ) which yields the truthful reports.
A prolog simulation of AM
mechanism: game parameters
% the original final time is 400 in [3].
game(parameter,time_limit,manager,4).
game(parameter,auxiliary_reward2,manager,1).
game(parameter,penalty,last_revision,2.00).
game(parameter,penalty,last_disagree_for_worker2,
1.00).
game(parameter,utility_scale,manager,0.01).
Initialization for the protocol
game(virtual(
time(0),
true_state(S),
reports([[],[]])
),
B,C,D):B=players([worker1,worker2]),
C=acts([report(null),report(null)]),
D=payoffs([0,0]),
game(parameter,true_state,nature,S).
Recursive protocol of negotiation
game(virtual(
time(T),
true_state(S),
reports([H1,H2])
),
B,C,D):B = players([worker1,worker2]),
C = acts([report(R1),report(R2)]),
D = payoffs([Y1,Y2]),
length([_|H1],T),
game(parameter,time_limit,manager,K),
(T > K -> !,fail; true),
T0 is T-1,
A1=virtual(
time(T0),
true_state(S),
reports([HR1,HR2])
),
B1=players([worker1,worker2]),
C1=acts([report(RR1),report(RR2)]),
D1=payoffs([X1,X2]),
game(A1,B1,C1,D1),
(RR1=null
->[H1,H2]=[HR1,HR2]
;[H1,H2]=[[RR1|HR1],[RR2|HR2]]
),
%(to be continued)
% (continued)
game(
agency(0),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([U1,U2])
),
game(
virtual_closing(
time(T),
true_state(S),
reports([H1,H2]),
last_revised(_LRT,_Renagade1)
),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([W1,W2]) % fines and bonus
),
game(parameter,utility_scale,manager,US),
Y1 is X1 + US * U1/K - W1,
Y2 is X2 + US * U2/K - W2.
%nl,write(payoff(1):Y1 is X1 + US * U1/K - W1),
%nl,write(payoff(2):Y2 is X2 + US * U2/K - W2).
Closing negotiation
game(
virtual_closing( time(K), true_state(S), reports([H1,H2]), last_revised(LRT,Renagade) ),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([Fine1,Fine2])
):game(parameter,time_limit,manager,K),
!,
length([_|H1],K),
game( penalty_for_last_revised(Renagade,LRT,[R1,R2],[H1,H2],K),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([FineA1,FineA2])
),
%penalty_for_last_disagree(worker2)
game(parameter,penalty,last_disagree_for_worker2,PW2),
(R1 =R2 -> FineB =0 ; FineB is PW2/K),
game(parameter,auxiliary_reward2,manager,M),
(R1 =S -> Bonus =M ; Bonus =0),
Fine1 is FineA1 - FineB - Bonus,
Fine2 is FineA2 + FineB.
game(virtual_closing(_,_,_,_),_,_,payoffs([0,0])).
Computing fines
game( penalty_for_last_revised(Renagade,LRT,[R1,R2],[H1,H2],K),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([FineA1,FineA2])
):min( LRT1,((nth1(LRT1,H1,RB1),RB1\=R1,!);LRT1 is K )),
min( LRT2,((nth1(LRT2,H2,RB2),RB2\=R2,!);LRT2 is K )),
((LRT1=LRT2,LRT1>=K)->(Renagade=non,LRT=K,!);true),
((LRT1=LRT2,LRT1<K)->(Renagade=both,LRT=LRT1,!);true),
(LRT1<LRT2->(Renagade=worker1,LRT=LRT1,!);true),
(LRT1>LRT2->(Renagade=worker2,LRT=LRT2,!);true),
%nl,write(last_revision:LRT-Renagade),
game(parameter,penalty,last_revised,Penalty),
L is Penalty / K,
G = 0,
%G is -L,
member(
[Renagade,FineA1,FineA2],
[[worker1,L,G],[worker2,G,L],[both,L,L],[non,0,0]]
% It will not wrok well if we specify the fine as follows analogically in Ref. 3, p.4, ll.12.
%[[worker1,L,G],[worker2,G,L],[both,0,0],[non,0,0]]
).
A test run : the final state
?- [am01].
------------------------------------------------------------------% implementation problem in agency---- Abreu-Matsushima mechanism
------------------------------------------------------------------Warning: (d:/prolog/source/am01.pl:820):
Clauses of game/4 are not together in the source-file
% am01 compiled 0.09 sec, 10,748 bytes
Yes
?- nash(virtual(time(4),true_state(success1),reports([[R,R,R],[R,R,R]])),P,A,U).
R = success1
P = players([worker1, worker2])
A = acts([report(success1), report(success1)])
U = payoffs([2.8, 1.2]) ;
R = success2
P = players([worker1, worker2])
A = acts([report(success1), report(success1)])
U = payoffs([1.85, 1.15]) ;
No
?-
Simulation of the AM mechanism
game(virtual(S),
players([worker1,worker2]),
acts([report([R1|H1]),report([R2|H2])]),
payoffs([Y1,Y2])
):game(
parameter,
time_limit,
manager,
K
),
game(
virtual(
time(K),
true_state(S),
reports([H1,H2])
),
players([worker1,worker2]),
acts([report(R1),report(R2)]),
payoffs([Y1,Y2])
).
% ---------------- test run ----------------
?- nash(virtual(S),P,acts([A,B]),U).
S = success1
P = players([worker1, worker2])
A = report([success1, success1, success1, success1])
B = report([success1, success1, success1, success1])
U = payoffs([2.8, 1.2])
S = success2
P = players([worker1, worker2])
A = report([success2, success2, success2, success2])
B = report([success2, success2, success2, success2])
U = payoffs([2.2, 1.8]) ;
No
Experimental lower bound of
auxiliary reward
final time lower bound
1
0.8001
2
1.3001
3
0.94
4
0.75
5
0.56
Other Parameters:
penalty
last_revision,2.
last_disagree,1.
utility_scale, 0.01.
?- nash(virtual(S),P,acts([A,B]),U).
S = success1
P = players([worker1, worker2])
A = report([success1, success1, success1, success1, success1])
B = report([success1, success1, success1, success1, success1])
U = payoffs([2.36, 1.2]) ;
S = success2
P = players([worker1, worker2])
A = report([success2, success2, success2, success2, success2])
B = report([success2, success2, success2, success2, success2])
U = payoffs([1.76, 1.8]) ;
No
?- game(parameter,auxiliary_reward2,manager,Z).
Z = 0.56
No
?-
Modeling inductive play
game(virtual_inductive(
time(K),
true_state(S),
reports([H1,H2])
),B,C,D):game(parameter,time_limit,manager,K),
A=virtual(
time(K),
true_state(S),
reports([H1,H2])
),
B=players([worker1,worker2]),
C=acts([report(_R1),report(_R2)]),
D=payoffs([_U1,_U2]),
game(A,B,C,D).
% another brief form for test run.
game(virtual_inductive(T,S,[H1,H2]),P,A,U):game(
virtual_inductive(
time(T),
true_state(S),
reports([H1,H2])
),
P, A, U
).
game(virtual_inductive(
time(T1),
true_state(S),
reports([H1,H2])
),B1,C1,D):A1=virtual( time(T1), true_state(S), reports([H1,H2]) ),
B1=players([worker1,worker2]),
C1=acts([report(R1),report(R2)]),
D1 = payoffs([_U1,_U2]),
game(parameter,time_limit,manager,K),
length([_|L],K),
% alternative: in order to
nth1(T1,L,T1),
% utlize the experimental log
length([_|H1],T1),
% of the previous steps.
T0 is T1 + 1,
A = log_inductive1(
A = virtual_inductive(
T0,
time(T0),
S,
[[R1|H1],[R2|H2]]
true_state(S),
),
reports([[R1|H1],[R2|H2]])
),
B = players([worker1,worker2]),
C = acts([report(_RR1),report(_RR2)]),
D = payoffs([_Y1,_Y2]),
% for the sake of the above.
nash(A,B,C,D),
game_ log (A1,B1,C1,D1),
game(A1,B1,C1,D1).
Experimention of inductive play
?- game(test_inductive1(1,S1,H),P,A,U).
S1 = success1
H = [[], []]
P = players([worker1, worker2])
A = acts([report(success1), report(success1)])
U = payoffs([2.8, 1.2]) ;
S1 = success2
H = [[], []]
P = players([worker1, worker2])
A = acts([report(success2), report(success2)])
U = payoffs([2.2, 1.8]) ;
No
?-
references
• [1] D. Abreu and H. Matsushima (1992). Virtual implementation.
Econometrica 60: 993-1008.
• [2] D. Abreu and H. Matsushima (1995). Exact implementation.
Journal of Economic Theory 64: 1-19.
• [3] H. Matsushima (1996). Mekanizumu dezain no gehmu riron.
[Game theory of mechanism design.] Keizaigaku Ronshu 62(1): 212.
• [4] H. Matsushima (1996). A-M mekanizumu no gohrisei. [Rationality
of A-M mechanism.] Keizai Kenkyu 47(1): 1-15.
• [5] L.C. Corchon (1996). The Theory of Implementation of socially
Optimal Decisions in Economics. Macmillan/St. Martin’s Press.
• [6] R. Serrano and R. Vohra (2001). Some limitations of virtual
Bayesian implementation. Econometrica 69(3): 785-792.