data_of_this_program([
  line('%-------------------------------------------------------%'),
  title('reputation model by Kreps and Wilson(1982).'),
  line('%-------------------------------------------------------%'),
  program_name('repu0.pl'),
  created(date('9-10 May 2003'),by('Kanto Gakuen University')),
  reference(author('Kreps, D. M. and R. Wilson (1982)')),
  reference(title('Reputation and imperfect information')),
  reference(journal('Journal of Economic Theory 27: 253-279.')),
  line('%-------------------------------------------------------%'),
  main_predicate:make_script
]).

:- data_of_this_program(X),forall(member(T,X),(nl,write(T))).


:- dynamic game_script /1.
:- dynamic game_script /2.
:- dynamic history_of_play /3.
:- dynamic reason_of_play /3.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    the enterant-monopolist game model
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

model_parameter(b(0.5)).
model_parameter(a(2)).

first_stage(10).
stage(T):-
   first_stage(N),
   anum_seq1(A,N),
   reverse(A,B),
   member(T,B).

player(1,entrant).
player(2,monopolist(Type)):- member(Type,[weak,strong]).
play(entrant,exit).
play(entrant,entry).
play(monopolist(_),X->acquiescence):-play(entrant,X).
play(monopolist(_),X->fight):-play(entrant,X).


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    basic data of the game 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% scripts of the game plays
%(these are not always on the sequential equilibrium path.)

game_script(auto(0)).  % dummy data
game_script(no(1)).

game_script(no(1),history_of_play(1,entrant,exit)).
game_script(no(1),history_of_play(2,entrant,exit)).
game_script(no(1),history_of_play(3,entrant,entry)).
game_script(no(1),history_of_play(4,entrant,entry)).
game_script(no(1),history_of_play(5,entrant,entry)).
game_script(no(1),history_of_play(6,entrant,entry)).
game_script(no(1),history_of_play(7,entrant,exit)).
game_script(no(1),history_of_play(8,entrant,exit)).
game_script(no(1),history_of_play(9,entrant,exit)).
game_script(no(1),history_of_play(10,entrant,exit)).
game_script(no(1),history_of_play(1,monopolist(_),fight)).
game_script(no(1),history_of_play(2,monopolist(_),fight)).
game_script(no(1),history_of_play(3,monopolist(_),fight)).
game_script(no(1),history_of_play(4,monopolist(_),fight)).
game_script(no(1),history_of_play(5,monopolist(_),fight)).
game_script(no(1),history_of_play(6,monopolist(_),fight)).
game_script(no(1),history_of_play(7,monopolist(_),fight)).
game_script(no(1),history_of_play(8,monopolist(_),fight)).
game_script(no(1),history_of_play(9,monopolist(_),fight)).
game_script(no(1),history_of_play(10,monopolist(_),fight)).

set_script(N,Script):-
  abolish(history_of_play/3),
  game_script(N),
  findall(H,game_script(N,H),Script),
  forall(member(H,Script),assert(H)).



kth_entry(before(T),stage(T1),met_by(A)):-
   stage(T),
   history_of_play(T1,entrant,entry),
   T1 > T,
   history_of_play(T1,monopolist(_),A).

last_entry(before(T),stage(T1),met_by(A)):-
   kth_entry(before(T),stage(T1),met_by(A)),
   \+ (
     kth_entry(
       before(T),
       stage(T2),
       met_by(_)
     ),
     T2 > T,
     T1 > T2
   ).

next_stage(T<T1):-
   stage(T),
   stage(T1),
   T is T1 - 1.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    updating entrant's beliefs
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
initial_reputation(0.1).

prob(L,D):-
   first_stage(L),
   initial_reputation(D).

prob(T,0):-
   stage(T),
   \+ first_stage(T),
   kth_entry(
       before(T),
       stage(_T1),
       met_by(acquiescence)
   ).

prob(T,D):-
   stage(T),
   \+ first_stage(T),
   initial_reputation(D),
   \+ kth_entry(
       before(T),
       stage(_T1),
       met_by(_A)
   ).

prob(T,D):-
   stage(T),
   \+ first_stage(T),
   initial_reputation(D0),
   \+ kth_entry(
       before(T),
       stage(_),
       met_by(acquiescence)
   ),
   last_entry(before(T),stage(T1),met_by(fight)),
   model_parameter(b(B)),
   D2 = B^(T1-1),
   max_of(DZ,[D0,D2]),
   P is DZ,
   (P = DZ -> D = P; D=(DZ=P)).


% alternative modeling.
%-----------------------------------

prob(L,[D],[]):-
   first_stage(L),
   initial_reputation(D).

prob(T,X,H):-
   next_stage(T<T1),
   history_of_play(T1,entrant,A),
   history_of_play(T1,monopolist(_),A->B),
   prob_1(T<T1,A,B,X,H).

prob_1(_T<T1,exit,_,[D,D|P],H):-
   prob(T1,[D|P],H).

prob_1(T<T1,entry,fight,[D,D1|P],[enrtry(T1,fought)|H]):-
   prob(T1,[D1|P],H),
   D1 > 0,
   model_parameter(b(B)),
   D2 = B^T,
   max_of(D,[D1,D2]).

prob_1(_T<T1,entry,B,[0,D|P],[entry(T1,acquiescence)|H]):-
   prob(T1,[D|P],H),
   (
    D = 0;
    B = acquiescence
   ).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    updating strategies
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%----------- for the entrant

strategy(T,entrant,Case,Decision):-
   stage(T), 
   prob(T,[P|_],_),
   model_parameter(b(B)),
   D = B^T,
   decision_rule(entrant,case([P,D],Case),Decision).


%----------- for the monopolist

strategy(T,monopolist(strong),'I am strong.',DoX->fight):-
   stage(T),
   history_of_play(T,entrant,DoX).
strategy(T,monopolist(weak),Case,DoX->DoY):-
   stage(T), 
   prob(T,[P|_],_),
   model_parameter(b(B)),
   D1 = B^(T-1),
   history_of_play(T,entrant,DoX),
   decision_rule(monopolist(weak),case([T,P,D1],Case),DoX->DoY).


%----------- case-based decision criteria

decision_rule(entrant,case([P,D],Case),exit):-
   Case = [current_belief(P) > critical_level(D)],
   P > D.
decision_rule(entrant,case([P,D],Case),entry):-
   Case = [current_belief(P) < critical_level(D)],
   P < D.
decision_rule(entrant,case([P,D],Case),Y):-
   Case = [
     current_belief(P) = critical_level(D), 
     random(X,'%'), critical_level(100/A,'%')
   ],
   P = D,
   model_parameter(a(A)),
   X is random(101),(nl,write(random(X))),
   (X > 100/A -> Y=entry; Y=exit),!. 

decision_rule(monopolist(weak),case([_,_,_],C),exit->fight):-
   C = ['to make exit and deter.'].
decision_rule(monopolist(weak),case([1,_,_],C),entry->acquiescence):-
   C = ['entry at last.'].
decision_rule(monopolist(weak),case([T,P,D],C),entry->fight):-
   C = [
     entry_at_stage(T) > 1,
     current_belief(P) > critical_level(D)
   ],
   T > 1,
   P > D.
decision_rule(monopolist(weak),case([T,P,D],C),entry->Z):-
   C = [
     entry_at_stage(T) > 1,
     current_belief(P) < critical_level(D),
     random(X,'%'), fight_prob(FightProb)
   ],
   T > 1,
   P < D,
   FightProb = ((1-D) * P)/((1-P) * D),
   PF is FightProb,
   X is random(101),(nl,write(random(X))),
   (X > 100 * PF -> Z=fight; Z=acquiescence),!. 


%----------- make a sequence of decision

strategy_path(J,S,DP):-
   player(_,J),
   play(J,S),
   findall(T,(stage(T),strategy(T,J,_,S)),DP).


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    simulating strategies
%     with knowledge level explanations
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% by working the players' strategies above into play,
% this code generates a set of predicates of 
% history_of_play / 3 along the stages.


% ----  simulation at the behavior-level:
% make_script /0,1

create_new_script(N):-
   game_script(auto(N0)),
   \+ (game_script(auto(N1)),N1>N0),
   N is N0 + 1,
   assert(game_script(auto(N))).

init_script(N,M,M_not):-
   (var(M)->hear_user(type_of_monopolist(M));true),
   findall(Y, (player(_,monopolist(Y)),Y \= M),M_not),
    nl, write((M,M_not)),
   create_new_script(N).

make_script(N,T,J,Do):-
   H = history_of_play(T,J,Do),
   assert(H),
   assert(game_script(N,H)).

make_reason(N,T,J,Case):-
   R = reason_of_play(T,J,Case),
   assert(R),
   assert(game_script(N,R)).

make_script(M):-
   init_script(N,M,M_not),
   abolish(history_of_play/3),
   abolish(reason_of_play/3),
   forall(
     (
      stage(T),
      player(_,J),
      \+ (J=monopolist(TYM),member(TYM,M_not)) 
     ),
     (
      strategy(T,J,Case,Do),
      make_script(N,T,J,Do),
      make_reason(N,T,J,Case)
     )
   ),
   listing(history_of_play),
   hear_user(reason_of_play).

make_script:-
   hear_user(type_of_monopolist(M)),
   make_script(M).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%    user interface
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% ----  inputs from user 

hear_user(type_of_monopolist(M)):-
   nl,
   write('Please specify the type of monopolist either weak or strong:'),
   read(M1),
   (\+ player(_,monopolist(M1))
     ->
      (
       nl,
       write(' no such type of monopolist. please re-try.'),
       hear_user(type_of_monopolist(M))
      )
     ; M = M1
   ).

hear_user(reason_of_play):-
   nl,
   write('Display the reasoning for the plays above? (all/spec/no):'),
   read(Y1),
   (member(Y1,[n,'N',no,'No','NO',q,quit,e,end])
        ->fail; true
   ),
   hear_user(reason_of_play(Y1)),!,
   nl,
   write('-----------end of explanation----------'),
   hear_user(reason_of_play).

hear_user(reason_of_play(Y1)):-
   (member(Y1,[y,'Y',yes,'Yes','YES'])
     ->
      (
       write('please re-enter as either all, stage, or no.'),
       hear_user(reason_of_play)
      )
     ;
      explain_reason_of_play(Y1)
   ).

hear_user((stage(S),player(J))):-
   hear_user(stage(S)),
   hear_user(player(J)).

hear_user(stage(Stage)):-
   nl,
   write('Type the number of the stage: '),
   read(S),
   (stage(S)->Stage=S;hear_user(stage(Stage))).

hear_user(player(Player)):-
   nl,
   write('Type the player: '),
   read(J),
   (
    (
     (player(J,N),Player=N);
     (player(_,J),Player=J)
    )
     ;hear_user(player(Player))
   ).


% ----  explanations for user 

explain_reason_of_play(All):-
   \+ var(All),
   All =all,
   forall(
     history_of_play(T,J,S),
     explain_reason_of_play(T,J,S,_)
   ).

explain_reason_of_play(Spec):-
   (
    (var(Spec);member(Spec,[spec,s]))
     ->
       hear_user((stage(S),player(J)))
     ;
      fail 
   ),
   explain_reason_of_play(S,J,_,_).

explain_reason_of_play(T,J,S,C):-
   history_of_play(T,J,S),
   reason_of_play(T,J,C),
   nl,
   write((J,at_stage:T,played:S)),
   nl,
   tab(1),
   write('because:'),
   forall(member(R,C),(nl,tab(2),write(R))).




%------------------------------------------------
%  mathematical utiliteis
%------------------------------------------------
max_of(X,[X]).
max_of(Z,[X|Y]):-
   max_of(Z1,Y),
   (X > Z1 -> Z=X; Z=Z1).
min_of(X,[X]).
min_of(Z,[X|Y]):-
   min_of(Z1,Y),
   (X < Z1 -> Z=X; Z=Z1).
dnum_seq([],N):-N<0,!.
dnum_seq([0],1).
dnum_seq([A|Q],N):-
   A is N - 1,
   length(Q,A),
   dnum_seq(Q,A).
anum_seq(Aseq,N):-dnum_seq(Dseq,N),sort(Dseq,Aseq).

dnum_seq1(Q,N):-
   M is N + 1,
   dnum_seq(Q0,M),
   subtract(Q0,[0],Q).
anum_seq1(Q,N):-
   M is N + 1,
   anum_seq(Q0,M),
   subtract(Q0,[0],Q).