def kb_consistent_trumpmarriage(self, state, move): # type: (State, move) -> bool # each time we check for consistency we initialise a new knowledge-base kb = KB() # Add general information about the game suit = State.get_trump_suit(state) if suit == "C": card1 = 2 card2 = 3 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "D": card1 = 7 card2 = 8 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "H": card1 = 12 card2 = 13 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) elif suit == "S": card1 = 17 card2 = 18 variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(strategy_variable) load.general_information(kb) # Add the necessary knowledge about the strategy load.strategy_knowledge(kb) # This line stores the index of the card in the deck. # If this doesn't make sense, refer to _deck.py for the card index mapping index = move[0] variable_string = "pm" + str(index) strategy_variable = Boolean(variable_string) # Add the relevant clause to the loaded knowledge base kb.add_clause(~strategy_variable) # If the knowledge base is not satisfiable, the strategy variable is # entailed (proof by refutation) return kb.satisfiable()
def kb_trump(self, state, move): # type: (State,move) -> bool kb = KB() load.general_information(kb) load.strategy_knowledge(kb) p_card = move[0] p_card_suit = "" if p_card < 5: p_card_suit = "C" elif p_card < 10: p_card_suit = "D" elif p_card < 15: p_card_suit = "H" elif p_card < 20: p_card_suit = "S" # p_card_suit = Deck.get_suit(p_card) trump_suit = state.get_trump_suit() variable_string = "wtt" + str(p_card_suit) + str(trump_suit) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_acecard(self, state, move): # type: (State, move) -> bool # each time we check for consistency we initialise a new knowledge-base kb = KB() # Add general information about the game load.general_information(kb) # Add the necessary knowledge about the strategy load.strategy_knowledge(kb) # This line stores the index of the card in the deck. # If this doesn't make sense, refer to _deck.py for the card index mapping index = move[0] # This creates the string which is used to make the strategy_variable. # Note that as far as kb.py is concerned, two objects created with the same # string in the constructor are equivalent, and are seen as the same symbol. # Here we use "pj" to indicate that the card with index "index" should be played with the # PlayJack heuristics that was defined in class. Initialise a different variable if # you want to apply a different strategy (that you will have to define in load.py) variable_string = "pa" + str(index) strategy_variable = Boolean(variable_string) # Add the relevant clause to the loaded knowledge base kb.add_clause(~strategy_variable) # If the knowledge base is not satisfiable, the strategy variable is # entailed (proof by refutation) return kb.satisfiable()
def prepareKB(self, state): readyKB = KB() for card in state.get_perspective(self): index = -1 if card == "P1H" or card == "P2H" or card == "P1W" or card == "P2W": index = state.get_perspective(self).index(card) if index != -1: tempString = self.__RANKS[index % 5] tempString += str(index % 5) readyKB.add_clause(Boolean(tempString)) return readyKB
def kb_consistent_marriage(self, state, move): # type: (State, move) -> bool kb = KB() load.general_information(kb) load.strategy_knowledge(kb) card1 = move[0] card2 = move[1] variable_string = "m" + str(card1) + str(card2) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_consistent_low_non_trump(self, state, move): # type: (State, move) -> bool kb = KB() load.general_information(kb) load.strategy_knowledge(kb) card = move[0] trump_suit = state.get_trump_suit() variable_string = "pc" + str(card) + str(trump_suit) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_consistent(self, state, move): # type: (State, move) -> bool index = move[0] if (Deck.get_suit(index) == state.get_trump_suit()): return True kb = self.prepareKB(state) load.strategy_knowledge(kb) variable_string = "pc" + str(index) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_consistent(self, state, move): # type: (State, move) -> bool index = move[0] # If a card is chosen by the KB, it will be played, doesn't matter if it is a trump # This will be an extremely rare case, possibility of this happening is very low if (Deck.get_rank(index) == "A"): return False kb = self.prepareKB(state) load.strategy_knowledge(kb) variable_string = "pc" + str(index) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_consistent_matching_win(self, state, move): # type: (State,move) -> bool kb = KB() load_justabout.general_information(kb) load_justabout.strategy_knowledge(kb) opp_card = state.get_opponents_played_card() opp_card_suit = Deck.get_suit(opp_card) opp_card_rank = opp_card % 5 p_card = move[0] p_card_suit = Deck.get_suit(p_card) p_card_rank = opp_card % 5 variable_string = "wt" + str(p_card_rank) + str(opp_card_rank) + str(p_card_suit) + str(opp_card_suit) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
def kb_consistent_trump_win(self,state,move): # type: (State,move) -> bool kb = KB() load_justabout.general_information(kb) load_justabout.strategy_knowledge(kb) opp_card = state.get_opponents_played_card() opp_card_suit = Deck.get_suit(opp_card) opp_card_rank = opp_card & 5 p_card = move[0] p_card_suit = Deck.get_suit(p_card) p_card_rank = p_card % 5 trump_suit = state.get_trump_suit() constraint_a = Integer('me') > Integer('op') constraint_b = Integer('op') > Integer('me') if opp_card_suit == trump_suit: if p_card_suit == trump_suit: if opp_card_rank < p_card_rank: strategy_variable = constraint_b else: strategy_variable = constraint_a else: strategy_variable = constraint_b else: variable_string = "wtt" + str(p_card_suit) + str(trump_suit) strategy_variable = Boolean(variable_string) kb.add_clause(~strategy_variable) return kb.satisfiable()
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # First all possible cards: # First all possible cards: J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3')
import sys from kb import KB, Boolean, Integer, Constant # Define our propositional symbols # a1 is true if the card with index 1 is an ace, etc # You need to initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play ace strategy. a0 = Boolean('a0') a1 = Boolean('a1') a2 = Boolean('a2') a3 = Boolean('a3') a4 = Boolean('a4') a5 = Boolean('a5') a6 = Boolean('a6') a7 = Boolean('a7') a8 = Boolean('a8') a9 = Boolean('a9') a10 = Boolean('a10') a11 = Boolean('a11') a12 = Boolean('a12') a13 = Boolean('a13') a14 = Boolean('a14') a15 = Boolean('a15') a16 = Boolean('a16') a17 = Boolean('a17') a18 = Boolean('a18') a19 = Boolean('a19') Pa0 = Boolean('pa0') Pa1 = Boolean('pa1') Pa2 = Boolean('pa2') Pa3 = Boolean('pa3')
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3') Q4 = Boolean('q4') Q5 = Boolean('q5')
def kb_consistent(self, state, move): # type: (State, move) -> bool # each time we check for consistency we initialise a new knowledge-base kb = KB() # Add general information about the game load.general_information(kb) # Add the necessary knowledge about the strategy load.strategy_knowledge(kb) # This line stores the index of the card in the deck. # If this doesn't make sense, refer to _deck.py for the card index mapping index = move[0] # This creates the string which is used to make the strategy_variable. # Note that as far as kb.py is concerned, two objects created with the same # string in the constructor are equivalent, and are seen as the same symbol. # Here we use "pj" to indicate that the card with index "index" should be played with the # PlayJack heuristics that was defined in class. Initialise a different variable if # you want to apply a different strategy (that you will have to define in load.py) # # Always play trump trump_suit = state.get_trump_suit() trump = trump_suit.lower() if trump == 'c': pj = Boolean('pj4') pq = Boolean('pq3') pk = Boolean('pk2') pt = Boolean('pt1') pa = Boolean('pa0') if trump == 'd': pj = Boolean('pj9') pq = Boolean('pq8') pk = Boolean('pk7') pt = Boolean('pt6') pa = Boolean('pa5') if trump == 'h': pj = Boolean('pj14') pq = Boolean('pq13') pk = Boolean('pk12') pt = Boolean('pt11') pa = Boolean('pa10') if trump == 's': pj = Boolean('pj19') pq = Boolean('pq18') pk = Boolean('pk17') pt = Boolean('pt16') pa = Boolean('pa15') kb.add_clause(~pj, ~pq, ~pk, ~pt, ~pa) # # always play Jack # variable_string = "pj" + str(index) # strategy_variable = Boolean(variable_string) # Add the relevant clause to the loaded knowledge base # kb.add_clause(~strategy_variable) # If the knowledge base is not satisfiable, the strategy variable is # entailed (proof by refutation) return kb.satisfiable()
import sys from kb import KB, Boolean, Integer, Constant # Define our propositional symbols # A1 is true if the card with index 1 is a Aack, etc # You need to initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Aack strategy. A0 = Boolean('a0') A1 = Boolean('a1') A2 = Boolean('a2') A3 = Boolean('a3') A4 = Boolean('a4') A5 = Boolean('a5') A6 = Boolean('a6') A7 = Boolean('a7') A8 = Boolean('a8') A9 = Boolean('a9') A10 = Boolean('a10') A11 = Boolean('a11') A12 = Boolean('a12') A13 = Boolean('a13') A14 = Boolean('a14') A15 = Boolean('a15') A16 = Boolean('a16') A17 = Boolean('a17') A18 = Boolean('a18') A19 = Boolean('a19') PA0 = Boolean('pa0') PA1 = Boolean('pa1') PA2 = Boolean('pa2') PA3 = Boolean('pa3')
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # First all possible cards: J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3') Q4 = Boolean('q4') Q5 = Boolean('q5')
import kb, sys from kb import KB, Boolean, Integer, Constant # Define our propositional symbols # J1 is true if the card with index 1 is a jack, etc # You need to initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') PJ0 = Boolean('pj0') PJ1 = Boolean('pj1') PJ2 = Boolean('pj2') PJ3 = Boolean('pj3')
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols A = Boolean('A') B = Boolean('B') C = Boolean('C') # Create a new knowledge base kb = KB() # Add clauses kb.add_clause(A, B, C) kb.add_clause(~A, B) kb.add_clause(~B, C) kb.add_clause(B, ~C) # Our clause kb.add_clause(~B,~C) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3') Q4 = Boolean('q4') Q5 = Boolean('q5')
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # First all possible cards: J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3') Q4 = Boolean('q4') Q5 = Boolean('q5')
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. C0 = Boolean('c0') C1 = Boolean('c1') C2 = Boolean('c2') C3 = Boolean('c3') C4 = Boolean('c4') C5 = Boolean('c5') C6 = Boolean('c6') C7 = Boolean('c7') C8 = Boolean('c8') C9 = Boolean('c9') C10 = Boolean('c10') C11 = Boolean('c11') C12 = Boolean('c12') C13 = Boolean('c13') C14 = Boolean('c14') C15 = Boolean('c15') C16 = Boolean('c16') C17 = Boolean('c17') C18 = Boolean('c18') C19 = Boolean('c19') PC0 = Boolean('pc0') PC1 = Boolean('pc1') PC2 = Boolean('pc2') PC3 = Boolean('pc3') PC4 = Boolean('pc4') PC5 = Boolean('pc5') PC6 = Boolean('pc6')
from kb import KB, Boolean, Integer # The variables initialized below need to be initialized to use different strategies. We can reduce these variables # if we plan to use a strategy where all of them are not being used. A0 = Boolean('a0') T0 = Boolean('t0') K0 = Boolean('k0') Q0 = Boolean('q0') J0 = Boolean('j0') A1 = Boolean('a1') T1 = Boolean('t1') K1 = Boolean('k1') Q1 = Boolean('q1') J1 = Boolean('j1') A2 = Boolean('a2') T2 = Boolean('t2') K2 = Boolean('k2') Q2 = Boolean('q2') J2 = Boolean('j2') A3 = Boolean('a3') T3 = Boolean('t3') K3 = Boolean('k3') Q3 = Boolean('q3') J3 = Boolean('j3') A4 = Boolean('a4') T4 = Boolean('t4') K4 = Boolean('k4') Q4 = Boolean('q4') J4 = Boolean('j4') A5 = Boolean('a5')
import kb, sys from kb import KB, Boolean, Integer, Constant # Define our propositional symbols # J1 is true if the card with index 1 is a jack, etc # You need to initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') PJ0 = Boolean('pj0') PJ1 = Boolean('pj1') PJ2 = Boolean('pj2') PJ3 = Boolean('pj3')
from kb import KB, Boolean, Integer # Initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Jack strategy. # Jacks J0 = Boolean('j0') J1 = Boolean('j1') J2 = Boolean('j2') J3 = Boolean('j3') J4 = Boolean('j4') J5 = Boolean('j5') J6 = Boolean('j6') J7 = Boolean('j7') J8 = Boolean('j8') J9 = Boolean('j9') J10 = Boolean('j10') J11 = Boolean('j11') J12 = Boolean('j12') J13 = Boolean('j13') J14 = Boolean('j14') J15 = Boolean('j15') J16 = Boolean('j16') J17 = Boolean('j17') J18 = Boolean('j18') J19 = Boolean('j19') #Queens Q0 = Boolean('q0') Q1 = Boolean('q1') Q2 = Boolean('q2') Q3 = Boolean('q3')
import sys from kb import KB, Boolean, Integer, Constant # Define our symbols Q = Boolean('Q') P = Boolean('P') R = Boolean('R') # Create a new knowledge base kb = KB() # Add clauses kb.add_clause(P, Q) kb.add_clause(~Q, R) kb.add_clause(~R, ~P) kb.add_clause(Q, ~P) kb.add_clause(P, ~Q) # Print all models of the knowledge base for model in kb.models(): print(model) # Print out whether the KB is satisfiable (if there are no models, it is not satisfiable) print(kb.satisfiable())
import kb, sys from kb import KB, Boolean, Integer, Constant # Define our propositional symbols # T1 is true if the card with index 1 is a tack, etc # You need to initialise all variables that you need for you strategies and game knowledge. # Add those variables here.. The following list is complete for the Play Tack strategy. T0 = Boolean('t0') T1 = Boolean('t1') T2 = Boolean('t2') T3 = Boolean('t3') T4 = Boolean('t4') T5 = Boolean('t5') T6 = Boolean('t6') T7 = Boolean('t7') T8 = Boolean('t8') T9 = Boolean('t9') T10 = Boolean('t10') T11 = Boolean('t11') T12 = Boolean('t12') T13 = Boolean('t13') T14 = Boolean('t14') T15 = Boolean('t15') T16 = Boolean('t16') T17 = Boolean('t17') T18 = Boolean('t18') T19 = Boolean('t19') A0 = Boolean('a0') A1 = Boolean('a1')