def handle_move(self, move, feedback):
for i in range(0, LENGTH_OF_CODE):
if feedback[i] == 1:
assignment = get_proposition(i + 1, move[i])
self.__handle_perfectly_correct_element(assignment)
if feedback[i] == 0:
assignment = get_proposition(i + 1, move[i])
self.__handle_correct_color_incorrect_position_element(
assignment)
if feedback[i] == -1:
self.__handle_incorrect_element(move[i])
return
def test_get_proposition():
""" when color_number is valid """
index = 3
color_number = 4
expected_proposition = "3:green"
proposition = get_proposition(index, color_number)
assert proposition == expected_proposition
""" when color_number is invalid """
index = 3
color_number = 0
expected_proposition = ""
proposition = get_proposition(index, color_number)
assert proposition == expected_proposition
def get_assignment(code):
assignment = {}
for i in range(0, LENGTH_OF_CODE):
proposition = get_proposition(i + 1, code[i])
assignment[proposition] = True
return assignment
def __move_to_world_assignment(move):
assignment = {}
for i in range(0, len(move)):
proposition = get_proposition(i + 1, move[i])
assignment[proposition] = True
return assignment
def __handle_incorrect_element(self, color_number):
worlds = copy.deepcopy(self.model.worlds)
for w in worlds:
for i in range(1, LENGTH_OF_CODE + 1):
assignment = get_proposition(i, color_number)
if assignment in w.assignment:
self.model.remove_node_by_name(w.name)
return
def __deduce_knowledge_for_wrongly_positioned_element(
self, index, color_number):
for i in range(1, 5):
if i != index:
proposition = get_proposition(i, color_number)
may_be = generate_may_be_proposition(proposition)
self.agent2.append(may_be)
return
def __add_knowledge_for_incorrect_element(self, index, color_number):
for i in range(1, 5):
proposition = get_proposition(i, color_number)
negative = generate_negative_proposition(proposition)
self.common_knowledge.append(negative)
self.__deduce_knowledge_for_incorrect_element(index, color_number)
return
def __deduce_knowledge_for_incorrect_element(self, index, color_number):
all_available_colors = [1, 2, 3, 4, 5, 6]
for c in all_available_colors:
if c != color_number:
proposition = get_proposition(index, c)
may_be = generate_may_be_proposition(proposition)
self.agent2.append(may_be)
return
def __add_knowledge_for_perfectly_correct_element(self, index,
color_number):
proposition = get_proposition(index, color_number)
self.common_knowledge.append(proposition)
self.__deduce_knowledge_for_correct_element(index, color_number)
return
def handle_move(self, move, feedback):
"""
Handles each move and its feedback as a public
announcement, and restricts the available model
accordingly.
"""
for i in range(0, LENGTH_OF_CODE):
if feedback[i] == 1:
assignment = get_proposition(i + 1, move[i])
self.__handle_perfectly_correct_element(assignment)
if feedback[i] == 0:
assignment = get_proposition(i + 1, move[i])
self.__handle_wrongly_positioned_element(assignment)
if feedback[i] == -1:
self.__handle_incorrect_element(move[i])
return
def __add_knowledge_for_wrongly_positioned_element(self, index,
color_number):
proposition = get_proposition(index, color_number)
negative = generate_negative_proposition(proposition)
self.common_knowledge.append(negative)
self.__deduce_knowledge_for_wrongly_positioned_element(
index, color_number)
return
def __extract_direct_knowledge(self, code):
"""
From the secret code, extracts direct knowledge about
the colors being present at given positions,
and adds it to agent1 individual knowledge.
"""
for i in range(0, len(code)):
proposition = get_proposition(i + 1, code[i])
self.agent1.append(proposition)
return
def __extract_indirect_knowledge(self, code):
all_available_colors = [1, 2, 3, 4, 5, 6]
for i in range(0, len(code)):
for c in all_available_colors:
if c != code[i]:
proposition = get_proposition(i + 1, c)
negative = generate_negative_proposition(proposition)
self.agent1.append(negative)
return
def get_assignment(code):
"""
Get world assignment from the code
[1 2 3 4] -> {'1:yellow', '2:violet', '3:red', '4:green'}
"""
assignment = {}
for i in range(0, LENGTH_OF_CODE):
proposition = get_proposition(i + 1, code[i])
assignment[proposition] = True
return assignment
def __deduce_knowledge_for_incorrect_element(self, index, color_number):
"""
Extracts indirect knowledge about incorrectly guessed color,
that is, MAY BE some other color is present at that position,
and adds it to individual knowledge of agent2.
"""
all_available_colors = [1, 2, 3, 4, 5, 6]
for c in all_available_colors:
if c != color_number:
proposition = get_proposition(index, c)
may_be = generate_may_be_proposition(proposition)
self.agent2.append(may_be)
return
def __deduce_knowledge_for_wrongly_positioned_element(
self, index, color_number):
"""
Extracts indirect knowledge about wrongly positioned color,
that is, this color is MAY BE present at some other position,
and adds it to individual knowledge of agent2.
"""
for i in range(1, 5):
if i != index:
proposition = get_proposition(i, color_number)
may_be = generate_may_be_proposition(proposition)
self.agent2.append(may_be)
return
def __handle_incorrect_element(self, color_number):
"""
For incorrectly guessed color, remove the worlds
which have this color at any position
and derive the reduced model.
"""
worlds = copy.deepcopy(self.model.worlds)
for w in worlds:
for i in range(1, LENGTH_OF_CODE + 1):
assignment = get_proposition(i, color_number)
if assignment in w.assignment:
self.model.remove_node_by_name(w.name)
return
def __deduce_knowledge_for_correct_element(self, index, color_number):
"""
Extracts indirect knowledge about perfectly positioned colors,
that is, other colors NOT being present at those positions,
and adds it to individual knowledge of agent2.
"""
all_available_colors = [1, 2, 3, 4, 5, 6]
for c in all_available_colors:
if c != color_number:
proposition = get_proposition(index, c)
negative = generate_negative_proposition(proposition)
self.agent2.append(negative)
return
def __add_knowledge_for_incorrect_element(self, index, color_number):
"""
From the move and feedback, extracts knowledge about
the colors which are incorrectly guessed.
Extracts direct knowledge about these colors NOT being
present anywhere, and adds it to the common knowledge.
Invokes extraction of indirect knowledge.
"""
for i in range(1, 5):
proposition = get_proposition(i, color_number)
negative = generate_negative_proposition(proposition)
self.common_knowledge.append(negative)
self.__deduce_knowledge_for_incorrect_element(index, color_number)
return
def __add_knowledge_for_perfectly_correct_element(self, index,
color_number):
"""
From the move and feedback, extracst knowledge about
the colors which are perfectly positioned.
Adds direct knowledge about those colors being present
to the common knowledge.
Invokes extraction of indirect knowledge
"""
proposition = get_proposition(index, color_number)
self.common_knowledge.append(proposition)
self.__deduce_knowledge_for_correct_element(index, color_number)
return
def __extract_indirect_knowledge(self, code):
"""
From the secret code, extracts indirect knowledge about
the other colors NOT being present at given positions,
and adds it to agent1 individual knowledge.
"""
all_available_colors = [1, 2, 3, 4, 5, 6]
for i in range(0, len(code)):
for c in all_available_colors:
if c != code[i]:
proposition = get_proposition(i + 1, c)
negative = generate_negative_proposition(proposition)
self.agent1.append(negative)
return
def __add_knowledge_for_wrongly_positioned_element(self, index,
color_number):
"""
From the move and feedback, extracts knowledge about
the colors which are wrongly positioned.
Extracts direct knowledge about these colors NOT being
present at that position, and adds it to the common knowledge.
Invokes extraction of indirect knowledge
"""
proposition = get_proposition(index, color_number)
negative = generate_negative_proposition(proposition)
self.common_knowledge.append(negative)
self.__deduce_knowledge_for_wrongly_positioned_element(
index, color_number)
return
def __extract_direct_knowledge(self, code):
for i in range(0, len(code)):
proposition = get_proposition(i + 1, code[i])
self.agent1.append(proposition)
return