def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = decode_state(state, self.state_map)
new_state.pos = [
f for f in new_state.pos if f not in action.effect_rem
]
# Use effect_add
new_state.pos += action.effect_add
return encode_state(new_state, self.state_map)
new_state = FluentState([], [])
current_state = decode_state(state, self.state_map)
for state in current_state.pos:
if state not in action.effect_rem:
new_state.pos.append(state)
for state in action.effect_add:
if state not in new_state.pos:
new_state.pos.append(state)
for state in current_state.neg:
if state not in action.effect_add:
new_state.neg.append(state)
for state in action.effect_rem:
if state not in new_state.neg:
new_state.neg.append(state)
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['ATL', 'JFK', 'SFO']
pos = [
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(C3, ATL)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)'),
expr('At(P3, ATL)'),
]
neg = get_negatives(cargos, planes, airports, pos)
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C2, SFO)'),
expr('At(C3, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def __init__(self, cargos, planes, airports, initial: FluentState, goal: list):
"""
:param cargos: list of str
cargos in the problem
:param planes: list of str
planes in the problem
:param airports: list of str
airports in the problem
:param initial: FluentState object
positive and negative literal fluents (as expr) describing initial state
:param goal: list of expr
literal fluents required for goal test
"""
self.state_map = initial.pos + initial.neg
self.initial_state_TF = encode_state(initial, self.state_map)
self.goal_state_TF = encode_state(FluentState(goal, []), self.state_map)
Problem.__init__(self, self.initial_state_TF, goal=goal)
self.cargos = cargos
self.planes = planes
self.airports = airports
self.actions_list = self.get_actions()
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = FluentState([], [])
kb = PropKB()
kb.tell(decode_state(state, self.state_map).pos_sentence())
action(kb, action.args)
for clause in kb.clauses:
new_state.pos.append(clause)
for clause in action.effect_rem:
new_state.neg.append(clause)
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
# TODO implement Problem 2 definition
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['SFO', 'JFK', 'ATL']
pos = [
expr('At(P1, SFO)'),
expr('At(P2, JFK)'),
expr('At(P3, ATL)'),
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(C3, ATL)')
]
neg = [
expr('At(P1, JFK)'),
expr('At(P1, ATL)'),
expr('At(P2, SFO)'),
expr('At(P2, ATL)'),
expr('At(P3, SFO)'),
expr('At(P3, JFK)'),
expr('At(C1, JFK)'),
expr('At(C1, ATL)'),
expr('At(C2, SFO)'),
expr('At(C2, ATL)'),
expr('At(C3, SFO)'),
expr('At(C3, JFK)'),
expr('In(C1, P1)'),
expr('In(C1, P2)'),
expr('In(C1, P3)'),
expr('In(C2, P1)'),
expr('In(C2, P2)'),
expr('In(C2, P3)'),
expr('In(C3, P1)'),
expr('In(C3, P2)'),
expr('In(C3, P3)')
]
init = FluentState(pos, neg)
goal = [expr('At(C1, JFK)'), expr('At(C2, SFO)'), expr('At(C3, SFO)')]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
current_state = decode_state(state, self.state_map)
new_pos = set(current_state.pos)
new_neg = set(current_state.neg)
for add in action.effect_add:
new_pos.add(add)
new_neg.discard(add)
for rem in action.effect_rem:
new_pos.discard(rem)
new_neg.add(rem)
return encode_state(FluentState(list(new_pos), list(new_neg)), self.state_map)
def air_cargo_p3() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3', 'C4']
planes = ['P1', 'P2']
airports = ['JFK', 'SFO', 'ATL', 'ORD']
pos = [
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(C3, ATL)'),
expr('At(C4, ORD)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)')
]
# -----------
neg = []
for c in cargos:
for p in planes:
# all cargos not in the planes
neg.append(expr('In({}, {})'.format(c, p)))
for a in airports:
# adding to 'neg' those combinations that not in 'pos'
if not expr('At({}, {})'.format(c, a)) in pos:
neg.append(expr('At({}, {})'.format(c, a)))
for p in planes:
for a in airports:
# adding to 'neg' those combinations that not in 'pos'
if not expr('At({}, {})'.format(p, a)) in pos:
neg.append(expr('At({}, {})'.format(p, a)))
# -------------
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C3, JFK)'),
expr('At(C2, SFO)'),
expr('At(C4, SFO)')
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
new_state.pos = list(
set(old_state.pos) - set(action.effect_rem)
| set(action.effect_add))
new_state.neg = list(
set(old_state.neg) - set(action.effect_add)
| set(action.effect_rem))
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['SFO', 'JFK', 'ATL']
pos = []
neg = []
for x in range(0, 3):
pos.append(expr('At(' + cargos[x] + ',' + airports[x] + ')'))
pos.append(expr('At(' + planes[x] + ',' + airports[x] + ')'))
for y in range(0, 3):
neg.append(expr('In(' + cargos[x] + ',' + planes[y] + ')'))
if x != y:
neg.append(expr('At(' + cargos[x] + ',' + airports[y] + ')'))
neg.append(expr('At(' + planes[x] + ',' + airports[y] + ')'))
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C2, SFO)'),
expr('At(C3, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# Lifted from example_have_cake.py
new_state = FluentState([], [])
# Get the current state
old_state = decode_state(state, self.state_map)
# Per the teaching materials, the precondition and effect of an action are each conjunctions of literals
# (positive or negated atomic sentences). The precondition defines the states in which the action can be
# executed, and the effect defines the result of executing the action. So, for each fluent (positive or
# negative) in the old state, we need to look in the action's effects (both the add and remove effects) to
# determine how the fluent will be carried over to the new state, as a positive or a negative fluent.
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append(fluent)
# The action may have positive and negative effects INDEPENDENTLY of the old state. If they're add effects,
# we need to make sure these fluents are added to the new state's positive sentences. Similarly, if they're
# remove effects, these fluents need to be added to the new state's negative sentences.
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(fluent)
for fluent in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(fluent)
# Return the new state
return encode_state(new_state, self.state_map)
def air_cargo_p1() -> AirCargoProblem:
'''
Problem 1 initial state and goal:
Init(At(C1, SFO) ∧ At(C2, JFK)
∧ At(P1, SFO) ∧ At(P2, JFK)
∧ Cargo(C1) ∧ Cargo(C2)
∧ Plane(P1) ∧ Plane(P2)
∧ Airport(JFK) ∧ Airport(SFO))
Goal(At(C1, JFK) ∧ At(C2, SFO))
'''
cargos = ['C1', 'C2']
planes = ['P1', 'P2']
airports = ['JFK', 'SFO']
pos = [
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)')
]
neg = [
expr('At(C2, SFO)'),
expr('In(C2, P1)'),
expr('In(C2, P2)'),
expr('At(C1, JFK)'),
expr('In(C1, P1)'),
expr('In(C1, P2)'),
expr('At(P1, JFK)'),
expr('At(P2, SFO)')
]
# set initial state as fluent of positive and negative assertions
init = FluentState(pos_list=pos, neg_list=neg)
goal = [expr('At(C1, JFK)'), expr('At(C2, SFO)')]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action): # here
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
old_state = decode_state(state, self.state_map)
pos_list = old_state.pos
neg_list = old_state.neg
for rem in action.effect_rem:
pos_list.remove(rem)
neg_list.append(rem)
for add in action.effect_add:
pos_list.append(add)
neg_list.remove(add)
new_state = FluentState(pos_list, neg_list)
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'ATL']
pos = [
expr("At(C1, SFO)"),
expr("At(C2, JFK)"),
expr("At(C3, ATL)"),
expr("At(P1, SFO)"),
expr("At(P2, JFK)"),
expr("At(P3, ATL)")
]
neg = [
expr("At(C1, JFK)"),
expr("At(C1, ATL)"),
expr("In(C1, P1)"),
expr("In(C1, P2)"),
expr("In(C1, P3)"),
expr("At(C2, SFO)"),
expr("At(C2, ATL)"),
expr("In(C2, P1)"),
expr("In(C2, P2)"),
expr("In(C2, P3)"),
expr("At(C3, JFK)"),
expr("At(C3, SFO)"),
expr("In(C3, P1)"),
expr("In(C3, P2)"),
expr("In(C3, P3)"),
expr("At(P1, JFK)"),
expr("At(P1, ATL)"),
expr("At(P2, SFO)"),
expr("At(P2, ATL)"),
expr("At(P3, JFK)"),
expr("At(P3, SFO)")
]
init = FluentState(pos, neg)
goal = [expr('At(C1, JFK)'), expr('At(C2, SFO)'), expr('At(C3, SFO)')]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
new_state.pos.extend(
[f for f in old_state.pos if f not in action.effect_rem])
new_state.pos.extend(
[f for f in action.effect_add if f not in new_state.pos])
new_state.neg.extend(
[f for f in old_state.neg if f not in action.effect_add])
new_state.neg.extend(
[f for f in action.effect_rem if f not in new_state.neg])
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'OTP']
pos = [expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)'),
expr('At(P3, OTP)'),
expr('At(C3, OTP)'),
]
neg = [expr('At(C2, SFO)'),
expr('At(C2, OTP)'),
expr('In(C2, P1)'),
expr('In(C2, P2)'),
expr('In(C2, P3)'),
expr('At(C3, SFO)'),
expr('At(C3, JFK)'),
expr('In(C3, P1)'),
expr('In(C3, P2)'),
expr('In(C3, P3)'),
expr('At(C1, JFK)'),
expr('At(C1, OTP)'),
expr('In(C1, P1)'),
expr('In(C1, P2)'),
expr('In(C1, P3)'),
expr('At(P1, JFK)'),
expr('At(P1, OTP)'),
expr('At(P2, SFO)'),
expr('At(P2, OTP)'),
expr('At(P3, JFK)'),
expr('At(P3, SFO)'),
]
init = FluentState(pos, neg)
goal = [expr('At(C1, JFK)'),
expr('At(C2, OTP)'),
expr('At(C3, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Returns the state that results from executing the given
action in the given state. The action is one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
# If a positive fluent has not been removed by the effect of current action then
# append that to positive fluents in the new_state.
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
# If a new positive fluent is added by the effect of current action then
# append that to positive fluents in the new_state.
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(fluent)
# If a negative fluent has not been removed by the effect of current action then
# append that to negative fluents in the new_state.
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append
# If a negative fluent has been removed by the effect of current action then
# append that to negative fluents in the new_state.
for fluents in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(fluent)
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'ATL']
pos = [
at_e('C1', 'SFO'),
at_e('C2', 'JFK'),
at_e('C3', 'ATL'),
at_e('P1', 'SFO'),
at_e('P2', 'JFK'),
at_e('P3', 'ATL')
]
neg = [
at_e('C2', 'SFO'),
at_e('C2', 'ATL'),
in_e('C2', 'P1'),
in_e('C2', 'P2'),
in_e('C2', 'P3'),
at_e('C1', 'JFK'),
at_e('C1', 'ATL'),
in_e('C1', 'P1'),
in_e('C1', 'P2'),
in_e('C1', 'P3'),
at_e('C3', 'JFK'),
at_e('C3', 'SFO'),
in_e('C3', 'P1'),
in_e('C3', 'P2'),
in_e('C3', 'P3'),
at_e('P1', 'JFK'),
at_e('P1', 'ATL'),
at_e('P2', 'SFO'),
at_e('P2', 'ATL'),
at_e('P3', 'JFK'),
at_e('P3', 'SFO')
]
init = FluentState(pos, neg)
goal = [at_e('C1', 'JFK'), at_e('C2', 'SFO'), at_e('C3', 'SFO')]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
This routine simply takes the current state, pos and neg, and copies to a new version depending
on the action's effects which can be add or rem.
So if the action has a add effect the new state will contain that effect in its pos section
If the action has a rem effect then the new state will contain that effect in its neg section
More formally put (p368) - The result of executing action a in state s is defined as a state s' which is represented
by the set of fluents formed by starting with s, removing the fluents that appear as negative literals in the
action's effects (what we wil call the delete list or DEL(a), and addign the fluents that are positie literals
in the action's effects (what we will call the add list or ADD(a).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
#print('Running result() function...')
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(fluent)
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append(fluent)
for fluent in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(fluent)
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ["C1", "C2", "C3"]
planes = ["P1", "P2", "P3"]
airports = ["JFK", "SFO", "ATL"]
pos = [
expr("At(C1, SFO)"),
expr("At(C2, JFK)"),
expr("At(C3, ATL)"),
expr("At(P1, SFO)"),
expr("At(P2, JFK)"),
expr("At(P3, ATL)")
]
neg = []
# for c in cargos:
# for p in planes:
# neg.append(expr("In({}, {})".format(c, p)))
neg = [expr("In({}, {})".format(c, p)) for p in planes for c in cargos]
for c in cargos:
for a in airports:
if not ((c == "C1" and a == "SFO") or (c == "C2" and a == "JFK") or
(c == "C3" and a == "ATL")):
neg.append(expr("At({}, {})".format(c, a)))
for p in planes:
for a in airports:
if not ((p == "P1" and a == "SFO") or (p == "P2" and a == "JFK") or
(p == "P3" and a == "ATL")):
neg.append(expr("At({}, {})".format(p, a)))
init = FluentState(pos, neg)
goal = [expr("At(C1, JFK)"), expr("At(C2, SFO)"), expr("At(C3, SFO)")]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = FluentState([], [])
#This code is used from Cake example file
#The idea of this function is to define next state in our problem
#which is going to "happen" after applying current action
old_state = decode_state(state, self.state_map)
#Going through positive fluents in previous (old) state
for fluent in old_state.pos:
#if that fluent is not in removal_effect from action -> add it to positve fluents for new state
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
#going through fluents that are added by the action
for fluent in action.effect_add:
#if that fluent is not already in positive fluents of new state -> add it
if fluent not in new_state.pos:
new_state.pos.append(fluent)
#going through negative fluents from old state
for fluent in old_state.neg:
#if that negative fluent is not in adding fluents of the action -> add it to negative fluents for new state
if fluent not in action.effect_add:
new_state.neg.append(fluent)
#going through fluents that are being removed by the action
for fluent in action.effect_rem:
#if that fluent is not already in negatives for the new state -> add it
if fluent not in new_state.neg:
new_state.neg.append(fluent)
return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
for pos_fluent in old_state.pos:
if pos_fluent not in action.effect_rem: # positive effect
new_state.pos.append(pos_fluent)
for pos_fluent in action.effect_add: # negative effect
if pos_fluent not in new_state.pos:
new_state.pos.append(pos_fluent)
for neg_fluent in old_state.neg:
if neg_fluent not in action.effect_add: # negative effect
new_state.neg.append(neg_fluent)
for neg_fluent in action.effect_rem: # positive effect
if neg_fluent not in new_state.neg:
new_state.neg.append(neg_fluent)
'''
old_state = decode_state(state, self.state_map)
pos, neg = set(old_state.pos), set(old_state.neg)
pos = pos - set(action.effect_rem) | set(action.effect_add)
neg = neg - set(action.effect_add) | set(action.effect_rem)
new_state = FluentState(list(pos), list(neg))
'''
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ["C1", "C2", "C3"]
planes = ["P1", "P2", "P3"]
airports = ["JFK", "ATL", "SFO"]
pos = [
expr("At(C1, SFO)"),
expr("At(C2, JFK)"),
expr("At(C3, ATL)"),
expr("At(P1, SFO)"),
expr("At(P2, JFK)"),
expr("At(P3, ATL)"),
]
neg = [
expr("At(C1, JFK)"),
expr("At(C1, ATL)"),
expr("At(C2, SFO)"),
expr("At(C2, ATL)"),
expr("At(C3, JFK)"),
expr("At(C3, SFO)"),
expr("At(P1, JFK)"),
expr("At(P1, ATL)"),
expr("At(P2, SFO)"),
expr("At(P2, ATL)"),
expr("At(P3, JFK)"),
expr("At(P3, SFO)"),
expr("In(C1, P1)"),
expr("In(C1, P2)"),
expr("In(C1, P3)"),
expr("In(C2, P1)"),
expr("In(C2, P2)"),
expr("In(C2, P3)"),
expr("In(C3, P1)"),
expr("In(C3, P2)"),
expr("In(C3, P3)"),
]
init = FluentState(pos_list=pos, neg_list=neg)
goal = [expr("At(C1, JFK)"), expr("At(C2, SFO)"), expr("At(C3, SFO)")]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(fluent)
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append(fluent)
for fluent in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(fluent)
return encode_state(new_state, self.state_map)
def air_cargo_p1() -> AirCargoProblem:
'''
Init(At(C1, SFO) ∧ At(C2, JFK)
∧ At(P1, SFO) ∧ At(P2, JFK)
∧ Cargo(C1) ∧ Cargo(C2)
∧ Plane(P1) ∧ Plane(P2)
∧ Airport(JFK) ∧ Airport(SFO))
Goal(At(C1, JFK) ∧ At(C2, SFO))
'''
cargos = ['C1', 'C2']
planes = ['P1', 'P2']
airports = ['JFK', 'SFO']
# Track where the planes and cargo are at
pos = [
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)'),
]
# Track where the planes and cargo are not at
neg = [
expr('At(C2, SFO)'),
expr('In(C2, P1)'),
expr('In(C2, P2)'),
expr('At(C1, JFK)'),
expr('In(C1, P1)'),
expr('In(C1, P2)'),
expr('At(P1, JFK)'),
expr('At(P2, SFO)'),
]
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C2, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(
fluent
) # add positive fluents which are in the old state and should not be removed
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(
fluent
) # add positive fluents which should be added and have not already been added
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append(
fluent
) # add negative fluents which are in the old state and should not be added
for fluent in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(
fluent
) # add negative fluents which should be removed but have not already been removed from the negative state
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'ATL']
pos = [
expr('At(C1, SFO)'),
expr('At(C2, JFK)'),
expr('At(C3, ATL)'),
expr('At(P1, SFO)'),
expr('At(P2, JFK)'),
expr('At(P3, ATL)'),
]
neg = [
expr('At(C3, JFK)'), # A LITTLE CONFUSED ON THIS
expr('At(C3, SFO)'), # GOT NEGATION OF WHERE CARGOS AT
expr('In(C3, P1)'),
expr('In(C3, P2)'),
expr('In(C3, P3)'),
expr('At(C2, SFO)'),
expr('At(C2, ATL)'),
expr('In(C2, P1)'),
expr('In(C2, P2)'),
expr('In(C2, P3)'),
expr('At(C1, JFK)'),
expr('At(C1, ATL)'),
expr('In(C1, P1)'),
expr('In(C1, P2)'),
expr('In(C1, P3)'),
expr('At(P1, JFK)'),
expr('At(P1, ATL)'),
expr('At(P2, SFO)'),
expr('At(P2, ATL)'),
expr('At(P3, JFK)'),
expr('At(P3, SFO)')
]
init = FluentState(pos, neg)
goal = [expr('At(C1, JFK)'), expr('At(C2, SFO)'), expr('At(C3, SFO)')]
return AirCargoProblem(cargos, planes, airports, init, goal)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# TODO implement
# Get the current state
curr_state = decode_state(state, self.state_map)
new_state = FluentState([], [])
# For each fluent in current state, we need to check the action's effects (added or removed effects),
# in order to how the positive or negative fluent can be carried over to the new state.
for f in curr_state.neg:
if f not in action.effect_add:
new_state.neg.append(f)
for f in curr_state.pos:
if f not in action.effect_rem:
new_state.pos.append(f)
# The action may have positive and negative effects separated, e.g. we need to check if the fluents are
# added to the new state's positive clauses if the actions have add effects. It is also the same for negative
# clauses
for f in action.effect_rem:
if f not in new_state.neg:
new_state.neg.append(f)
for f in action.effect_add:
if f not in new_state.pos:
new_state.pos.append(f)
return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action):
""" Return the state that results from executing the given
action in the given state. The action must be one of
self.actions(state).
:param state: state entering node
:param action: Action applied
:return: resulting state after action
"""
# This from example_have_cake.py should work
new_state = FluentState([], [])
old_state = decode_state(state, self.state_map)
"""
for fluent in old_state.pos:
if fluent not in action.effect_rem:
new_state.pos.append(fluent)
for fluent in action.effect_add:
if fluent not in new_state.pos:
new_state.pos.append(fluent)
for fluent in old_state.neg:
if fluent not in action.effect_add:
new_state.neg.append(fluent)
for fluent in action.effect_rem:
if fluent not in new_state.neg:
new_state.neg.append(fluent)
"""
# This may be a better way, how much depends on the size
pos_fluents = set(old_state.pos)
pos_fluents.difference_update(action.effect_rem)
pos_fluents.update(action.effect_add)
new_state.pos.extend(pos_fluents)
neg_fluents = set(old_state.neg)
neg_fluents.difference_update(action.effect_add)
neg_fluents.update(action.effect_rem)
new_state.neg.extend(neg_fluents)
#"""
return encode_state(new_state, self.state_map)
def air_cargo_p2() -> AirCargoProblem:
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'ATL']
at_list = [ \
('C1','SFO'), \
('C2','JFK'), \
('C3','ATL'), \
('P1','SFO'), \
('P2','JFK'), \
('P3','ATL'), \
]
pos = [expr('At({}, {})'.format(a, b)) for a, b in at_list]
neg = []
for p in planes:
for ap in airports:
if (p, ap) in at_list:
continue
neg.append(expr('At({}, {})'.format(p, ap)))
for c in cargos:
for ap in airports:
if (c, ap) in at_list:
continue
neg.append(expr('At({}, {})'.format(c, ap)))
for c in cargos:
for p in planes:
if (c, p) in at_list:
continue
neg.append(expr('In({}, {})'.format(c, p)))
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C2, SFO)'),
expr('At(C3, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
def air_cargo_p2() -> AirCargoProblem:
# TODO implement Problem 2 definition
cargos = ['C1', 'C2', 'C3']
planes = ['P1', 'P2', 'P3']
airports = ['JFK', 'SFO', 'ATL']
pos = [
expr('At(C1, SFO)'),
expr('At(P1, SFO)'),
expr('At(C2, JFK)'),
expr('At(P2, JFK)'),
expr('At(C3, ATL)'),
expr('At(P3, ATL)'),
]
neg = [
expr('At(C1, JFK)'),
expr('At(P1, JFK)'),
expr('At(C1, ATL)'),
expr('At(P1, ATL)'),
expr('At(C2, SFO)'),
expr('At(P2, SFO)'),
expr('At(C2, ATL)'),
expr('At(P2, ATL)'),
expr('At(C3, SFO)'),
expr('At(P3, SFO)'),
expr('At(C3, JFK)'),
expr('At(P3, JFK)'),
]
neg += [expr('In({},{})'.format(c, p)) for c in cargos for p in planes]
init = FluentState(pos, neg)
goal = [
expr('At(C1, JFK)'),
expr('At(C2, SFO)'),
expr('At(C3, SFO)'),
]
return AirCargoProblem(cargos, planes, airports, init, goal)
