def maxLevel(state, problem):
"""
The heuristic value is the number of layers required to expand all goal propositions.
If the goal is not reachable from the state your heuristic should return float('inf')
A good place to start would be:
propLayerInit = PropositionLayer() #create a new proposition layer
for prop in state:
propLayerInit.addProposition(prop) #update the proposition layer with the propositions of the state
pgInit = PlanGraphLevel() #create a new plan graph level (level is the action layer and the propositions layer)
pgInit.setPropositionLayer(propLayerInit) #update the new plan graph level with the the proposition layer
"""
"*** YOUR CODE HERE ***"
propLayerInit = PropositionLayer() #create a new proposition layer
for prop in state:
propLayerInit.addProposition(prop) #update the proposition layer with the propositions of the state
pgInit = PlanGraphLevel() #create a new plan graph level (level is the action layer and the propositions layer)
pgInit.setPropositionLayer(propLayerInit) #update the new plan graph level with the the proposition layer
level = 0;
while not problem.isGoalState(pgInit.getPropositionLayer().getPropositions()):
level += 1
## Expand to the next leyer
prevLayerSize = len(pgInit.getPropositionLayer().getPropositions())
pgInit.expandWithoutMutex(pgInit)
## Check if the expanded leyer is the same leyer as before
if len(pgInit.getPropositionLayer().getPropositions()) == prevLayerSize:
return float("inf")
return level
def levelSum(state, problem):
"""
The heuristic value is the sum of sub-goals level they first appeared.
If the goal is not reachable from the state your heuristic should return float('inf')
"""
propLayerInit = PropositionLayer() #create a new proposition layer
for prop in state:
propLayerInit.addProposition(prop) #update the proposition layer with the propositions of the state
pgInit = PlanGraphLevel() #create a new plan graph level (level is the action layer and the propositions layer)
pgInit.setPropositionLayer(propLayerInit) #update the new plan graph level with the the proposition layer
level = 0
sumLevel = 0
currentGoals = set(copy.copy(problem.goal))
while currentGoals: #TODO: Changed: run until all goals found/no solution possible
#check for new goals achieved
goalsInHand = set(pgInit.getPropositionLayer().getPropositions()) & currentGoals
if goalsInHand:
sumLevel += len(goalsInHand) * level;
currentGoals -= goalsInHand;
level += 1
## Expand to the next leyer
prevLayerSize = len(pgInit.getPropositionLayer().getPropositions())
pgInit.expandWithoutMutex(pgInit)
## Check if the expanded leyer is the same leyer as before
if len(pgInit.getPropositionLayer().getPropositions()) == prevLayerSize:
return float("inf")
return sumLevel
def maxLevel(state, problem):
"""
The heuristic value is the number of layers required to expand all goal propositions.
If the goal is not reachable from the state your heuristic should return float('inf')
A good place to start would be:
propLayerInit = PropositionLayer() #create a new proposition layer
for prop in state:
propLayerInit.addProposition(prop) #update the proposition layer with the propositions of the state
pgInit = PlanGraphLevel() #create a new plan graph level (level is the action layer and the propositions layer)
pgInit.setPropositionLayer(propLayerInit) #update the new plan graph level with the the proposition layer
"""
"*** YOUR CODE HERE ***"
# explain: implement max level heuristic
# expand the graph with out mutexs until the goal is reached,
# the heuristic value is the number of levels need to reach the goal
pg = state
Graph = []
Graph.append(pg)
Level = 0
pgNext = pg
isRepeat = False
isGoal = False
while not isGoal and not isRepeat:
# expand next level without mutexs
pgPrev = pgNext
pgNext = PlanGraphLevel()
pgNext.expandWithoutMutex(pgPrev)
Graph.append(pgNext)
Level += 1
# check if level expansion is in 'levels-off' state
# if isFixed() function return true' check if the current level was aread reached in a previous graph history
# if so, we are in a loop state and the heuristic value should be 'inf'
if isFixed(Graph, Level):
pgNextPropositions = pgNext.getPropositionLayer().getPropositions()
isRepeat = True
for Hist in range(Level - 1):
HistLevelPropositions = Graph[Hist].getPropositionLayer(
).getPropositions()
for prop in pgNextPropositions:
if prop not in HistLevelPropositions:
isRepeat = False
isGoal = not problem.goalStateNotInPropLayer(
pgNext.propositionLayer.propositions)
h = Level
if isRepeat and not isGoal:
h = float('inf')
return h
def levelSum(state, problem):
"""
The heuristic value is the sum of sub-goals level they first appeared.
If the goal is not reachable from the state your heuristic should return float('inf')
"""
def nextPlan(plan):
next_plan = PlanGraphLevel()
next_plan.expandWithoutMutex(plan)
return next_plan, next_plan.getPropositionLayer().getPropositions()
propLayerInit = PropositionLayer()
# add all to the new proposition layer
lmap(propLayerInit.addProposition, state)
plan = PlanGraphLevel()
plan.setPropositionLayer(propLayerInit)
plan_propositions = plan.getPropositionLayer().getPropositions()
# create a graph that will store all the plan levels
graph = []
graph.append(plan)
goals_levels = dict()
goal = problem.goal
# init goals levels
for p in goal:
goals_levels[p.getName()] = None
# as long as we have for one of the goal None we didnt find the first level
while None in goals_levels.values():
# if fixed we won't have a solution
if isFixed(graph, len(graph) - 1):
return float('inf')
# for each prop in the goal check if exist on the current plan
# propositions
for p in goal:
# check that we didnt assign a value yet
if p in plan_propositions and goals_levels[p.getName()] == None:
# set the current level as the fist appearance of the prop
goals_levels[p.getName()] = len(graph) - 1
# create the next plan by the prev
plan, plan_propositions = nextPlan(plan)
# store in the graph
graph.append(plan)
return sum(goals_levels.values())
def maxLevel(state, problem):
"""
The heuristic value is the number of layers required to expand all goal propositions.
If the goal is not reachable from the state your heuristic should return float('inf')
A good place to start would be:
propLayerInit = PropositionLayer() #create a new proposition layer
for prop in state:
#update the proposition layer with the propositions of the state
propLayerInit.addProposition(prop)
# create a new plan graph level (level is the action layer and the
# propositions layer)
pgInit = PlanGraphLevel()
#update the new plan graph level with the the proposition layer
pgInit.setPropositionLayer(propLayerInit)
"""
def nextPlan(plan):
next_plan = PlanGraphLevel()
next_plan.expandWithoutMutex(plan)
return next_plan, next_plan.getPropositionLayer().getPropositions()
propLayerInit = PropositionLayer()
# add all to the new proposition layer
lmap(propLayerInit.addProposition, state)
plan = PlanGraphLevel()
plan.setPropositionLayer(propLayerInit)
plan_propositions = plan.getPropositionLayer().getPropositions()
# create a graph that will store all the plan levels
graph = []
graph.append(plan)
# if we found we can rest
while not problem.isGoalState(plan_propositions):
# if fixed we won't have a solution
if isFixed(graph, len(graph) - 1):
return float('inf')
# create the next plan by the prev
plan, plan_propositions = nextPlan(plan)
# store in the graph
graph.append(plan)
return len(graph) - 1
def nextPlan(plan):
next_plan = PlanGraphLevel()
next_plan.expandWithoutMutex(plan)
return next_plan, next_plan.getPropositionLayer().getPropositions()
def levelSum(state, problem):
"""
The heuristic value is the sum of sub-goals level they first appeared.
If the goal is not reachable from the state your heuristic should return float('inf')
"""
"*** YOUR CODE HERE ***"
# explain: implement max level heuristic
# expand the graph with out mutexs until the goal is reached,
# the heuristic value is the sum of the levels reached for each goal proposition
pg = state
Graph = []
Graph.append(pg)
Level = 0
Sum = 0
goal = copy.deepcopy(problem.goal)
pgNext = pg
isRepeat = False
isGoal = False
while not isGoal and not isRepeat:
# expand next level without mutexs
pgPrev = pgNext
pgNext = PlanGraphLevel()
pgNext.expandWithoutMutex(pgPrev)
Graph.append(pgNext)
Level += 1
# check if level expansion is in 'levels-off' state
# if isFixed() function return true' check if the current level was aread reached in a previous graph history
# if so, we are in a loop state and the heuristic value should be 'inf'
if isFixed(Graph, Level):
pgNextPropositions = pgNext.getPropositionLayer().getPropositions()
isRepeat = True
for Hist in range(Level - 1):
HistLevelPropositions = Graph[Hist].getPropositionLayer(
).getPropositions()
for prop in pgNextPropositions:
if prop not in HistLevelPropositions:
isRepeat = False
to_delete = []
for prop in goal:
if prop in pgNext.propositionLayer.propositions:
# add each goal level, and delete it from goal list
Sum += Level
to_delete.append(prop)
for prop in to_delete:
goal.remove(prop)
isGoal = len(goal) == 0
h = Sum
if isRepeat and not isGoal:
h = float('inf')
return h
