headline:-
   write('% --------------------------------------------------------- %'),nl,
   write('%     simulating common knowledge and speculative trade.    %'),nl,
   write('% --------------------------------------------------------- %'),nl,
   write(' trader/5 to simulate the trade negotiation procces.'),nl,
   write('  trader(Type,Agent,Time_and_State,ProbWin,Reply).'),nl,
   write('  ex.1,'),nl,
   write('   ?- trader(sophist,J,S,Q,D).'),nl,
   write('  ex.2,'),nl,
   write('   ?- trader(rational,J,(T,S),Q,D).'),nl.
me:-
   write('% file: trade.pl.'),nl,
   write('% created: 16-19 Jan 2003.'),nl,
   write('% modified: 22-26 Jan 2003.'),nl,
   write('% modified: 11 Feb 2003.'),nl,
   write('% author: Kenryo INDO (Kanto Gakuen University) '),nl,
   write('% url: http://www.us.kanto-gakuen.ac.jp/indo/front.html'),nl.
references:-
   write('% references:'),nl,
   write('% [1] Aumann, R. J. (1976). Agreeing to disagree.'),nl,
   write('%   Annals of Statistics 4: 1236-1239.'),nl,
   write('% [2] Geanakoplos, J. (1992). Common knowledge.'),nl,
   write('%   Journal of Economic Perspective  6: 53-82.'),nl,
   write('%   also in R. J. Aumann and S. Hart (eds.),'),nl,
   write('%   Handbook of Game Theory 2: 1437-1496, 1994.'),nl,
   write('% [3] Milgrom, P. and N. Stokey (1982). Information, trade '),nl,
   write('%   and common knowledge. Journal of Economic Theory 26: 17-27.'),nl,
   write('% [4] Sebenius, J. K. Geanakoplos, J. (1983). Dont bet on it:'),nl,
   write('%   contingent agreements with aymmetric information.'),nl,
   write('%   Journal of American Statistical Association 78(382): 424-426.'),
   nl.

:- dynamic  true_state/1.
:- dynamic  said/3.
:- dynamic  said/4.

:- headline.

model_of_trader(X):-
   member(X,[ex_ante,naive,sophist,rational]).

uts(S):-
   update_true_state(S).
update_true_state(S):-
   state(S),
   abolish(true_state/1),
   assert(true_state(S)).

make_public(S):-
   state(S),
   assert(said(public,0,is_impossible(S))).

%
% -------------------------------------------------  %
%  knowledge operators via possibility correspondences. 
% -------------------------------------------------  %
% added: 25 Jan 2003. 
% However, these four predicates are not used in trade.pl
know_event_when(J,E,K):-
   agent(J),
   event(E),
   setof(S,
     H^(
      partition(J,S,H),
      subset(H,E)
     ),
   K).
dont_know_event_when(J,E,DK):-
   agent(J),
   event(DK),
   DK \= [],
   event(E),
   E \= [],
   \+ know_event_when(J,E,DK).
think_possible_when(J,E,P):-
   agent(J),
   event(E),
   setof(S,
     H^(
      partition(J,S,H),
      intersection(H,E,M),
      M\=[]
     ),
   P).
think_impossible_when(J,E,U):-
   think_possible_when(J,E,P),
   all_states(O),
   subtract(O,P,U),
   U\=[],
   event(U).
%
% -------------------------------------------------  %
%  state, agent, information (partition),
%  and possibility correspondences
% -------------------------------------------------  %
true_state(s3).
all_agents([1,2]).
all_states([s1,s2,s3,s4,s5]).
agent(J):-all_agents(Is),member(J,Is).
state(S):-all_states(Ss),member(S,Ss).
%
%                state 　 s1　s2　s3　s4　s5
% ---------------------------------------------
%  Partition of 1 (P1)    1a  1b  1b  1c  1c
%  Partition of 2 (P2)    2x  2x  2y  2y  2z
% ---------------------------------------------
%  Fig.2 partitions of Milgrom and Stokey's example.
%
%/*
partition(1,s1,[s1]).
partition(1,S,[s2,s3]):-member(S,[s2,s3]).
partition(1,S,[s4,s5]):-member(S,[s4,s5]).
partition(2,S,[s1,s2]):-member(S,[s1,s2]).
partition(2,S,[s3,s4]):-member(S,[s3,s4]).
partition(2,s5,[s5]).
%*/
%
% a nested example inspired by Rubinstein and Wolinsky(1990)
% which induce speculative trades everywhere. 
%
/*
partition(1,s1,[s1,s2,s3,s5]).
partition(1,S,[s2,s3]):-member(S,[s2,s3]).
partition(1,s4,[s4,s5]).
partition(1,s5,[s5]).
partition(2,s1,[s1]).
partition(2,s2,[s1,s2]).
partition(2,S,[s3,s4]):-member(S,[s3,s4]).
partition(2,s5,[s1,s3,s4,s5]).
%
*/
think(J,S,is_impossible(O)):-
   agent(J),
   state(S),
   state(O),
   \+ think(J,S,is_possible(O)).
think(J,S,is_possible(O)):-
   agent(J),
   state(S),
   partition(J,S,H),
   member(O,H),
   \+ said(public,0,is_impossible(O)).
think(J,S,K):-
   K = think(_J1,O,_O1),
   think(J,S,is_possible(O)),
   K.
%
test_think(S,S1,X,M):-
   X=[S1,S2,S3,S4,S5,S6],
   (M==fix->(
    S1=s1,
    S2=s1,
    S3=s2,
    S4=s3,
    S5=s4,
    S6=s5
   );true),
   think(1, S1,
     think(2, S2,
       think(1, S3,
         think(2, S4,
           think(1, S5,
             think(2, S6,
               is_possible(S)
             ) 
           )
         )
       )
     )
   ).
%
%            probability of transfer
%     sate     q1(1->2)   q2(2->1)    p(q2|S)    p(S)   
%    -----------------------------------------------------
%      s1       .20        .05         1/5       .25    
%      s2       .05        .15         3/4       .20    
%      s3       .05        .05         1/2       .10    
%      s4       .15        .05         1/4       .20    
%      s5       .05        .20         4/5       .25    
%    -----------------------------------------------------
%    Fig.1 trade example of Milgrom and Stokey(1982).

% -------------------------------------------------  %
%  probability and game payoffs of the trade
% -------------------------------------------------  %
%
%/*
probability(w1,s1, 0.20).
probability(w1,s2, 0.05).
probability(w1,s3, 0.05).
probability(w1,s4, 0.15).
probability(w1,s5, 0.05).
probability(w2,s1, 0.05).
probability(w2,s2, 0.15).
probability(w2,s3, 0.05).
probability(w2,s4, 0.05).
probability(w2,s5, 0.20).
%*/
/*
probability(w1,s1, 0.10).
probability(w1,s2, 0.05).
probability(w1,s3, 0.15).
probability(w1,s4, 0.15).
probability(w1,s5, 0.05).
probability(w2,s1, 0.05).
probability(w2,s2, 0.15).
probability(w2,s3, 0.15).
probability(w2,s4, 0.05).
probability(w2,s5, 0.10).
*/
test_prob(P):-
    findall(A,probability(_W,_S,A),Ps),
    sum(Ps,P).
probability(S, P):-
    state(S),
    findall(A,probability(_W,S,A),Ps),
    sum(Ps,P).
%
% game_outcome and payoff
% -----------------------------------------------------------  %
payoff(agent(J),win,1):-agent(J).
payoff(agent(J),loose,-1):-agent(J).
game_outcome(w1,agent(1),loose).
game_outcome(w1,agent(2),win).
game_outcome(w2,agent(1),win).
game_outcome(w2,agent(2),loose).
%
% expected payoff (if no information is available)
% -----------------------------------------------------------  %
expected_payoff(J,S,E):-
    game_outcome(W,agent(J),O),
    probability(W,S,P),
    payoff(agent(J),O,U),
    E is P * U.
expected_payoff(J,V):-
    agent(J),
    findall(E,
      (
       expected_payoff(J,_S,E)
      ),
    H),
    sum(H,V).
%
% conditional probability and conditional expectation
% -----------------------------------------------------------  %
probability_of_event(W,E,P):-
    event(E1), % conditionalization by event specified directly
    (var(E)->E = E1; sort(E,E1)),
    G = member(S,E1),
    findall(A,(probability(W,S,A),G),Ps),
    sum(Ps,P).
probability_of_event(W,E,P,G):-
    \+ var(G), % conditionalization via constraints indirectly
    G=(Goal,M,[W,S,A]),  % constraints with params
    findall([S1,A1],
      (
       (M=do->(W=W1,S=S1,A=A1);true),
       probability(W1,S1,A1),
       Goal
      ),
    Xs),
    findall(S,member([S,A],Xs),E0),
    findall(A,member([S,A],Xs),Ps),
    sort(E0,E),
    sum(Ps,P).
%
% below was not used in trade.pl
conditional_probability(S,P,E):-
    state(S),
    event(E1), 
    (var(E)->E = E1; sort(E,E1)),
    findall(A,conditional_probability(_W,S,A,E),Ps),
    sum(Ps,P).
conditional_probability(W,S,P,E):-
    probability(W,S,P1),
    event(E1),
    (var(E)->E = E1; sort(E,E1)),
    (\+ member(S,E)
     -> P=0
     ;
      (
       probability_of_event(W,E,P0),
       P is P1 / P0
      )
    ).
conditional_probability(W,S,P,E,G):-
    probability(W,S,P1),
    event(E1),
    (var(E)->E = E1; sort(E,E1)),
    (\+ member(S,E)
     -> P=0
     ;
      (
       probability_of_event(_W0,E,P0,G),
       P is P1 / P0
      )
    ).
%
conditional_expected_payoff(J,S,V,H):-
    game_outcome(W,agent(J),O),
    conditional_probability(W,S,P,H),
    payoff(agent(J),O,U),
    V is P * U.
conditional_expected_payoff(J,V,H):-
    agent(J),
    event(H),
    findall(E,
      (
       conditional_expected_payoff(J,_S,E,H)
      ),
    V0),
    sum(V0,V).
%
% -------------------------------------------------  %
%  ex ante expectation of win
% -------------------------------------------------  %
win_prob(J,S, Q):-
    state(S),
    game_outcome(W,agent(J),win),
    probability(W,S,Q1),
    probability(S,P0),
    Q is Q1 / P0.
win_prob(J,S, Q):-
    true_state(0),
    win_prob(J,S, Q).
win_prob_on_event(J,H, Q):-
    event(H),
    \+ H = [],
    probability_of_event(_,H,P0),
    game_outcome(W,agent(J),win),
    probability_of_event(W,H,P1),
    Q is P1 / P0.
%
% -------------------------------------------------  %
%  decision criteria (common)
% -------------------------------------------------  %
is_probability(Q):-
   (
    (
     number(Q),
     Q >= 0,
     Q =< 1
    )
    -> true;
    (
     write('invalid value of probability.'),
     fail
    )
   ).
decision(Q,D):-
    is_probability(Q),
    (
     Q > 0.5 -> D = ok;
     Q = 0.5 -> D = indifferent;
     D = reject
    ).
%
% -------------------------------------------------  %
%  model of trader (1) --- naive expectation
% -------------------------------------------------  %
trader(naive,J,S,Q,D):-
    state(S),
    partition(J,S,H),
    win_prob_on_event(J,H, Q),
    decision(Q,D).
%
% -------------------------------------------------  %
%  model of trader (2) --- 2nd order expectation
%   with a sort of certainty reasoning 
% -------------------------------------------------  %
trader(sophist,J,S,Q,D):-
   trader(naive,J,S,Q,D0),
   (
    (
     D0 = ok,
     partition(J,S,H),
     \+ (
      member(S1,H),
      agent(J1),
      J1 \= J,
      trader(naive,J1,S1,_Q1,reject),
      write(trader(naive,J1,S1,_Q1,reject))
     )
    )
    ->
     D = D0
    ;
     D=reject
   ).
%
% -------------------------------------------------  %
%  model of trader (3) --- 
%  expectation under common knowledge of rationality 
% -------------------------------------------------  %
% iterative message exchange reveals private information. 
trader(rational,J,(T,S),Q,D):-
   state(S),
   time(T/N),
   T > 0,
   agent(J),
   move(J,T/N,yes),
   %T1 is T - 1,
   delay(T,1,T1),
   partition(J,T1/N,S,H),
   win_prob_on_event(J,H, Q),
   decision(Q,D).
%
%-----------------------------------------------
/*  the supporting evidence of state   */
%-----------------------------------------------
is_consistent_with_information(T,S,O):-
   time(T/_N),
   state(S),
   state(O),
   agent(J),
   trader(rational,J,(T,S),_Q,D),  % real.
   trader(rational,J,(T,O),_Q1,D).  % expected.
%
%*********************************
/* cited from ck01.pl  */
%*********************************
%
% -------------------------------------------------  %
%  event, (static) knowledge, and reachability
% -------------------------------------------------  %
event(E):-
   all_states(O),
   subset_of(E,_N,O).
know(J,S,E):-
   agent(J),
   state(S),
   partition(J,S,H),
   event(E),
   subset(H,E).
% 
% -------------------------------------------------  %
%  common knowledge via meet of partitions
% -------------------------------------------------  %
meet_of_partitions([J],[S],H):-
   partition(J,S,H).
meet_of_partitions([J|Js],[S|Ss],M):-
   meet_of_partitions(Js,Ss,M1),
   partition(J,S,H),
   \+ cyclic(J/Js,S/Ss),
   \+ subset(H,M1),
   intersection(M1,H,H12),
   H12 \= [],
   union(H,M1,M2),
   sort(M2,M).
%
%-----------------------------------------------
/*  time and  act of agent : message process   */
%-----------------------------------------------
time(0/N):- last_time(N).
time(T/N):- last_time(N),length(L,N), nth1(T,L,T).
all_times(Ts):- findall(T,time(T),Ts).
delay(T,1,T1):- all_times(Ts), nth0(T,Ts,T/N),T\=N,nth1(T,Ts,T1/N).
delay(T,1,T1):- last_time(T), T1 is T - 1.
delay(T,D,T1):- \+var(D), D >1,delay(T,1,T2), D1 is D - 1, delay(T2,D1,T1).

last_time(7).
move(J,0/N,no):-
   time(0/N), 
   agent(J).
move(J,T/N,yes):-
   time(T/N), 
   T > 0,
   %T1 is T - 1,
   delay(T,1,T1),
   agent(J),
   all_agents(Is),
   length(Is,NL),
   J is T1 mod NL + 1.
%
%-----------------------------------------------
/*  dynamic knowledge updated by messages   */
%-----------------------------------------------
partition(J,T/N,S,H):-
   time(T/N),
   partition(J,S,H1),
   remove_impossible_states(J,T/N,S,H1,H).
%
know(J,T/N,S,E):-
   time(T/N),
   agent(J),
   state(S),
   partition(J,T/N,S,H),
   % remove_impossible_states(J,T/N,S,E,H), 
   (length(H,1)->E=H;true),
   event(E),
   subset(H,E).
%
remove_impossible_states(J,T/N,S,E,H):-
   time(T/N),
   agent(J),
   state(S),
   event(E),
   findall(X,
      think(J,T/N,S,is_impossible(X)),
   D),
   subtract(E,D,F),
   sort(F,H).
%
think(J,T/N,S,is_impossible(O)):-
   agent(J),
   time(T/N),
   state(S),
   state(O),
   \+ think(J,T/N,S,is_possible(O)).
%
think(J,0/N,S,is_possible(O)):-
   time(0/N),
   think(J,S,is_possible(O)).
think(J,T/N,S,is_possible(O)):-
   time(T/N),
   T \= 0,
   %T1 is T - 1,
   delay(T,1,T1),
   think(J,T1/N,S,is_possible(O)),
   is_consistent_with_information(T,S,O).
%
%-----------------------------------------------
/*  utilities   */
%-----------------------------------------------
bag0([],_A,0).
bag0([C|B],A,N):-
   length([C|B],N),
   bag0(B,A,_N1),
   member(C,A).
zeros(Zero,N):-bag0(Zero,[0],N).
ones(One,N):-bag0(One,[1],N).
%
% subset_of/3 : subset-enumeration 
% -----------------------------------------------------------  %
subset_of(A,N,As):-
   length(As,L),
   length(D,L),
   list_projection(D,As,B),
   length(B,N),
   sort(B,A).
% a sequence of binary choice for a list:
%--------------------------------------------------
list_projection([],[],[]).
list_projection([X|Y],[_A|B],C):-
   X = 0,
   list_projection(Y,B,C).
list_projection([X|Y],[A|B],[A|C]):-
   X = 1,
   list_projection(Y,B,C).
% sum
% -----------------------------------------------------------  %
sum([],0).
sum([X|Members],Sum):-
   sum(Members,Sum1),
  %number(X),
   Sum is Sum1 + X.
%
% product
% -----------------------------------------------------------  %
product([],1).
product([X|Members],Z):-
   product(Members,Z1),
  %number(X),
   Z is Z1 * X.
%
% weighted sum
% -----------------------------------------------------------  %
product_sum([],[],[],0).
product_sum([P|Q],[A|B],[E|F],V):-
    length(Q,N),
    length(B,N),
    product_sum(Q,B,F,V1),
    E is P * A,
    V is V1 + E.

% -------------------------------------------------  %
% alias -- if you like
% -------------------------------------------------  %
pr(W,S,P):-
    probability(W,S,P).
xpf(J,S,E):-
    expected_payoff(J,S,E).
prev(W,E,P):-
    probability_of_event(W,E,P).
prev(W,E,P,G):-
    probability_of_event(W,E,P,G).
cpr(W,S,P,E):-
    conditional_probability(W,S,P,E).
cxpf(J,S,V,H):-
    conditional_expected_payoff(J,S,V,H).
cxpf(J,V,H):-
    conditional_expected_payoff(J,V,H).
%
icwi(T,S,O):-
   is_consistent_with_information(T,S,O).
mops(Js,Ss,M):-
   meet_of_partitions(Js,Ss,M).
% it is relatively difficult to find a path of enumerating states.
test_mops(B,C,N):-
   mops([1,2,3,1,2,3,1],B,C),
   length(C,N).
rimps(J,T/N,S,E,H):-
   remove_impossible_states(J,T/N,S,E,H).
%
%----a utility but not used
%
display_trader(S,[Type1,Type2],[P1,P2],X):-
   write('%----------------------------------% '),
   nl,
   write('  Under the true state '),
   write(S),
   write(','),
   nl,
   write(' the traders of a pair of types <'),
   write((Type1,Type2)),
   write('>  '),
   nl,
   write(' and each of who has the expectation of win  '),
   write((P1,P2)),
   nl,
   write(' respectively, '),
   write(X),
   write('.'),
   nl,
   write('%----------------------------------% '),
   nl.
%
%end