Appendix F

Full trace of simulated conversation

 

 

 

Initial State:

 

barney: state(believe(barney,next_subsequence(subsequence(1,[o])),true),0,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(believe(barney,turn(adam),true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,give_turn(adam),true),0,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,

blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,

blank,blank,blank,g,o])),goal_true),0,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 1:

 

op(     % goal_request_next_subsequence

  if([ conversants(adam,barney),

     act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,

blank,g,o])),goal_true),

     believe(adam,next_subsequence(subsequence(1,[blank])),true) ]),

  not([ act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),goal_true),

     act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true) ]),

  test([]),

  action([]),

  effects([ add(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),

goal_true),barney),goal_true)) ]),

  atts([ level(domain),

     name(goal_request_next_subsequence) ]) ).

 

op(     % acknowledge_my_turn

  if([ conversants(adam,barney),

     believe(adam,turn(barney),mutually_known_true),

     act(barney,give_turn(adam),true) ]),

  not([]),

  test([]),

  action([ act(adam,acknowledge_turn(turn(adam),mutually_known_true),true) ]),

  effects([ del(act(barney,give_turn(adam),true)),

     del(believe(adam,turn(barney),mutually_known_true)),

     add(believe(adam,turn(adam),mutually_known_true)) ]),

  atts([ level(turn),

     name(acknowledge_my_turn) ]) ).

 

 

barney's acts for cycle 1:

 

op(     % goal_confirm_next_subsequence

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,

g,o])),goal_true),

     believe(barney,next_subsequence(subsequence(1,[o])),true) ]),

  not([ act(barney,confirm_mutual(subsequence(1,[o])),goal_true),

     act(barney,assert(believe(barney,subsequence(1,_4140),true),adam),goal_true),

     act(barney,assert(believe(barney,subsequence(1,_4156),true),adam),true) ]),

  test([ not(o = blank) ]),

  action([]),

  effects([ add(act(barney,confirm_mutual(subsequence(1,[o])),goal_true)),

     add(believe(barney,next_letter(letter(1,o)),true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_subsequence) ]) ).

 

 

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(act(barney,confirm_mutual(subsequence(1,[o])),goal_true),1,-1)

barney: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

barney: state(believe(barney,next_subsequence(subsequence(1,[o])),true),0,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(believe(barney,turn(adam),true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(adam),mutually_known_true),1,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),goal_true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 2:

 

op(     % do_request

  if([ conversants(adam,barney),

     act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),goal_true),

     believe(adam,turn(adam),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true) ]),

  effects([ del(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),

goal_true),barney),goal_true)),

     del(believe(adam,turn(adam),mutually_known_true)),

     add(believe(adam,turn(barney),mutually_known_true)) ]),

  atts([ name(do_request),

     level(information) ]) ).

 

op(     % give_turn_3

  if([ conversants(adam,barney),

     act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),goal_true),

     believe(adam,turn(adam),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(adam,give_turn(barney),mutually_known_true) ]),

  effects([ del(believe(adam,turn(adam),mutually_known_true)),

     del(act(adam,give_turn(barney),mutually_known_true)),

     add(believe(adam,turn(barney),true)) ]),

  atts([ name(give_turn_3),

     level(turn) ]) ).

 

 

barney's acts for cycle 2:

 

op(     % goal_confirm_next_letter_1

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(subsequence(1,[o])),goal_true),

     believe(barney,next_letter(letter(1,o)),true) ]),

  not([ act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true) ]),

  test([]),

  action([]),

  effects([ add(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true)),

     add(act(barney,assert(next_letter(letter(1,o)),adam),goal_true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_letter_1) ]) ).

 

op(     % others_turn_acknowledged

  if([ conversants(barney,adam),

     believe(barney,turn(adam),true),

     act(adam,acknowledge_turn(turn(adam),mutually_known_true),true) ]),

  not([]),

  test([]),

  action([]),

  effects([ del(believe(barney,turn(adam),true)),

     add(believe(barney,turn(adam),mutually_known_true)),

     del(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true)) ]),

  atts([ level(turn),

     name(others_turn_acknowledged) ]) ).

 

 

barney: state(believe(barney,turn(adam),mutually_known_true),2,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),goal_true),2,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),2,-1)

barney: state(act(adam,give_turn(barney),mutually_known_true),2,-1)

barney: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(act(barney,confirm_mutual(subsequence(1,[o])),goal_true),1,-1)

barney: state(believe(barney,next_subsequence(subsequence(1,[o])),true),0,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 3:

 

 

barney's acts for cycle 3:

 

op(     % goal_assert_next_subsequence_2

  if([ conversants(barney,adam),

     believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),

     act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),

     act(barney,confirm_mutual(subsequence(1,[o])),goal_true),

     act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),

     act(barney,assert(next_letter(letter(1,o)),adam),goal_true),

     believe(barney,next_subsequence(subsequence(1,[o])),true) ]),

  not([ act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),goal_true) ]),

  test([ get_subsequence(1,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

subsequence(1,[o])) ]),

  action([]),

  effects([ del(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),

goal_true),barney),true)),

     del(act(barney,confirm_mutual(subsequence(1,[o])),goal_true)),

     del(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true)),

     del(act(barney,assert(next_letter(letter(1,o)),adam),goal_true)),

     add(act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),goal_true)),

     del(believe(barney,next_subsequence(subsequence(1,[o])),true)),

     add(believe(barney,next_subsequence(subsequence(1,[o])),true)) ]),

  atts([ level(domain),

     name(goal_assert_next_subsequence_2) ]) ).

 

op(     % recognize_my_turn_1

  if([ conversants(barney,adam),

     act(adam,give_turn(barney),mutually_known_true),

     believe(barney,turn(adam),mutually_known_true) ]),

  not([ act(barney,request - turn,true) ]),

  test([]),

  action([]),

  effects([ del(believe(barney,turn(adam),mutually_known_true)),

     del(act(adam,give_turn(barney),mutually_known_true)),

     add(believe(barney,turn(barney),mutually_known_true)) ]),

  atts([ name(recognize_my_turn_1),

     level(turn) ]) ).

 

 

barney: state(believe(barney,turn(barney),mutually_known_true),3,-1)

barney: state(believe(barney,next_subsequence(subsequence(1,[o])),true),3,-1)

barney: state(act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),

goal_true),3,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 4:

 

 

barney's acts for cycle 4:

 

op(     % do_assert

  if([ conversants(barney,adam),

     act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),goal_true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),true) ]),

  effects([ del(act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),

goal_true)) ]),

  atts([ name(do_assert),

     level(information) ]) ).

 

 

barney: state(act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),true),4,-1)

barney: state(believe(barney,turn(barney),mutually_known_true),3,-1)

barney: state(believe(barney,next_subsequence(subsequence(1,[o])),true),3,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 5:

 

 

barney's acts for cycle 5:

 

op(     % asserted_next_subsequence

  if([ conversants(barney,adam),

     believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),

     believe(barney,next_subsequence(subsequence(1,[o])),true),

     act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),true) ]),

  not([]),

  test([ length([o],1),

     length([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o],17),

     1 + 1 =< 17,

     get_next_subsequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o],

subsequence(1,[o]),subsequence(2,[blank])) ]),

  action([]),

  effects([ del(believe(barney,next_subsequence(subsequence(1,[o])),true)),

     del(act(barney,assert(believe(barney,subsequence(1,[o]),true),adam),true)),

     add(believe(barney,next_subsequence(subsequence(2,[blank])),true)) ]),

  atts([ level(domain),

     name(asserted_next_subsequence) ]) ).

 

 

barney: state(believe(barney,next_subsequence(subsequence(2,[blank])),true),5,-1)

barney: state(believe(barney,turn(barney),mutually_known_true),3,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 6:

 

 

barney's acts for cycle 6:

 

op(     % goal_request_next_subsequence

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,

g,o])),goal_true),

     believe(barney,next_subsequence(subsequence(2,[blank])),true) ]),

  not([ act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true),

     act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true) ]),

  test([]),

  action([]),

  effects([ add(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true)) ]),

  atts([ level(domain),

     name(goal_request_next_subsequence) ]) ).

 

 

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true),6,-1)

barney: state(believe(barney,next_subsequence(subsequence(2,[blank])),true),5,-1)

barney: state(believe(barney,turn(barney),mutually_known_true),3,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 7:

 

 

barney's acts for cycle 7:

 

op(     % do_request

  if([ conversants(barney,adam),

     act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true) ]),

  effects([ del(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true)),

     del(believe(barney,turn(barney),mutually_known_true)),

     add(believe(barney,turn(adam),mutually_known_true)) ]),

  atts([ name(do_request),

     level(information) ]) ).

 

op(     % give_turn_3

  if([ conversants(barney,adam),

     act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),goal_true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(barney,give_turn(adam),mutually_known_true) ]),

  effects([ del(believe(barney,turn(barney),mutually_known_true)),

     del(act(barney,give_turn(adam),mutually_known_true)),

     add(believe(barney,turn(adam),true)) ]),

  atts([ name(give_turn_3),

     level(turn) ]) ).

 

 

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_subsequence(subsequence(2,[blank])),true),5,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,give_turn(adam),mutually_known_true),7,-1)

adam: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),goal_true),

adam),true),7,-1)

adam: state(believe(adam,turn(barney),true),2,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,next_subsequence(subsequence(1,[blank])),true),0,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 8:

 

op(     % goal_assert_next_subsequence_1

  if([ conversants(adam,barney),

     believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,blank,g,o]),

goal_mutually_known_true),

     act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),

     believe(adam,next_subsequence(subsequence(1,[blank])),true) ]),

  not([ act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),goal_true),

     act(adam,confirm_mutual(subsequence(2,_506)),goal_true) ]),

  test([ get_subsequence(2,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,

blank,g,o]),subsequence(2,[i,s,u,t,w])) ]),

  action([]),

  effects([ del(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true)),

     add(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),

barney),goal_true)),

     del(believe(adam,next_subsequence(subsequence(1,[blank])),true)),

     add(believe(adam,next_subsequence(subsequence(2,[i,s,u,t,w])),true)) ]),

  atts([ level(domain),

     name(goal_assert_next_subsequence_1) ]) ).

 

op(     % recognize_my_turn_1

  if([ conversants(adam,barney),

     act(barney,give_turn(adam),mutually_known_true),

     believe(adam,turn(barney),true) ]),

  not([ act(adam,request - turn,true) ]),

  test([]),

  action([]),

  effects([ del(believe(adam,turn(barney),true)),

     del(act(barney,give_turn(adam),mutually_known_true)),

     add(believe(adam,turn(adam),mutually_known_true)) ]),

  atts([ name(recognize_my_turn_1),

     level(turn) ]) ).

 

 

barney's acts for cycle 8:

 

 

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_subsequence(subsequence(2,[blank])),true),5,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,next_subsequence(subsequence(2,[i,s,u,t,w])),true),8,-1)

adam: state(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),

goal_true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 9:

 

op(     % do_assert

  if([ conversants(adam,barney),

     act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),goal_true),

     believe(adam,turn(adam),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true) ]),

  effects([ del(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),

goal_true)) ]),

  atts([ name(do_assert),

     level(information) ]) ).

 

op(     % request_turn

  if([ conversants(adam,barney),

     act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),goal_true),

     believe(adam,turn(barney),mutually_known_true) ]),

  not([ act(adam,request_turn,true) ]),

  test([ assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney) = assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney) ; assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney) =

request(_320,barney) ]),

  action([ act(adam,request_turn,true) ]),

  effects([]),

  atts([ name(request_turn),

     level(turn) ]) ).

 

 

barney's acts for cycle 9:

 

 

barney: state(act(adam,request_turn,true),9,-1)

barney: state(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),

true),9,-1)

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_subsequence(subsequence(2,[blank])),true),5,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(adam,request_turn,true),9,-1)

adam: state(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),

true),9,-1)

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,next_subsequence(subsequence(2,[i,s,u,t,w])),true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 10:

 

op(     % asserted_next_subsequence

  if([ conversants(adam,barney),

     believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,blank,g,o]),

goal_mutually_known_true),

     believe(adam,next_subsequence(subsequence(2,[i,s,u,t,w])),true),

     act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true) ]),

  not([]),

  test([ length([i,s,u,t,w],5),

     length([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,blank,g,o],17),

     2 + 5 =< 17,

     get_next_subsequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,blank,g,o],

subsequence(2,[i,s,u,t,w]),subsequence(7,[r,q,g,l,d])) ]),

  action([]),

  effects([ del(believe(adam,next_subsequence(subsequence(2,[i,s,u,t,w])),true)),

     del(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true)),

     add(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true)) ]),

  atts([ level(domain),

     name(asserted_next_subsequence) ]) ).

 

 

barney's acts for cycle 10:

 

op(     % informed_of_next_subsequence_by_other

  if([ conversants(barney,adam),

     believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),

     believe(barney,next_subsequence(subsequence(2,[blank])),true),

     act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true) ]),

  not([]),

  test([ length([blank],1),

     length([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o],17),

     2 + 1 =< 17,

     get_next_subsequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o],

subsequence(2,[blank]),subsequence(3,[s,u,t,w,r])) ]),

  action([]),

  effects([ del(believe(barney,next_subsequence(subsequence(2,[blank])),true)),

     del(act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true)),

     add(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true)) ]),

  atts([ level(domain),

     name(informed_of_next_subsequence_by_other) ]) ).

 

op(     % assertion_received_1

  if([ conversants(barney,adam),

     act(adam,assert(believe(adam,subsequence(2,[i,s,u,t,w]),true),barney),true),

     believe(barney,turn(adam),mutually_known_true) ]),

  not([ believe(adam,subsequence(2,[i,s,u,t,w]),true) ]),

  test([]),

  action([]),

  effects([ add(believe(adam,subsequence(2,[i,s,u,t,w]),true)) ]),

  atts([ name(assertion_received_1),

     level(information) ]) ).

 

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 11:

 

op(     % goal_confirm_next_subsequence

  if([ conversants(adam,barney),

     act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,blank,

blank,g,o])),goal_true),

     believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true) ]),

  not([ act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),

     act(adam,assert(believe(adam,subsequence(7,_307),true),barney),goal_true),

     act(adam,assert(believe(adam,subsequence(7,_323),true),barney),true) ]),

  test([ not(r = blank) ]),

  action([]),

  effects([ add(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true)),

     add(believe(adam,next_letter(letter(1,r)),true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_subsequence) ]) ).

 

 

barney's acts for cycle 11:

 

op(     % goal_confirm_next_subsequence

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,

g,o])),goal_true),

     believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true) ]),

  not([ act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),

     act(barney,assert(believe(barney,subsequence(3,_2558),true),adam),goal_true),

     act(barney,assert(believe(barney,subsequence(3,_2574),true),adam),true) ]),

  test([ not(s = blank) ]),

  action([]),

  effects([ add(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true)),

     add(believe(barney,next_letter(letter(1,s)),true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_subsequence) ]) ).

 

 

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 12:

 

op(     % goal_confirm_next_letter_1

  if([ conversants(adam,barney),

     act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),

     believe(adam,next_letter(letter(1,r)),true) ]),

  not([ act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true) ]),

  test([]),

  action([]),

  effects([ add(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true)),

     add(act(adam,assert(next_letter(letter(1,r)),barney),goal_true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_letter_1) ]) ).

 

 

barney's acts for cycle 12:

 

op(     % goal_confirm_next_letter_1

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),

     believe(barney,next_letter(letter(1,s)),true) ]),

  not([ act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true) ]),

  test([]),

  action([]),

  effects([ add(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true)),

     add(act(barney,assert(next_letter(letter(1,s)),adam),goal_true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_letter_1) ]) ).

 

 

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),goal_true),12,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),goal_true),12,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 13:

 

op(     % do_assert

  if([ conversants(adam,barney),

     act(adam,assert(next_letter(letter(1,r)),barney),goal_true),

     believe(adam,turn(adam),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(adam,assert(next_letter(letter(1,r)),barney),true) ]),

  effects([ del(act(adam,assert(next_letter(letter(1,r)),barney),goal_true)) ]),

  atts([ name(do_assert),

     level(information) ]) ).

 

 

barney's acts for cycle 13:

 

op(     % goal_confirm_next_letter_1

  if([ conversants(barney,adam),

     act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),

     believe(barney,next_letter(letter(1,o)),true) ]),

  not([ act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true) ]),

  test([]),

  action([]),

  effects([ add(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true)),

     add(act(barney,assert(next_letter(letter(1,o)),adam),goal_true)) ]),

  atts([ level(domain),

     name(goal_confirm_next_letter_1) ]) ).

 

op(     % request_turn

  if([ conversants(barney,adam),

     act(barney,assert(next_letter(letter(1,s)),adam),goal_true),

     believe(barney,turn(adam),mutually_known_true) ]),

  not([ act(barney,request_turn,true) ]),

  test([ assert(next_letter(letter(1,s)),adam) = assert(next_letter(letter(1,s)),adam) ; assert(next_letter(letter(1,s)),adam) = request(_2442,adam) ]),

  action([ act(barney,request_turn,true) ]),

  effects([]),

  atts([ name(request_turn),

     level(turn) ]) ).

 

 

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),goal_true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),goal_true),12,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(believe(barney,turn(adam),true),7,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,request_turn,true),13,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(adam),mutually_known_true),8,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

adam's acts for cycle 14:

 

op(     % give_turn_2

  if([ conversants(adam,barney),

     act(barney,request_turn,true),

     believe(adam,turn(adam),mutually_known_true) ]),

  not([ act(adam,assert(next_letter(letter(1,r)),barney),goal_true) ]),

  test([]),

  action([ act(adam,give_turn(barney),true) ]),

  effects([ del(believe(adam,turn(adam),mutually_known_true)),

     del(act(adam,give_turn(barney),true)),

     del(act(barney,request_turn,true)),

     add(believe(adam,turn(barney),mutually_known_true)) ]),

  atts([ name(give_turn_2),

     level(turn) ]) ).

 

 

barney's acts for cycle 14:

 

op(     % regain_turn

  if([ conversants(barney,adam),

     act(barney,assert(next_letter(letter(1,o)),adam),goal_true),

     believe(barney,turn(adam),true) ]),

  not([ act(barney,hold_turn,mutually_known_true) ]),

  test([ assert(next_letter(letter(1,o)),adam) =

  assert(next_letter(letter(1,o)),adam);

  assert(next_letter(letter(1,o)),adam)

  = request(_2839,adam) ]),

  action([ act(barney,hold_turn,mutually_known_true) ]),

  effects([ del(believe(barney,turn(adam),true)),

     add(believe(barney,turn(barney),true)) ]),

  atts([ name(regain_turn),

     level(turn) ]) ).

 

 

barney: state(believe(barney,turn(barney),true),14,-1)

barney: state(act(barney,hold_turn,mutually_known_true),14,-1)

barney: state(act(adam,give_turn(barney),true),14,-1)

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),goal_true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),goal_true),12,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),7,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,hold_turn,mutually_known_true),14,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),14,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 15:

 

 

barney's acts for cycle 15:

 

op(     % acknowledge_my_turn

  if([ conversants(barney,adam),

     believe(barney,turn(adam),mutually_known_true),

     act(adam,give_turn(barney),true) ]),

  not([]),

  test([]),

  action([ act(barney,acknowledge_turn(turn(barney),mutually_known_true),true) ]),

  effects([ del(act(adam,give_turn(barney),true)),

     del(believe(barney,turn(adam),mutually_known_true)),

     add(believe(barney,turn(barney),mutually_known_true)) ]),

  atts([ level(turn),

     name(acknowledge_my_turn) ]) ).

 

 

barney: state(believe(barney,turn(barney),mutually_known_true),15,-1)

barney: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),true),15,-1)

barney: state(believe(barney,turn(barney),true),14,-1)

barney: state(act(barney,hold_turn,mutually_known_true),14,-1)

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),goal_true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),goal_true),12,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),true),15,-1)

adam: state(act(barney,hold_turn,mutually_known_true),14,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),14,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 16:

 

 

barney's acts for cycle 16:

 

op(     % do_assert

  if([ conversants(barney,adam),

     act(barney,assert(next_letter(letter(1,o)),adam),goal_true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(barney,assert(next_letter(letter(1,o)),adam),true) ]),

  effects([ del(act(barney,assert(next_letter(letter(1,o)),adam),goal_true)) ]),

  atts([ name(do_assert),

     level(information) ]) ).

 

 

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

barney: state(believe(barney,turn(barney),mutually_known_true),15,-1)

barney: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),

true),15,-1)

barney: state(believe(barney,turn(barney),true),14,-1)

barney: state(act(barney,hold_turn,mutually_known_true),14,-1)

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),goal_true),12,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(adam,request_turn,true),9,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

adam: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),true),15,-1)

adam: state(act(barney,hold_turn,mutually_known_true),14,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),14,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 17:

 

 

barney's acts for cycle 17:

 

op(     % do_assert

  if([ conversants(barney,adam),

     act(barney,assert(next_letter(letter(1,s)),adam),goal_true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([]),

  test([]),

  action([ act(barney,assert(next_letter(letter(1,s)),adam),true) ]),

  effects([ del(act(barney,assert(next_letter(letter(1,s)),adam),goal_true)) ]),

  atts([ name(do_assert),

     level(information) ]) ).

 

op(     % give_turn_2

  if([ conversants(barney,adam),

     act(adam,request_turn,true),

     believe(barney,turn(barney),mutually_known_true) ]),

  not([ act(barney,assert(next_letter(letter(1,o)),adam),goal_true) ]),

  test([]),

  action([ act(barney,give_turn(adam),true) ]),

  effects([ del(believe(barney,turn(barney),mutually_known_true)),

     del(act(barney,give_turn(adam),true)),

     del(act(adam,request_turn,true)),

     add(believe(barney,turn(adam),mutually_known_true)) ]),

  atts([ name(give_turn_2),

     level(turn) ]) ).

 

 

barney: state(believe(barney,turn(adam),mutually_known_true),17,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),true),17,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

barney: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),

true),15,-1)

barney: state(believe(barney,turn(barney),true),14,-1)

barney: state(act(barney,hold_turn,mutually_known_true),14,-1)

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(act(barney,give_turn(adam),true),17,-1)

adam: state(act(barney,assert(next_letter(letter(1,s)),adam),true),17,-1)

adam: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

adam: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),true),15,-1)

adam: state(act(barney,hold_turn,mutually_known_true),14,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),14,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 18:

 

op(     % acknowledge_my_turn

  if([ conversants(adam,barney),

     believe(adam,turn(barney),mutually_known_true),

     act(barney,give_turn(adam),true) ]),

  not([]),

  test([]),

  action([ act(adam,acknowledge_turn(turn(adam),mutually_known_true),true) ]),

  effects([ del(act(barney,give_turn(adam),true)),

     del(believe(adam,turn(barney),mutually_known_true)),

     add(believe(adam,turn(adam),mutually_known_true)) ]),

  atts([ level(turn),

     name(acknowledge_my_turn) ]) ).

 

 

barney's acts for cycle 18:

 

 

barney: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),18,-1)

barney: state(believe(barney,turn(adam),mutually_known_true),17,-1)

barney: state(act(barney,assert(next_letter(letter(1,s)),adam),true),17,-1)

barney: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

barney: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),

true),15,-1)

barney: state(believe(barney,turn(barney),true),14,-1)

barney: state(act(barney,hold_turn,mutually_known_true),14,-1)

barney: state(act(barney,request_turn,true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,o))),goal_true),13,-1)

barney: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

barney: state(act(barney,confirm_mutual(next_letter(letter(1,s))),goal_true),12,-1)

barney: state(believe(barney,next_letter(letter(1,s)),true),11,-1)

barney: state(act(barney,confirm_mutual(subsequence(3,[s,u,t,w,r])),goal_true),11,-1)

barney: state(believe(adam,subsequence(2,[i,s,u,t,w]),true),10,-1)

barney: state(believe(barney,next_subsequence(subsequence(3,[s,u,t,w,r])),true),10,-1)

barney: state(act(barney,request(act(adam,assert(subsequence(2,[blank]),barney),

goal_true),adam),true),7,-1)

barney: state(believe(barney,next_letter(letter(1,o)),true),1,-1)

barney: state(believe(barney,sequence([o,blank,s,u,t,w,r,q,g,blank,blank,f,w,w,d,g,o]),

goal_mutually_known_true),0,-1)

barney: state(act(barney,confirm_mutual(sequence([o,blank,s,u,t,w,r,q,g,blank,

blank,f,w,w,d,g,o])),goal_true),0,-1)

barney: state(conversants(barney,adam),0,-1)

 

 

adam: state(believe(adam,turn(adam),mutually_known_true),18,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),18,-1)

adam: state(act(barney,assert(next_letter(letter(1,s)),adam),true),17,-1)

adam: state(act(barney,assert(next_letter(letter(1,o)),adam),true),16,-1)

adam: state(act(barney,acknowledge_turn(turn(barney),mutually_known_true),true),15,-1)

adam: state(act(barney,hold_turn,mutually_known_true),14,-1)

adam: state(act(adam,assert(next_letter(letter(1,r)),barney),true),13,-1)

adam: state(act(adam,confirm_mutual(next_letter(letter(1,r))),goal_true),12,-1)

adam: state(believe(adam,next_letter(letter(1,r)),true),11,-1)

adam: state(act(adam,confirm_mutual(subsequence(7,[r,q,g,l,d])),goal_true),11,-1)

adam: state(believe(adam,next_subsequence(subsequence(7,[r,q,g,l,d])),true),10,-1)

adam: state(act(adam,request_turn,true),9,-1)

adam: state(believe(adam,turn(barney),mutually_known_true),2,-1)

adam: state(act(adam,request(act(barney,assert(subsequence(1,[blank]),adam),goal_true),

barney),true),2,-1)

adam: state(act(adam,acknowledge_turn(turn(adam),mutually_known_true),true),1,-1)

adam: state(believe(adam,sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o]),goal_mutually_known_true),0,-1)

adam: state(act(adam,confirm_mutual(sequence([blank,i,s,u,t,w,r,q,g,l,d,blank,blank,

blank,blank,g,o])),goal_true),0,-1)

adam: state(conversants(adam,barney),0,-1)

 

 

adam's acts for cycle 19:

 

 

barney's acts for cycle 19: