Appendix F Full trace of simulated conversation

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)