コード例 #1
0
def pacmanAliveSuccessorStateAxioms(x, y, t, num_ghosts):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    """
    ghost_strs = [
        ghost_pos_str + str(ghost_num) for ghost_num in xrange(num_ghosts)
    ]

    "*** YOUR CODE HERE ***"

    no_ghost = []

    for ghost in ghost_strs:
        ghost_position_before = ~logic.PropSymbolExpr(ghost, x, y, t - 1)
        no_ghost.append(ghost_position_before)
        ghost_position_now = ~logic.PropSymbolExpr(ghost, x, y, t)
        no_ghost.append(ghost_position_now)

    no_ghost_here = logic.conjoin(no_ghost)
    ghost_exists = ~(logic.conjoin(no_ghost))
    pacman_alive_prev = logic.PropSymbolExpr(pacman_alive_str, t - 1)
    pacman_not_there = ~logic.PropSymbolExpr(pacman_str, x, y, t)

    return logic.PropSymbolExpr(pacman_alive_str, t) % (pacman_alive_prev & (
        (no_ghost_here) | (ghost_exists & pacman_not_there)))
コード例 #2
0
def ghostDirectionSuccessorStateAxioms(t, ghost_num, blocked_west_positions,
                                       blocked_east_positions):
    """
    Successor state axiom for patrolling ghost direction state (t) (from t-1).
    west or east walls.
    Current <==> (causes to stay) | (causes of current)
    """
    pos_str = ghost_pos_str + str(ghost_num)
    east_str = ghost_east_str + str(ghost_num)

    "*** YOUR CODE HERE ***"

    west_action = ~(logic.PropSymbolExpr(east_str, t - 1))
    east_action = logic.PropSymbolExpr(east_str, t - 1)

    west_list = []
    east_list = []

    for pos in blocked_east_positions:
        x, y = pos
        not_blocked_east = ~logic.PropSymbolExpr(pos_str, x, y, t)
        lst = logic.conjoin(east_action, not_blocked_east)
        east_list.append(lst)

    for pos in blocked_west_positions:
        x, y = pos
        blocked_west = logic.PropSymbolExpr(pos_str, x, y, t)
        lst = logic.conjoin(west_action, blocked_west)
        west_list.append(lst)

    east_list = logic.conjoin(east_list)
    west_list = logic.disjoin(west_list)

    return logic.PropSymbolExpr(east_str, t) % logic.disjoin(
        east_list, west_list)
コード例 #3
0
def sentence2():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    C if and only if (B or D)
    A implies ((not B) and (not D))
    (not (B and (not C))) implies A
    (not D) implies C
    """
    "*** YOUR CODE HERE ***"

    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    D = logic.Expr('D')
    notB = ~B
    notD = ~D
    notC = ~C
    B_or_D = logic.disjoin((B), (D))
    notB_and_notD = logic.conjoin((notB), (notD))
    C_iff_B_or_D = C % B_or_D
    A_implies_notB_and_notD = A >> notB_and_notD
    B_and_notC = logic.conjoin((B), (notC))
    not_B_and_notC_implies_A = ~B_and_notC >> A
    notD_implies_C = notD >> C

    return logic.conjoin((C_iff_B_or_D), (A_implies_notB_and_notD),
                         (not_B_and_notC_implies_A), (notD_implies_C))
コード例 #4
0
def SLAMSensorAxioms(t, non_outer_wall_coords):
    all_percept_exprs = []
    combo_var_def_exprs = []
    for direction in DIRECTIONS:
        percept_exprs = []
        dx, dy = DIR_TO_DXDY_MAP[direction]
        for x, y in non_outer_wall_coords:
            combo_var = PropSymbolExpr(pacman_wall_str, x, y, t, x + dx,
                                       y + dy)
            percept_exprs.append(combo_var)
            combo_var_def_exprs.append(
                combo_var % (PropSymbolExpr(pacman_str, x, y, t)
                             & PropSymbolExpr(wall_str, x + dx, y + dy)))

        blocked_dir_clause = PropSymbolExpr(blocked_str_map[direction], t)
        all_percept_exprs.append(blocked_dir_clause % disjoin(percept_exprs))

    percept_to_blocked_sent = []
    for n in range(1, 4):
        wall_combos_size_n = itertools.combinations(blocked_str_map.values(),
                                                    n)
        n_walls_blocked_sent = disjoin([
            conjoin(
                [PropSymbolExpr(blocked_str, t) for blocked_str in wall_combo])
            for wall_combo in wall_combos_size_n
        ])
        # n_walls_blocked_sent is of form: (N & S) | (N & E) | ...
        percept_to_blocked_sent.append(
            PropSymbolExpr(geq_num_adj_wall_str_map[n], t) %
            n_walls_blocked_sent)

    return conjoin(all_percept_exprs + combo_var_def_exprs +
                   percept_to_blocked_sent)
コード例 #5
0
def mapping(problem, agent):
    '''
    problem: a MappingProblem instance
    agent: a MappingLogicAgent instance
    '''
    debug = False

    pac_x_0, pac_y_0 = problem.startState
    KB = []
    all_coords = list(
        itertools.product(range(problem.getWidth() + 2),
                          range(problem.getHeight() + 2)))
    non_outer_wall_coords = list(
        itertools.product(range(1,
                                problem.getWidth() + 1),
                          range(1,
                                problem.getHeight() + 1)))

    # map describes what we know, for GUI rendering purposes. -1 is unknown, 0 is open, 1 is wall
    known_map = [[-1 for y in range(problem.getHeight() + 2)]
                 for x in range(problem.getWidth() + 2)]
    known_map_by_timestep = []

    # Pacman knows that the outer border of squares are all walls
    outer_wall_sent = []
    for x, y in all_coords:
        if ((x == 0 or x == problem.getWidth() + 1)
                or (y == 0 or y == problem.getHeight() + 1)):
            known_map[x][y] = 1
            outer_wall_sent.append(PropSymbolExpr(wall_str, x, y))
    KB.append(conjoin(outer_wall_sent))
    KB.append(PropSymbolExpr(pacman_str, pac_x_0, pac_y_0, 0))

    for t in range(agent.num_timesteps):
        KB.append(pacphysics_axioms(t, all_coords, non_outer_wall_coords))
        KB.append(PropSymbolExpr(agent.actions[t], t))
        KB.append(sensorAxioms(t, non_outer_wall_coords))
        percept_rules = four_bit_percept_rules(t, agent.getPercepts())
        KB.append(percept_rules)

        for xy in non_outer_wall_coords:
            wall_present = PropSymbolExpr(wall_str, xy[0], xy[1])
            model1 = findModel(conjoin(conjoin(KB), wall_present))
            model2 = findModel(conjoin(conjoin(KB), ~wall_present))
            if model2 is False:
                known_map[xy[0]][xy[1]] = 1
                KB.append(wall_present)
            if model1 is False:
                known_map[xy[0]][xy[1]] = 0
                KB.append(~wall_present)
            if model1 and model2:
                known_map[xy[0]][xy[1]] = -1
        known_map_by_timestep.append(copy.deepcopy(known_map))

        agent.moveToNextState(agent.actions[t])
        KB.append(
            allLegalSuccessorAxioms(t + 1, known_map_by_timestep[t],
                                    non_outer_wall_coords))

    return known_map_by_timestep
コード例 #6
0
ファイル: logicPlan.py プロジェクト: jiffchan/cs188-sp21
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are ['North', 'East', 'South', 'West']
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    walls_list = walls.asList()
    x0, y0 = problem.startState
    xg, yg = problem.goal

    # Get lists of possible locations (i.e. without walls) and possible actions
    all_coords = list(itertools.product(range(width + 2), range(height + 2)))
    non_wall_coords = [loc for loc in all_coords if loc not in walls_list]
    actions = ['North', 'South', 'East', 'West']
    KB = []

    "*** BEGIN YOUR CODE HERE ***"
    KB.append(PropSymbolExpr(pacman_str, x0, y0, 0))
    for t in range(50):
        KB.append(
            exactlyOne([
                PropSymbolExpr(pacman_str, x, y, t) for x, y in non_wall_coords
            ]))
        model = findModel(
            conjoin(conjoin(KB), PropSymbolExpr(pacman_str, xg, yg, t)))
        if (model != False):
            return extractActionSequence(model, actions)
        KB.append(exactlyOne([PropSymbolExpr(action, t)
                              for action in actions]))
        KB.append(allLegalSuccessorAxioms(t + 1, walls, non_wall_coords))

    "*** END YOUR CODE HERE ***"
コード例 #7
0
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are ['North', 'East', 'South', 'West']
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    walls_list = walls.asList()
    x0, y0 = problem.startState
    xg, yg = problem.goal

    # Get lists of possible locations (i.e. without walls) and possible actions
    all_coords = list(itertools.product(range(width + 2), range(height + 2)))
    non_wall_coords = [loc for loc in all_coords if loc not in walls_list]
    actions = ['North', 'South', 'East', 'West']
    KB = []

    pos_t0 = PropSymbolExpr(pacman_str, x0, y0, 0)
    KB.append(pos_t0)

    for t in range(50):
        nonwallpos = [
            PropSymbolExpr(pacman_str, xy[0], xy[1], t)
            for xy in non_wall_coords
        ]
        KB.append(exactlyOne(nonwallpos))
        goal_assertion = PropSymbolExpr(pacman_str, xg, yg, t)
        model = findModel(conjoin(conjoin(KB), goal_assertion))
        if model:
            return extractActionSequence(model, actions)
        action_list = [PropSymbolExpr(action, t) for action in actions]
        KB.append(exactlyOne(action_list))
        for xy in non_wall_coords:
            KB.append(pacmanSuccessorStateAxioms(xy[0], xy[1], t + 1, walls))
コード例 #8
0
def pacmanSuccessorStateAxioms(x, y, t, walls_grid):
    """
    Successor state axiom for state (x,y,t) (from t-1), given the board (as a 
    grid representing the wall locations).
    Current <==> (previous position at time t-1) & (took action to move to x, y)
    """
    curPosition = logic.PropSymbolExpr(pacman_str, x, y, t)

    neighbors = []

    if not walls_grid[x + 1][y]:
        prevPosition = logic.PropSymbolExpr(pacman_str, x + 1, y, t - 1)
        action = logic.PropSymbolExpr('West', t - 1)
        neighbors.append(logic.conjoin(prevPosition, action))

    if not walls_grid[x - 1][y]:
        prevPosition = logic.PropSymbolExpr(pacman_str, x - 1, y, t - 1)
        action = logic.PropSymbolExpr('East', t - 1)
        neighbors.append(logic.conjoin(prevPosition, action))

    if not walls_grid[x][y + 1]:
        prevPosition = logic.PropSymbolExpr(pacman_str, x, y + 1, t - 1)
        action = logic.PropSymbolExpr('South', t - 1)
        neighbors.append(logic.conjoin(prevPosition, action))

    if not walls_grid[x][y - 1]:
        prevPosition = logic.PropSymbolExpr(pacman_str, x, y - 1, t - 1)
        action = logic.PropSymbolExpr('North', t - 1)
        neighbors.append(logic.conjoin(prevPosition, action))

    return curPosition % logic.disjoin(neighbors)
コード例 #9
0
def pacphysics_axioms(t, all_coords, non_outer_wall_coords):
    """
    Given:
        t: timestep
        all_coords: list of (x, y) coordinates of the entire problem
        non_outer_wall_coords: list of (x, y) coordinates of the entire problem,
            excluding the outer border (these are the actual squares pacman can
            possibly be in)
    Return a logic sentence containing all of the following:
        - for all (x, y) in all_coords:
            If a wall is at (x, y) --> Pacman is not at (x, y)
        - Pacman is at one of the non_outer_wall_coords.
        - Pacman is at exactly one of the squares at timestep t.
        - Pacman takes one of the four actions in DIRECTIONS
        - Pacman takes exactly one action at timestep t.
    """
    pacphysics_sentences = []

    "*** BEGIN YOUR CODE HERE ***"
    all_coords_elements = []
    for i in all_coords:
        x = i[0]
        y = i[1]
        all_coords_elements.append(PropSymbolExpr(wall_str, x, y) >> ~PropSymbolExpr(pacman_str, x, y ,t))

    first = conjoin(all_coords_elements)
    second = exactlyOne([PropSymbolExpr(pacman_str, i[0], i[1], t) for i in non_outer_wall_coords])
    third = exactlyOne([PropSymbolExpr(action, t) for action in DIRECTIONS])

    pacphysics_sentences.append(first)
    pacphysics_sentences.append(second)
    pacphysics_sentences.append(third)
    "*** END YOUR CODE HERE ***"

    return conjoin(pacphysics_sentences)
コード例 #10
0
def pacphysics_axioms(t, all_coords, non_outer_wall_coords):
    """
    Given:
        t: timestep
        all_coords: list of (x, y) coordinates of the entire problem
        non_outer_wall_coords: list of (x, y) coordinates of the entire problem,
            excluding the outer border (these are the actual squares pacman can
            possibly be in)
    Return a logic sentence containing all of the following:
        - for all (x, y) in all_coords:
            If a wall is at (x, y) --> Pacman is not at (x, y)
        - Pacman is at exactly one of the squares at timestep t.
        - Pacman takes exactly one action at timestep t.
    """
    pacphysics_sentences = []

    "*** BEGIN YOUR CODE HERE ***"
    for x, y in all_coords:
        s = PropSymbolExpr(wall_str, x,
                           y) >> ~PropSymbolExpr(pacman_str, x, y, t)
        pacphysics_sentences.append(s)
    inp_wall = []
    for x, y in non_outer_wall_coords:
        inp_wall.append(PropSymbolExpr(pacman_str, x, y, t))
    pacphysics_sentences.append(exactlyOne(inp_wall))
    inp_dir = []
    for dir in DIRECTIONS:
        inp_dir.append(PropSymbolExpr(dir, t))
    pacphysics_sentences.append(exactlyOne(inp_dir))
    return conjoin(pacphysics_sentences)
    "*** END YOUR CODE HERE ***"

    return conjoin(pacphysics_sentences)
コード例 #11
0
def ghostPositionSuccessorStateAxioms(x, y, t, ghost_num, walls_grid):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    GE is going east, ~GE is going west 
    """
    pos_str = ghost_pos_str + str(ghost_num)
    east_str = ghost_east_str + str(ghost_num)
    current = logic.PropSymbolExpr(pos_str, x, y, t)

    neighbors = []

    if walls_grid[x - 1][y] == False:
        prev_position = logic.PropSymbolExpr(pos_str, x - 1, y, t - 1)
        action = logic.PropSymbolExpr(east_str, t - 1)
        state = logic.conjoin(prev_position, action)
        neighbors.append(state)

    if walls_grid[x + 1][y] == False:
        prev_position = logic.PropSymbolExpr(pos_str, x + 1, y, t - 1)
        action = ~logic.PropSymbolExpr(east_str, t - 1)
        state = logic.conjoin(prev_position, action)
        neighbors.append(state)

    prev_states = atLeastOne(neighbors)
    if str(prev_states) == "FALSE":
        final_axiom = current % logic.PropSymbolExpr(pos_str, x, y, t - 1)
    else:
        final_axiom = current % prev_states
    return final_axiom
コード例 #12
0
ファイル: logicPlan.py プロジェクト: jxyoung/pacman
def ghostDirectionSuccessorStateAxioms(t, ghost_num, blocked_west_positions,
                                       blocked_east_positions):
    """
    Successor state axiom for patrolling ghost direction state (t) (from t-1).
    west or east walls.
    Current <==> (causes to stay) | (causes of current)
    """
    pos_str = ghost_pos_str + str(ghost_num)
    east_str = ghost_east_str + str(ghost_num)
    move = logic.PropSymbolExpr(east_str, t - 1)
    moveT = logic.PropSymbolExpr(east_str, t)
    west_not_block = []
    condition = []
    for position in blocked_west_positions:
        west_not_block += [
            ~logic.PropSymbolExpr(pos_str, position[0], position[1], t)
        ]
    west_not_block = logic.conjoin(west_not_block)
    east_not_block = []
    for position in blocked_east_positions:
        east_not_block += [
            ~logic.PropSymbolExpr(pos_str, position[0], position[1], t)
        ]
    east_not_block = logic.conjoin(east_not_block)
    if t == 0:
        return east_not_block % moveT
    return moveT % ((move & east_not_block) |
                    (~west_not_block & east_not_block) |
                    (~west_not_block & ~east_not_block & ~move))
コード例 #13
0
def sentence3():
    """Using the symbols WumpusAlive[1], WumpusAlive[0], WumpusBorn[0], and WumpusKilled[0],
    created using the logic.PropSymbolExpr constructor, return a logic.PropSymbolExpr
    instance that encodes the following English sentences (in this order):

    The Wumpus is alive at time 1 if and only if the Wumpus was alive at time 0 and it was
    not killed at time 0 or it was not alive and time 0 and it was born at time 0.

    The Wumpus cannot both be alive at time 0 and be born at time 0.

    The Wumpus is born at time 0.
    """
    "*** YOUR CODE HERE ***"
    #know the use of the PropSymbolExpr from logic.py
    Alive_1 = logic.PropSymbolExpr("WumpusAlive", 1)
    #print (Alive_1)
    Alive_0 = logic.PropSymbolExpr("WumpusAlive", 0)
    Born_0 = logic.PropSymbolExpr("WumpusBorn", 0)
    Killed_0 = logic.PropSymbolExpr("WumpusKilled", 0)
    One = Alive_1 % logic.disjoin(logic.conjoin(Alive_0, ~Killed_0),
                                  logic.conjoin(~Alive_0, Born_0))
    Two = ~logic.conjoin(Alive_0, Born_0)
    Three = Born_0
    return logic.conjoin(One, Two, Three)
    util.raiseNotDefined()
コード例 #14
0
def ghostPositionSuccessorStateAxioms(x, y, t, ghost_num, walls_grid):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    GE is going east, ~GE is going west 
    """
    pos_str = ghost_pos_str + str(ghost_num)
    east_str = ghost_east_str + str(ghost_num)

    "*** YOUR CODE HERE ***"

    left = walls_grid[x - 1][y]
    right = walls_grid[x + 1][y]

    possible_locations = []

    left_prev = logic.PropSymbolExpr(pos_str, x - 1, y, t - 1)
    right_prev = logic.PropSymbolExpr(pos_str, x + 1, y, t - 1)
    west_action = ~(logic.PropSymbolExpr(east_str, t - 1))
    east_action = logic.PropSymbolExpr(east_str, t - 1)

    if left and right:
        return logic.PropSymbolExpr(pos_str, x, y, t) % logic.PropSymbolExpr(
            pos_str, x, y, t - 1)

    if not left:
        possible_locations.append(logic.conjoin(left_prev, east_action))

    if not right:
        possible_locations.append(logic.conjoin(right_prev, west_action))

    return logic.PropSymbolExpr(pos_str, x, y,
                                t) % logic.disjoin(possible_locations)
コード例 #15
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def ghostPositionSuccessorStateAxioms(x, y, t, ghost_num, walls_grid):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    GE is going east, ~GE is going west 
    """
    pos_str = ghost_pos_str+str(ghost_num)
    east_str = ghost_east_str+str(ghost_num)

    pos = logic.PropSymbolExpr(pos_str, x, y, t)
    listAdj = [(x-1, y), (x+1, y)]
    lst = []
    for l in listAdj:
        if not walls_grid[l[0]][l[1]]:
            if l == (x-1, y):
                e = logic.conjoin([logic.PropSymbolExpr(pos_str, x-1, y, t-1), logic.PropSymbolExpr(east_str, t-1)]) 
            else:
                e = logic.conjoin([logic.PropSymbolExpr(pos_str, x+1, y, t-1), ~(logic.PropSymbolExpr(east_str, t-1))])
            lst.append(e)
    if walls_grid[x-1][y] & walls_grid[x+1][y]: #if there are walls on both sides and ghost cannot move
       lst.append(logic.PropSymbolExpr(pos_str, x, y, t-1))
    if (len(lst) == 0):
        return pos % pos
    r = logic.disjoin(lst)
    return pos % r
コード例 #16
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def ghostPositionSuccessorStateAxioms(x, y, t, ghost_num, walls_grid):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    GE is going east, ~GE is going west 
    """
    pos_str = ghost_pos_str+str(ghost_num)
    east_str = ghost_east_str+str(ghost_num)

    pos = logic.PropSymbolExpr(pos_str, x, y, t)
    listAdj = [(x-1, y), (x+1, y)]
    lst = []
    for l in listAdj:
        if not walls_grid[l[0]][l[1]]:
            if l == (x-1, y):
                e = logic.conjoin([logic.PropSymbolExpr(pacman_str, x-1, y, t-1), logic.PropSymbolExpr(east_str, t-1)])
            else:
                e = logic.conjoin([logic.PropSymbolExpr(pacman_str, x+1, y, t-1), ~(logic.PropSymbolExpr(east_str, t-1))])
            lst.append(e)
    if (len(lst) == 0):
        return pos % pos
    r = logic.disjoin(lst)
    return pos % r
    "*** YOUR CODE HERE ***"
    return logic.Expr('A') # Replace this with your expression
コード例 #17
0
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    MAX_TIME = 50
    start_pos = problem.getStartState()
    goal_pos = problem.getGoalState()
    actions = ['North', 'South', 'East', 'West']

    # pacman can only start at one position (with this and other constarin, there is no need to generate knowledge that pacman can not in two place at one time)
    start_one_list = []
    for x in range(1, width + 1):
        for y in range(1, height + 1):
            if (x, y) != start_pos:
                start_one_list.append(
                    ~logic.PropSymbolExpr(pacman_str, x, y, 0))

    start_one = logic.conjoin(start_one_list)

    #pacman start state
    start_state = logic.PropSymbolExpr(pacman_str, start_pos[0], start_pos[1],
                                       0)

    #pacman is in start_pos and not in any other position
    start = logic.conjoin(start_state, start_one)

    one_action_list = []
    transition_list = []
    #update knowledge base through time
    for t in range(1, MAX_TIME + 1):
        goal = logic.PropSymbolExpr(pacman_str, goal_pos[0], goal_pos[1], t)
        #can only take one action to get to current state
        temp = []
        for action in actions:
            one = logic.PropSymbolExpr(action, t - 1)
            temp.append(one)
        step_one_action = exactlyOne(temp)
        one_action_list.append(step_one_action)

        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if not walls[x][y]:
                    transition_list.append(
                        pacmanSuccessorStateAxioms(x, y, t, walls))

        one_action = logic.conjoin(one_action_list)
        one_action_list = [one_action]
        transition = logic.conjoin(transition_list)
        transition_list = [transition]

        result = findModel(logic.conjoin(start, one_action, transition, goal))

        if result is not False:
            return extractActionSequence(result, actions)
コード例 #18
0
def mapping(problem, agent):
    '''
    problem: a MappingProblem instance
    agent: a MappingLogicAgent instance
    '''
    debug = False

    pac_x_0, pac_y_0 = problem.startState
    KB = []
    all_coords = list(itertools.product(range(problem.getWidth()+2), range(problem.getHeight()+2)))
    non_outer_wall_coords = list(itertools.product(range(1, problem.getWidth()+1), range(1, problem.getHeight()+1)))

    #map describes what we know, for GUI rendering purposes. -1 is unknown, 0 is open, 1 is wall
    known_map = [[-1 for y in range(problem.getHeight()+2)] for x in range(problem.getWidth()+2)]
    known_map_by_timestep = []

    # Pacman knows that the outer border of squares are all walls
    outer_wall_sent = []
    for x, y in all_coords:
        if ((x == 0 or x == problem.getWidth() + 1)
                or (y == 0 or y == problem.getHeight() + 1)):
            known_map[x][y] = 1
            outer_wall_sent.append(PropSymbolExpr(wall_str, x, y))
    KB.append(conjoin(outer_wall_sent))

    "*** BEGIN YOUR CODE HERE ***"
    KB.append(PropSymbolExpr(pacman_str, pac_x_0, pac_y_0, 0))

    for t in range(agent.num_timesteps):
        # Add pacphysics, action, sensor, and percept information to KB
        KB.append(pacphysics_axioms(t, all_coords, non_outer_wall_coords))
        KB.append(PropSymbolExpr(agent.actions[t], t))
        KB.append(sensorAxioms(t, non_outer_wall_coords))
        KB.append(four_bit_percept_rules(t, agent.getPercepts()))

        # Find provable wall locations with updated KB
        for i in non_outer_wall_coords:
            x, y = i
            # find a model such that (x,y) is wall
            model1 = findModel(conjoin(KB) & PropSymbolExpr(wall_str, x, y))
            # find a model such that (x,y) is not wall
            model2 = findModel(conjoin(KB) & ~PropSymbolExpr(wall_str, x, y))

            if not model2:
                KB.append(PropSymbolExpr(wall_str, x, y))
                known_map[x][y] = 1
            elif not model1:
                KB.append(~PropSymbolExpr(wall_str, x, y))
                known_map[x][y] = 0
        map_copy = copy.deepcopy(known_map)
        known_map_by_timestep.append(map_copy)

        agent.moveToNextState(agent.actions[t])
        KB.append(allLegalSuccessorAxioms(t + 1, known_map, non_outer_wall_coords))

    "*** END YOUR CODE HERE ***"
    return known_map_by_timestep
コード例 #19
0
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are ['North', 'East', 'South', 'West']
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    walls_list = walls.asList()
    (x0, y0), food = problem.start
    food = food.asList()

    # Get lists of possible locations (i.e. without walls) and possible actions
    all_coords = list(itertools.product(range(width + 2), range(height + 2)))

    #locations = list(filter(lambda loc : loc not in walls_list, all_coords))
    non_wall_coords = [loc for loc in all_coords if loc not in walls_list]
    actions = ['North', 'South', 'East', 'West']

    KB = []

    "*** BEGIN YOUR CODE HERE ***"
    for x, y in food:
        KB.append(PropSymbolExpr(food_str, x, y, 0))

    KB.append(PropSymbolExpr(pacman_str, x0, y0, 0))

    for t in range(50):

        inp_wall = []
        for x, y in non_wall_coords:
            inp_wall.append(PropSymbolExpr(pacman_str, x, y, t))
        KB.append(exactlyOne(inp_wall))

        inp_food = []
        for x, y in food:
            inp_food.append(~PropSymbolExpr(food_str, x, y, t))
        food_goal = conjoin(inp_food)
        model = findModel(conjoin(KB) & food_goal)
        if model:
            return extractActionSequence(model, actions)

        inp_dir = []
        for dir in actions:
            inp_dir.append(PropSymbolExpr(dir, t))
        KB.append(exactlyOne(inp_dir))

        for x, y in non_wall_coords:
            KB.append(pacmanSuccessorStateAxioms(x, y, t + 1, walls))
        for x, y in food:
            expr = (PropSymbolExpr(pacman_str, x, y, t)
                    & PropSymbolExpr(food_str, x, y, t))
            expr2 = ~PropSymbolExpr(food_str, x, y, t + 1)
            KB.append(expr2 % expr | ~PropSymbolExpr(food_str, x, y, t))
    "*** END YOUR CODE HERE ***"
コード例 #20
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()

    "*** YOUR CODE HERE ***"
    initialState = problem.getStartState()

    foodGrid = initialState[1]

    
    (x, y) = initialState[0]
    initial = []
    initial.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
    foodLoc = []
    foodLoac = []
    for r in xrange(1,width+1):
        for c in xrange(1, height+1):
            if not walls[r][c] and ((r,c) != (x,y)):
                initial.append(~(logic.PropSymbolExpr(pacman_str, r,c,0)))
                if foodGrid[r][c]:
                    foodLoc.append(logic.PropSymbolExpr(pacman_str,r,c,0))
                    foodLoac.append((r,c))
    init = logic.conjoin(initial)

    lst = []
    for t in range(1,51):
        for r in xrange(1,width+1):
            for c in xrange(1, height+1):
                if not walls[r][c]:
                    lst.append(pacmanSuccessorStateAxioms(r, c, t, walls))

        d = []
        d.append(logic.PropSymbolExpr(game.Directions.NORTH,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.SOUTH,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.EAST,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.WEST,t-1))
        for food in foodLoac:
            foodLoc[foodLoac.index(food)] = foodLoc[foodLoac.index(food)] | logic.PropSymbolExpr(pacman_str,food[0],food[1],t)
        goalState = logic.conjoin(foodLoc)
        lst.append(exactlyOne(d))
        lisst = logic.conjoin(lst)
        result = lisst & init & goalState
        model = findModel(result)
        if model != False: 
            seq = extractActionSequence(model, [game.Directions.NORTH, game.Directions.SOUTH,game.Directions.EAST, game.Directions.WEST])
            return seq
   
               
    util.raiseNotDefined()
コード例 #21
0
def localization(problem, agent):
    '''
    problem: a LocalizationProblem instance
    agent: a LocalizationLogicAgent instance
    '''
    debug = False

    walls_grid = problem.walls
    walls_list = walls_grid.asList()
    all_coords = list(
        itertools.product(range(problem.getWidth() + 2),
                          range(problem.getHeight() + 2)))
    non_outer_wall_coords = list(
        itertools.product(range(1,
                                problem.getWidth() + 1),
                          range(1,
                                problem.getHeight() + 1)))
    possible_locs_by_timestep = []
    KB = []

    "*** BEGIN YOUR CODE HERE ***"
    for x, y in all_coords:
        if (x, y) in walls_list:
            KB.append(PropSymbolExpr(wall_str, x, y))
        else:
            KB.append(~PropSymbolExpr(wall_str, x, y))

    for t in range(agent.num_timesteps):
        KB.append(pacphysics_axioms(t, all_coords, non_outer_wall_coords))
        KB.append(PropSymbolExpr(agent.actions[t], t))
        KB.append(sensorAxioms(t, non_outer_wall_coords))

        percepts = agent.getPercepts()
        KB.append(four_bit_percept_rules(t, percepts))

        possible_locations_t = []
        for x, y in non_outer_wall_coords:
            res1 = findModel(
                conjoin(KB) & ~PropSymbolExpr(pacman_str, x, y, t))
            res2 = findModel(conjoin(KB) & PropSymbolExpr(pacman_str, x, y, t))
            if not res1:
                KB.append(PropSymbolExpr(pacman_str, x, y, t))
            elif not res2:
                KB.append(~PropSymbolExpr(pacman_str, x, y, t))
            if res2:
                possible_locations_t.append((x, y))

        possible_locs_by_timestep.append(possible_locations_t)
        agent.moveToNextState(agent.actions[t])
        KB.append(
            allLegalSuccessorAxioms(t + 1, walls_grid, non_outer_wall_coords))
    "*** END YOUR CODE HERE ***"
    print(possible_locs_by_timestep)
    return possible_locs_by_timestep
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    available_action = ['North', 'East', 'South', 'West'] # evacuate STOP
    "*** YOUR CODE HERE ***"
    # get start/goal loaction
    start = problem.getStartState()
    goal = problem.getGoalState()

    start_state = logic.PropSymbolExpr("P", start[0], start[1], 0)
    start_logic = []
    for i in range(1, width+1):
        for j in range(1, height+1):
            start_logic.append(logic.PropSymbolExpr("P", i, j, 0))
    start_logic = exactlyOne(start_logic)
    start_logic = logic.conjoin(start_logic, start_state)
    # note that we must assert any other position is not allowed, otherwise it will cause weird error

    t = 1 # initial time
    # note that time start from 1 but not 0
    path = False

    while not path:
        # goal state
        goal_state = logic.PropSymbolExpr("P", goal[0], goal[1], t+1)
        # build succession logic
        successor = []
        for k in range(1, t+2): # note here must be t+2
            for i in range(1, width + 1): # skip the most-outside wall
                for j in range(1, height + 1):
                    if not walls[i][j]: # if (x, y) is not a wall
                        successor.append(pacmanSuccessorStateAxioms(i, j, k, walls))
        successor = logic.conjoin(successor)

        action_taken = []
        for i in range(0, t + 1):# last one is t
            all_action = []
            for action in available_action:
                all_action += [logic.PropSymbolExpr(action, i)]
            # one step must take exactly one action
            action_taken.append(exactlyOne(all_action))
        # each step must take action
        each_step_action = logic.conjoin(action_taken)
        # assemble model
        model = logic.conjoin(start_logic, goal_state, each_step_action, successor)
        path = findModel(model) 
        # complicated init state & goal state & way to achieve goal & all possible action can be taken & all possible successors to any point 
        t += 1
    return extractActionSequence(path, available_action)
コード例 #23
0
def pacphysics_axioms(t, all_coords, non_outer_wall_coords):
    """
    Given:
        t: timestep
        all_coords: list of (x, y) coordinates of the entire problem
        non_outer_wall_coords: list of (x, y) coordinates of the entire problem,
            excluding the outer border (these are the actual squares pacman can
            possibly be in)
    Return a logic sentence containing all of the following:
        - for all (x, y) in all_coords:
            If a wall is at (x, y) --> Pacman is not at (x, y)
        - Pacman is at one of the non_outer_wall_coords.
        - Pacman is at exactly one of the squares at timestep t.
        - Pacman takes one of the four actions in DIRECTIONS
        - Pacman takes exactly one action at timestep t.
    """
    pacphysics_sentences = []

    "*** BEGIN YOUR CODE HERE ***"
    #Pacman at x,y at time t:
    #PropSymbolExpr(pacman_str, x, y, t)
    #Whether or not a wall is at x,y
    #PropSymbolExpr(wall_str, x, y)
    #Whether or not pacman takes action a at time t
    #PropSymbolExpr(action, t)

    #if a wall at x,y >> pacman not at x,y
    implications = []
    for (x, y) in all_coords:
        implications.append(
            PropSymbolExpr(wall_str, x, y) >>
            ~PropSymbolExpr(pacman_str, x, y, t))

    pacphysics_sentences.append(conjoin(implications))
    #pacman is at exactly one of the non_outer_wall_coords
    props = []
    for (x, y) in non_outer_wall_coords:
        props.append(PropSymbolExpr(pacman_str, x, y, t))
    is_somewhere = exactlyOne(props)
    pacphysics_sentences.append(is_somewhere)

    #Pacman takes exactly one of four directions
    one_direction = exactlyOne([
        PropSymbolExpr('North', t),
        PropSymbolExpr('South', t),
        PropSymbolExpr('East', t),
        PropSymbolExpr('West', t)
    ])
    pacphysics_sentences.append(one_direction)

    "*** END YOUR CODE HERE ***"

    return conjoin(pacphysics_sentences)
コード例 #24
0
ファイル: logicPlan.py プロジェクト: jxyoung/pacman
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    food = problem.startingGameState.getFood()
    startState = problem.getStartState()
    expr1 = [
        logic.PropSymbolExpr(pacman_str, startState[0][0], startState[0][1], 0)
    ]
    expr2 = []
    for i in xrange(1, width + 1):
        for j in xrange(1, height + 1):
            if (i, j) != (startState[0]):
                expr1 += [~logic.PropSymbolExpr(pacman_str, i, j, 0)]
    for m in xrange(0, 51):
        for i in xrange(1, width + 1):
            for j in xrange(1, height + 1):
                if m > 0:
                    if not walls[i][j]:
                        expr1 += [pacmanSuccessorStateAxioms(i, j, m, walls)]

        if m > 0:
            expr3 = []
            expr3 += [logic.PropSymbolExpr('North', m - 1)]
            expr3 += [logic.PropSymbolExpr('South', m - 1)]
            expr3 += [logic.PropSymbolExpr('West', m - 1)]
            expr3 += [logic.PropSymbolExpr('East', m - 1)]
            expr2 += [exactlyOne(expr3)]

        finalState = []
        for i in xrange(1, width + 1):
            for j in xrange(1, height + 1):
                if food[i][j]:
                    aux = []
                    for k in xrange(0, m + 1):
                        aux += [logic.PropSymbolExpr(pacman_str, i, j, k)]
                    finalState += [logic.disjoin(aux)]
        auxx = expr1 + expr2 + [logic.conjoin(finalState)]
        cnf = logic.to_cnf(logic.conjoin(auxx))
        model = findModel(cnf)
        if (model != False):
            return extractActionSequence(model,
                                         ['West', 'South', 'North', 'East'])
    return False

    "*** YOUR CODE HERE ***"
    util.raiseNotDefined()
コード例 #25
0
def pacmanSLAMSuccessorStateAxioms(x, y, t, walls_grid, var_str=pacman_str):
    """
    Similar to `pacmanSuccessorStateAxioms` but accounts for illegal actions
    where the pacman might not move timestep to timestep.
    Available actions are ['North', 'East', 'South', 'West']
    """
    moved_tm1_possibilities = []
    if not walls_grid[x][y + 1]:
        moved_tm1_possibilities.append(
            PropSymbolExpr(var_str, x, y + 1, t - 1)
            & PropSymbolExpr('South', t - 1))
    if not walls_grid[x][y - 1]:
        moved_tm1_possibilities.append(
            PropSymbolExpr(var_str, x, y - 1, t - 1)
            & PropSymbolExpr('North', t - 1))
    if not walls_grid[x + 1][y]:
        moved_tm1_possibilities.append(
            PropSymbolExpr(var_str, x + 1, y, t - 1)
            & PropSymbolExpr('West', t - 1))
    if not walls_grid[x - 1][y]:
        moved_tm1_possibilities.append(
            PropSymbolExpr(var_str, x - 1, y, t - 1)
            & PropSymbolExpr('East', t - 1))

    if not moved_tm1_possibilities:
        return None

    moved_tm1_sent = conjoin([
        ~PropSymbolExpr(var_str, x, y, t - 1), ~PropSymbolExpr(wall_str, x, y),
        disjoin(moved_tm1_possibilities)
    ])

    unmoved_tm1_possibilities_aux_exprs = []  # merged variables
    aux_expr_defs = []
    for direction in DIRECTIONS:
        dx, dy = DIR_TO_DXDY_MAP[direction]
        wall_dir_clause = PropSymbolExpr(
            wall_str, x + dx, y + dy) & PropSymbolExpr(direction, t - 1)
        wall_dir_combined_literal = PropSymbolExpr(wall_str + direction,
                                                   x + dx, y + dy, t - 1)
        unmoved_tm1_possibilities_aux_exprs.append(wall_dir_combined_literal)
        aux_expr_defs.append(wall_dir_combined_literal % wall_dir_clause)

    unmoved_tm1_sent = conjoin([
        PropSymbolExpr(var_str, x, y, t - 1),
        disjoin(unmoved_tm1_possibilities_aux_exprs)
    ])

    return conjoin([
        PropSymbolExpr(var_str, x, y, t) %
        disjoin([moved_tm1_sent, unmoved_tm1_sent])
    ] + aux_expr_defs)
コード例 #26
0
def sentence2():
    """Returns a Expr instance that encodes that the following expressions are all true.
    
    C if and only if (B or D)
    A implies ((not B) and (not D))
    (not (B and (not C))) implies A
    (not D) implies C
    """
    s1 = C % disjoin(B, D)
    s2 = A >> conjoin(~B, ~D)
    s3 = ~conjoin(B, ~C) >> A
    s4 = ~D >> C
    return conjoin(s1, s2, s3, s4)
コード例 #27
0
def localization(problem, agent):
    '''
    problem: a LocalizationProblem instance
    agent: a LocalizationLogicAgent instance
    '''
    debug = False

    walls_grid = problem.walls
    walls_list = walls_grid.asList()
    all_coords = list(
        itertools.product(range(problem.getWidth() + 2),
                          range(problem.getHeight() + 2)))
    non_outer_wall_coords = list(
        itertools.product(range(1,
                                problem.getWidth() + 1),
                          range(1,
                                problem.getHeight() + 1)))

    possible_locs_by_timestep = []
    KB = []
    for xy in all_coords:
        if xy in walls_list:
            KB.append(PropSymbolExpr(wall_str, xy[0], xy[1]))
        else:
            KB.append(~PropSymbolExpr(wall_str, xy[0], xy[1]))

    for t in range(agent.num_timesteps):
        KB.append(pacphysics_axioms(t, all_coords, non_outer_wall_coords))
        KB.append(PropSymbolExpr(agent.actions[t], t))
        KB.append(sensorAxioms(t, non_outer_wall_coords))
        percept_rules = four_bit_percept_rules(t, agent.getPercepts())
        KB.append(percept_rules)

        possible_locations_t = []
        for xy in non_outer_wall_coords:
            pacman_present = PropSymbolExpr(pacman_str, xy[0], xy[1], t)
            model1 = findModel(conjoin(conjoin(KB), pacman_present))
            model2 = findModel(conjoin(conjoin(KB), ~pacman_present))
            if model2 is False:
                possible_locations_t.append(xy)
                KB.append(pacman_present)
            if model1 is False:
                KB.append(~pacman_present)
            if model1 and model2:
                possible_locations_t.append(xy)
        possible_locs_by_timestep.append(possible_locations_t)
        agent.moveToNextState(agent.actions[t])
        KB.append(
            allLegalSuccessorAxioms(t + 1, walls_grid, non_outer_wall_coords))

    return possible_locs_by_timestep
コード例 #28
0
ファイル: logicPlan.py プロジェクト: yyqjshcn/CS181_19fall
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()

    "*** YOUR CODE HERE ***"
    actions = ['North', 'South', 'East', 'West']
    startState = []
    initialX, initialY = problem.getStartState()
    initial = logic.PropSymbolExpr(pacman_str, initialX, initialY, 0)
    goalX, goalY = problem.getGoalState()
    goalSuccessors = []
    goalActions = []

    steps = 50
    for x in range(1, width + 1):
        for y in range(1, height + 1):
            if not (x, y) in walls.asList():
                startState.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
    for i in range(1, steps):
        successors = []
        start = exactlyOne(startState)  # needed for goal
        goal = logic.PropSymbolExpr(pacman_str, goalX, goalY, i)
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if (x, y) not in walls.asList():
                    successors.append(
                        pacmanSuccessorStateAxioms(x, y, i, walls))
        successor = logic.conjoin(successors)
        action = []
        for a in actions:
            action.append(logic.PropSymbolExpr(a, i - 1))
        goalActions.append(exactlyOne(action))
        goalSuccessors.append(successor)
        # print("start: ", start)
        # print("initial: ", initial)
        # print("goal: ", goal)
        # print("goalActions: ", goalActions)
        # print("goalSuccessors: ", goalSuccessors)
        isGoal = findModel(
            logic.conjoin([
                start, initial, goal,
                logic.conjoin(goalSuccessors),
                logic.conjoin(goalActions)
            ]))
        if isGoal:
            return extractActionSequence(isGoal, actions)
コード例 #29
0
def check_location_satisfiability(x1_y1, x0_y0, action0, action1, problem):
    """
    Given:
        - x1_y1 = (x1, y1), a potential location at time t = 1
        - x0_y0 = (x0, y0), Pacman's location at time t = 0
        - action0 = one of the four items in DIRECTIONS, Pacman's action at time t = 0
        - problem = An instance of logicAgents.LocMapProblem
    Return:
        - a model proving whether Pacman is at (x1, y1) at time t = 1
        - a model proving whether Pacman is not at (x1, y1) at time t = 1
    """
    walls_grid = problem.walls
    walls_list = walls_grid.asList()
    all_coords = list(
        itertools.product(range(problem.getWidth() + 2),
                          range(problem.getHeight() + 2)))
    non_outer_wall_coords = list(
        itertools.product(range(1,
                                problem.getWidth() + 1),
                          range(1,
                                problem.getHeight() + 1)))
    KB = []
    x0, y0 = x0_y0
    x1, y1 = x1_y1

    # We know which coords are walls:
    map_sent = [PropSymbolExpr(wall_str, x, y) for x, y in walls_list]
    KB.append(conjoin(map_sent))

    pos_t0 = PropSymbolExpr(pacman_str, x0, y0, 0)
    axioms_t0 = pacphysics_axioms(0, all_coords, non_outer_wall_coords)
    action_t0 = PropSymbolExpr(action0, 0)
    legal_axioms_t0 = allLegalSuccessorAxioms(1, walls_grid,
                                              non_outer_wall_coords)

    axioms_t1 = pacphysics_axioms(1, all_coords, non_outer_wall_coords)
    action_t1 = PropSymbolExpr(action1, 1)

    KB.append(pos_t0)
    KB.append(axioms_t0)
    KB.append(action_t0)
    KB.append(legal_axioms_t0)
    KB.append(axioms_t1)
    KB.append(action_t1)

    model1 = findModel(
        conjoin(conjoin(KB), PropSymbolExpr(pacman_str, x1, y1, 1)))
    model2 = findModel(
        conjoin(conjoin(KB), ~PropSymbolExpr(pacman_str, x1, y1, 1)))

    return model2, model1
コード例 #30
0
def localization(problem, agent):
    '''
    problem: a LocalizationProblem instance
    agent: a LocalizationLogicAgent instance
    '''
    debug = False

    walls_grid = problem.walls
    walls_list = walls_grid.asList()
    all_coords = list(itertools.product(range(problem.getWidth()+2), range(problem.getHeight()+2)))
    non_outer_wall_coords = list(itertools.product(range(1, problem.getWidth()+1), range(1, problem.getHeight()+1)))

    possible_locs_by_timestep = []
    KB = []

    "*** BEGIN YOUR CODE HERE ***"
    for i in all_coords:
        if i in walls_list:
            KB.append(PropSymbolExpr(wall_str, i[0], i[1]))
        else:
            KB.append(~PropSymbolExpr(wall_str, i[0], i[1]))

    for t in range(agent.num_timesteps):
        # Add pacphysics, action, sensor, and percept information to KB
        KB.append(pacphysics_axioms(t, all_coords, non_outer_wall_coords))
        KB.append(PropSymbolExpr(agent.actions[t], t))
        KB.append(sensorAxioms(t, non_outer_wall_coords))
        KB.append(four_bit_percept_rules(t, agent.getPercepts()))

        #Find possible pacman locations with updated KB
        possible_locations_t = []
        for i in non_outer_wall_coords:
            model1 = findModel(conjoin(KB) & PropSymbolExpr(pacman_str, i[0], i[1], t))
            model2 = findModel(conjoin(KB) & ~PropSymbolExpr(pacman_str, i[0], i[1], t))
            if model1:
                possible_locations_t.append(i)
            elif not model2:
                KB.append(~PropSymbolExpr(pacman_str, i[0], i[1], t))
            elif not model1:
                KB.append(~PropSymbolExpr(pacman_str, i[0], i[1], t))
        possible_locs_by_timestep.append(possible_locations_t)

        agent.moveToNextState(agent.actions[t])
        KB.append(allLegalSuccessorAxioms(t + 1, walls_grid, non_outer_wall_coords))

    return possible_locs_by_timestep

    #print(KB)

    "*** END YOUR CODE HERE ***"
    return possible_locs_by_timestep
コード例 #31
0
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    actions = ['North', 'South', 'East', 'West']
    x, y = problem.startState
    t = 0
    final_expression = p_0 = logic.PropSymbolExpr(pacman_str, problem.startState[0], problem.startState[1], 0)
    initial_state = ([], [p_0], x, y, t)
    states = [initial_state]
    visited = []
    while len(states) > 0:
        state = states.pop(0)
        sentence, path, x, y, t = state[0], state[1], state[2], state[3], state[4]
        if not findModel(logic.conjoin(sentence + path)):
            continue
        if state != initial_state and (x, y) == problem.goal and findModel(logic.conjoin(sentence + path)):
            final_expression = logic.conjoin(sentence + path)
            break
        else:
            if (x, y) not in visited and not walls[x][y]:
                visited.append((x, y))
            if (x - 1, y) not in visited and not walls[x - 1][y]:
                tmp = logic.PropSymbolExpr(pacman_str, x - 1, y, t + 1) % (
                    logic.PropSymbolExpr('West', t) & logic.PropSymbolExpr(pacman_str, x, y, t))
                states.append(
                    ([tmp] + sentence, [logic.PropSymbolExpr(pacman_str, x - 1, y, t + 1)] + path, x - 1, y, t + 1))

            if (x + 1, y) not in visited and not walls[x + 1][y]:
                tmp = logic.PropSymbolExpr(pacman_str, x + 1, y, t + 1) % (
                    logic.PropSymbolExpr('East', t) & logic.PropSymbolExpr(pacman_str, x, y, t))
                states.append(
                    ([tmp] + sentence, [logic.PropSymbolExpr(pacman_str, x + 1, y, t + 1)] + path, x + 1, y, t + 1))
            if (x, y - 1) not in visited and not walls[x][y - 1]:
                tmp = logic.PropSymbolExpr(pacman_str, x, y - 1, t + 1) % (
                    logic.PropSymbolExpr('South', t) & logic.PropSymbolExpr(pacman_str, x, y, t))
                states.append(
                    ([tmp] + sentence, [logic.PropSymbolExpr(pacman_str, x, y - 1, t + 1)] + path, x, y - 1, t + 1))

            if (x, y + 1) not in visited and not walls[x][y + 1]:
                tmp = logic.PropSymbolExpr(pacman_str, x, y + 1, t + 1) % (
                    logic.PropSymbolExpr('North', t) & logic.PropSymbolExpr(pacman_str, x, y, t))
                states.append(
                    ([tmp] + sentence, [logic.PropSymbolExpr(pacman_str, x, y + 1, t + 1)] + path, x, y + 1, t + 1))

    return extractActionSequence(findModel(final_expression), actions)
コード例 #32
0
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are ['North', 'East', 'South', 'West']
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    walls_list = walls.asList()
    (x0, y0), food = problem.start
    food = food.asList()

    # Get lists of possible locations (i.e. without walls) and possible actions
    all_coords = list(itertools.product(range(width + 2), range(height + 2)))

    #locations = list(filter(lambda loc : loc not in walls_list, all_coords))
    non_wall_coords = [loc for loc in all_coords if loc not in walls_list]
    actions = [ 'North', 'South', 'East', 'West' ]

    KB = []

    "*** BEGIN YOUR CODE HERE ***"
    KB.append(PropSymbolExpr(pacman_str, x0, y0, 0))

    for i in food:
        expression = PropSymbolExpr(food_str, i[0], i[1], 0)
        KB.append(expression)

    for t in range(50):
        goal_check = conjoin([~PropSymbolExpr(food_str, f[0], f[1], t) for f in food])
        KB.append(exactlyOne([PropSymbolExpr(pacman_str, i[0], i[1], t) for i in non_wall_coords]))
        model = findModel(conjoin(KB) & goal_check)

        if model is not False:
            return extractActionSequence(model, actions)

        KB.append(exactlyOne([PropSymbolExpr(action, t) for action in actions]))
        for i in non_wall_coords:
            KB.append(pacmanSuccessorStateAxioms(i[0], i[1], t + 1, walls))

        for f in food:
            KB.append(PropSymbolExpr(food_str, f[0], f[1], t + 1) % (~PropSymbolExpr(pacman_str, f[0], f[1], t) &
                                                                      PropSymbolExpr(food_str, f[0], f[1], t)))


    return None
    "*** END YOUR CODE HERE ***"
コード例 #33
0
def pacmanAliveSuccessorStateAxioms(x, y, t, num_ghosts):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    """
    ghost_strs = [
        ghost_pos_str + str(ghost_num) for ghost_num in xrange(num_ghosts)
    ]
    current = logic.PropSymbolExpr(pacman_str, x, y, t)
    ghosts = ghost_strs[:]
    neighbors = []

    k = []
    l = []
    while num_ghosts != 0:
        k += [
            logic.PropSymbolExpr(ghost_strs[num_ghosts - 1], x, y, t - 1)
            | logic.PropSymbolExpr(ghost_strs[num_ghosts - 1], x, y, t)
        ]
        num_ghosts -= 1
    m = ~logic.PropSymbolExpr(pacman_alive_str, t - 1)

    prev_states = logic.disjoin(k)
    prev_states = logic.conjoin(logic.PropSymbolExpr(pacman_str, x, y, t),
                                prev_states) | m
    final_axiom = ~logic.PropSymbolExpr(pacman_alive_str, t) % prev_states
    return final_axiom
コード例 #34
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def exactlyOne(literals) :
    """
    Given a list of logic.Expr literals, return a single logic.Expr instance in 
    CNF (conjunctive normal form)that represents the logic that exactly one of 
    the expressions in the list is true.
    """
    "*** YOUR CODE HERE ***"
    return logic.conjoin(atLeastOne(literals), atMostOne(literals))
コード例 #35
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def sentence2():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    C if and only if (B or D)
    A implies ((not B) and (not D))
    (not (B and (not C))) implies A
    (not D) implies C
    """
    "*** YOUR CODE HERE ***"
    A, B, C, D = logic.Expr('A'), logic.Expr('B'), logic.Expr('C'), logic.Expr('D')
    C_iff = C % logic.disjoin([B,D])
    A_imp = A >> logic.conjoin([~B, ~D])
    nots = ~(logic.conjoin([B, ~C])) >> A
    notD = ~D >> C

    return logic.conjoin([C_iff, A_imp, nots, notD])
    util.raiseNotDefined()
コード例 #36
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def exactlyOne(literals) :
    """
    Given a list of logic.Expr literals, return a single logic.Expr instance in 
    CNF (conjunctive normal form)that represents the logic that exactly one of 
    the expressions in the list is true.
    """
    if len(literals) == 1:
        return literals[0]
    return logic.conjoin([logic.disjoin(literals),atMostOne(literals)])
コード例 #37
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def pacmanAliveSuccessorStateAxioms(x, y, t, num_ghosts):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    """
    ghost_strs = [ghost_pos_str+str(ghost_num) for ghost_num in xrange(num_ghosts)]

    alive = logic.PropSymbolExpr(pacman_alive_str, t)
    lst = []
    e = []
    for g in ghost_strs:
        e.append(~logic.PropSymbolExpr(g, x, y, t-1))
        e.append(~logic.PropSymbolExpr(g, x, y, t))
    q = logic.conjoin(e)
    lst.append(q)
    lst.append(~logic.PropSymbolExpr(pacman_str, x, y, t))
    res = logic.disjoin(lst)
    if len(lst) == 0:
        return alive % alive 
    return alive % (logic.conjoin([logic.PropSymbolExpr(pacman_alive_str, t-1), res]))
コード例 #38
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def sentence1():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    A or B
    (not A) if and only if ((not B) or C)
    (not A) or (not B) or C
    """
    "*** YOUR CODE HERE ***"
    A, B, C = logic.Expr('A'), logic.Expr('B'), logic.Expr('C')
    line1, line2, line3 = A | B, ~A % (~B | C), logic.disjoin(~A, ~B, C)
    return logic.conjoin(line1, line2, line3)
コード例 #39
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def sentence2():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    C if and only if (B or D)
    A implies ((not B) and (not D))
    (not (B and (not C))) implies A
    (not D) implies C
    """
    "*** YOUR CODE HERE ***"
    A, B, C, D = logic.Expr('A'), logic.Expr('B'), logic.Expr('C'), logic.Expr('D')
    line1, line2, line3, line4 = C % (B | D), A >> (~B & ~D), ~(B & ~C) >> A, ~D >> C
    return logic.conjoin(line1, line2, line3, line4)
コード例 #40
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    
    "*** YOUR CODE HERE ***"
    (x, y) = problem.getStartState();
    (v, w) = problem.getGoalState();
    initial = []
    initial.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
    for r in xrange(1,width+1):
        for c in xrange(1, height+1):
            if not walls[r][c] and ((r,c) != (x,y)):
                initial.append(~(logic.PropSymbolExpr(pacman_str, r,c,0)))

    init = logic.conjoin(initial)

    lst = []
    for t in range(1,51):
        for r in xrange(1,width+1):
            for c in xrange(1, height+1):
                if not walls[r][c]:
                    lst.append(pacmanSuccessorStateAxioms(r, c, t, walls))

        d = []
        d.append(logic.PropSymbolExpr(game.Directions.NORTH,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.SOUTH,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.EAST,t-1))
        d.append(logic.PropSymbolExpr(game.Directions.WEST,t-1))
        lst.append(exactlyOne(d))
        lisst = logic.conjoin(lst)
        result = lisst & logic.PropSymbolExpr(pacman_str, v, w, t) & init
        model = findModel(result)
        if model != False: 
            seq = extractActionSequence(model, [game.Directions.NORTH, game.Directions.SOUTH,game.Directions.EAST, game.Directions.WEST])
            return seq
コード例 #41
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def atMostOne(literals) :
    """
    Given a list of logic.Expr literals, return a single logic.Expr instance in 
    CNF (conjunctive normal form) that represents the logic that at most one of 
    the expressions in the list is true.
    """
    notliterals = [~literal for literal in literals]
    clauses = []
    for i in range(0,len(literals)-1):
        for j in range(i+1, len(literals)):
            clause = [notliterals[i]] + [notliterals[j]]
            clauses.append(logic.disjoin(clause))
    return logic.conjoin(clauses)
コード例 #42
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def sentence1():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    A or B
    (not A) if and only if ((not B) or C)
    (not A) or (not B) or C
    """
    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    expr1 = A | B
    expr2 = (~A) % ((~B)|C)
    expr3 = logic.disjoin([~A,~B,C])
    return logic.conjoin([expr1,expr2,expr3])
コード例 #43
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()

    "*** YOUR CODE HERE ***"
    kb = []
    actions = ['North', 'South', 'East', 'West']
    start = problem.getStartState()[0]
    food = problem.getStartState()[1]
    
    for x in range(1, width + 1):
        for y in range(1, height + 1):
            if (x, y) == start:
                kb.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
            else:
                kb.append(~logic.PropSymbolExpr(pacman_str, x, y, 0))

    for t in range(50):
        
        lst = []
        for a in actions:
            lst.append(logic.PropSymbolExpr(a, t)) 
        kb.append(exactlyOne(lst))
        #print(kb)
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                kb.append(pacmanSuccessorStateAxioms(x, y, t + 1, walls))

        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if food[x][y]:
                    lst = []
                    for t in range(t + 1):
                        lst.append(logic.PropSymbolExpr(pacman_str, x, y, t))
                    kb.append(atLeastOne(lst))

        model = findModel(logic.conjoin(kb))
        if model:
            return extractActionSequence(model, actions)

        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if food[x][y]:
                    kb.pop()
コード例 #44
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def foodLogicPlan(problem):
    """
    Given an instance of a FoodPlanningProblem, return a list of actions that help Pacman
    eat all of the food.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    start, foodGrid = problem.getStartState()[0],problem.getStartState()[1]
    start_axiom = [logic.PropSymbolExpr(pacman_str,start[0],start[1],0)]
    for x in range(1,width+1):
        for y in range(1,height+1):
            if not walls[x][y] and (x != start[0] or y != start[1]):
                start_axiom.append(~logic.PropSymbolExpr(pacman_str,x,y,0))
    start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',0), 
                                logic.PropSymbolExpr('West',0),
                                logic.PropSymbolExpr('South',0),
                                logic.PropSymbolExpr('North',0)]))
    for t in range(1,51):
        start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',t), 
                            logic.PropSymbolExpr('West',t),
                            logic.PropSymbolExpr('South',t),
                            logic.PropSymbolExpr('North',t)]))
        position_t = []
        move_t = []
        for x in range(1,width+1):
            for y in range(1,height+1):
                if not walls[x][y]:
                    move_t.append(pacmanSuccessorStateAxioms(x,y,t,walls))
        start_axiom += move_t

        pops = 0
        for x in range(1,width+1):
            for y in range(1,height+1):
                visit = []
                if foodGrid[x][y]:
                    for i in range(1,t+1):
                        visit.append(logic.PropSymbolExpr(pacman_str,x,y,i))
                    start_axiom.append(atLeastOne(visit))
                    pops += 1

        model = logic.pycoSAT(logic.conjoin(start_axiom))
        if model:
            directions = [game.Directions.NORTH,game.Directions.SOUTH,game.Directions.EAST,game.Directions.WEST]
            actions = extractActionSequence(model, directions)
            return actions
        for i in range(0,pops):
            start_axiom.pop()
コード例 #45
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def atMostOne(literals) :
    """
    Given a list of logic.Expr literals, return a single logic.Expr instance in 
    CNF (conjunctive normal form) that represents the logic that at most one of 
    the expressions in the list is true.
    """
    "*** YOUR CODE HERE ***"
    lst = []
    for i in range(len(literals)):
        for j in range(len(literals)):
            if i != j:
                l1, l2 = ~literals[i] | ~literals[j], ~literals[j] | ~literals[i] 
                if l1 not in lst and l2 not in lst:
                    lst.append(l1)
    return logic.conjoin(lst)
コード例 #46
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def atMostOne(literals) :
    """
    Given a list of logic.Expr literals, return a single logic.Expr instance in 
    CNF (conjunctive normal form) that represents the logic that at most one of 
    the expressions in the list is true.
    """
    "*** YOUR CODE HERE ***"

    allComp = []
    for l in literals:
        for i in literals[literals.index(l)+1:]:
            allComp.append(~l | ~i)
    return logic.conjoin(allComp)


    util.raiseNotDefined()
コード例 #47
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def sentence3():
    """Using the symbols WumpusAlive[1], WumpusAlive[0], WumpusBorn[0], and WumpusKilled[0],
    created using the logic.PropSymbolExpr constructor, return a logic.PropSymbolExpr
    instance that encodes the following English sentences (in this order):

    The Wumpus is alive at time 1 if and only if the Wumpus was alive at time 0 and it was
    not killed at time 0 or it was not alive and time 0 and it was born at time 0.

    The Wumpus cannot both be alive at time 0 and be born at time 0.

    The Wumpus is born at time 0.
    """
    "*** YOUR CODE HERE ***"
    line1 = logic.PropSymbolExpr("WumpusAlive", 1) % ((logic.PropSymbolExpr("WumpusAlive", 0) & ~logic.PropSymbolExpr("WumpusKilled", 0)) | (~logic.PropSymbolExpr("WumpusAlive", 0) & logic.PropSymbolExpr("WumpusBorn", 0)))
    line2 = ~(logic.PropSymbolExpr("WumpusAlive", 0) & logic.PropSymbolExpr("WumpusBorn", 0))
    line3 = logic.PropSymbolExpr("WumpusBorn", 0)
    return logic.conjoin(line1, line2, line3)
コード例 #48
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def sentence2():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    C if and only if (B or D)
    A implies ((not B) and (not D))
    (not (B and (not C))) implies A
    (not D) implies C
    """
    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    D = logic.Expr('D')
    expr1 = C % (B | D)
    expr2 = A >> ((~B)&(~D))
    expr3 = (~(B&(~C))) >> A
    expr4 = (~D) >> C
    return logic.conjoin([expr1,expr2,expr3,expr4])
コード例 #49
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def sentence1():
    """Returns a logic.Expr instance that encodes that the following expressions are all true.
    
    A or B
    (not A) if and only if ((not B) or C)
    (not A) or (not B) or C
    """
    "*** YOUR CODE HERE ***"
    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    a_or_b = A | B
    notA, notB = ~A, ~B
    notB_or_C = notB | C
    notA_iff = notA % notB_or_C
    notA_or_else = logic.disjoin([notA,notB,C])

    return logic.conjoin([(a_or_b),(notA_iff),(notA_or_else)])

    util.raiseNotDefined()
コード例 #50
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def pacmanAliveSuccessorStateAxioms(x, y, t, num_ghosts):
    """
    Successor state axiom for patrolling ghost state (x,y,t) (from t-1).
    Current <==> (causes to stay) | (causes of current)
    """
    ghost_strs = [ghost_pos_str+str(ghost_num) for ghost_num in xrange(num_ghosts)]

    "*** YOUR CODE HERE ***"
    lst1, lst2 = [], []

    for g in ghost_strs:
        lst1.append(logic.PropSymbolExpr(g, x, y, t))
        lst2.append(logic.PropSymbolExpr(g, x, y, t - 1))

    if len(ghost_strs):
        causes = (logic.PropSymbolExpr(pacman_str, x, y, t) & logic.disjoin(lst2)) | logic.conjoin((logic.PropSymbolExpr(pacman_str, x, y, t), ~logic.disjoin(lst2), logic.disjoin(lst1)))
    else:
        return ~logic.PropSymbolExpr(pacman_alive_str, t) % ~logic.PropSymbolExpr(pacman_alive_str, t - 1)
    #print logic.PropSymbolExpr(pacman_alive_str, t) % logic.conjoin(logic.PropSymbolExpr(pacman_alive_str, t - 1), cause)
    return ~logic.PropSymbolExpr(pacman_alive_str, t) % ((logic.PropSymbolExpr(pacman_alive_str, t - 1) & causes) | ~logic.PropSymbolExpr(pacman_alive_str, t - 1)) 
コード例 #51
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def sentence3():
    """Using the symbols WumpusAlive[1], WumpusAlive[0], WumpusBorn[0], and WumpusKilled[0],
    created using the logic.PropSymbolExpr constructor, return a logic.PropSymbolExpr
    instance that encodes the following English sentences (in this order):

    The Wumpus is alive at time 1 if and only if the Wumpus was alive at time 0 and it was
    not killed at time 0 or it was not alive and time 0 and it was born at time 0.

    The Wumpus cannot both be alive at time 0 and be born at time 0.

    The Wumpus is born at time 0.
    """

    WumpusAlive0 = logic.PropSymbolExpr('WumpusAlive',0)
    WumpusAlive1 = logic.PropSymbolExpr('WumpusAlive',1)
    WumpusBorn0 = logic.PropSymbolExpr('WumpusBorn',0)
    WumpusKilled0 = logic.PropSymbolExpr('WumpusKilled',0)
    expr1 = WumpusAlive1 % ((WumpusAlive0 & ~WumpusKilled0) | (~WumpusAlive0 & WumpusBorn0))
    expr2 = ~(WumpusAlive0 & WumpusBorn0)
    expr3 = WumpusBorn0
    return logic.conjoin([expr1,expr2,expr3])
コード例 #52
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    
    "*** YOUR CODE HERE ***"
    kb = []
    actions = ['North', 'South', 'East', 'West']
    start = problem.getStartState()
    goal = problem.getGoalState()
    
    for x in range(1, width + 1):
        for y in range(1, height + 1):
            if (x, y) == start:
                kb.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
            else:
                kb.append(~logic.PropSymbolExpr(pacman_str, x, y, 0))

    for t in range(50):
        
        action = []
        for a in actions:
            action.append(logic.PropSymbolExpr(a, t)) 
        kb.append(exactlyOne(action))
        #print(kb)
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                kb.append(pacmanSuccessorStateAxioms(x, y, t + 1, walls))

        kb.append(logic.PropSymbolExpr(pacman_str, goal[0], goal[1], t))

        model = findModel(logic.conjoin(kb))
        if model:
            return extractActionSequence(model, actions)

        kb.pop()
コード例 #53
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def positionLogicPlan(problem):
    """
    Given an instance of a PositionPlanningProblem, return a list of actions that lead to the goal.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    start = problem.getStartState()
    goal = problem.getGoalState()

    start_axiom = [logic.PropSymbolExpr(pacman_str,start[0],start[1],0)]
    for x in range(1,width+1):
        for y in range(1,height+1):
            if not walls[x][y] and (x != start[0] or y != start[1]):
                start_axiom.append(~logic.PropSymbolExpr(pacman_str,x,y,0))
    start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',0), 
                                logic.PropSymbolExpr('West',0),
                                logic.PropSymbolExpr('South',0),
                                logic.PropSymbolExpr('North',0)]))
    for t in range(1,51):
        start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',t), 
                            logic.PropSymbolExpr('West',t),
                            logic.PropSymbolExpr('South',t),
                            logic.PropSymbolExpr('North',t)]))
        for x in range(1,width+1):
            for y in range(1,height+1):
                if not walls[x][y]:
                    start_axiom.append(pacmanSuccessorStateAxioms(x,y,t,walls))
        start_axiom.append(pacmanSuccessorStateAxioms(goal[0],goal[1],t+1,walls))
        start_axiom.append(logic.PropSymbolExpr(pacman_str,goal[0],goal[1],t+1))
        model = logic.pycoSAT(logic.conjoin(start_axiom))
        if model:
            directions = [game.Directions.NORTH, game.Directions.SOUTH,game.Directions.EAST,game.Directions.WEST]
            actions = extractActionSequence(model, directions)
            return actions
        start_axiom.pop()
        start_axiom.pop()
コード例 #54
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def sentence3():
    """Using the symbols WumpusAlive[1], WumpusAlive[0], WumpusBorn[0], and WumpusKilled[0],
    created using the logic.PropSymbolExpr constructor, return a logic.PropSymbolExpr
    instance that encodes the following English sentences (in this order):

    The Wumpus is alive at time 1 if and only if the Wumpus was alive at time 0 and it was
    not killed at time 0 or it was not alive and time 0 and it was born at time 0.

    The Wumpus cannot both be alive at time 0 and be born at time 0.

    The Wumpus is born at time 0.
    """
    "*** YOUR CODE HERE ***"
    time_1_alive = logic.PropSymbolExpr('WumpusAlive', 1)
    time_0_alive = logic.PropSymbolExpr("WumpusAlive", 0)
    time_0_born = logic.PropSymbolExpr("WumpusBorn", 0)
    time_0_killed = logic.PropSymbolExpr("WumpusKilled", 0)
    alive_and_notkilled = time_0_alive & ~time_0_killed
    notalive_and_born = ~time_0_alive & time_0_born
    first_exp = time_1_alive % (alive_and_notkilled | notalive_and_born)
    second_exp = ~(time_0_alive & time_0_born)
    return logic.conjoin([first_exp, second_exp, time_0_born])
    util.raiseNotDefined()
コード例 #55
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def foodGhostLogicPlan(problem):
    """
    Given an instance of a FoodGhostPlanningProblem, return a list of actions that help Pacman
    eat all of the food and avoid patrolling ghosts.
    Ghosts only move east and west. They always start by moving East, unless they start next to
    and eastern wall. 
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()

    "*** YOUR CODE HERE ***"
    kb = []
    actions = ['North', 'South', 'East', 'West']
    start = problem.getStartState()[0]
    food = problem.getStartState()[1]
    ghosts = problem.getGhostStartStates()
    num_ghosts = len(ghosts)
    blocked_west_positions, blocked_east_positions = [], []
    ghosts_pos = []

    # init KB
    for i in range(len(ghosts)):
        ghosts_pos.append(ghosts[i].getPosition())    

    for x in range(1, width + 1):
        for y in range(1, height + 1):
            if (x, y) == start:
                kb.append(logic.PropSymbolExpr(pacman_str, x, y, 0))
            else:
                kb.append(~logic.PropSymbolExpr(pacman_str, x, y, 0))
            for i in range(len(ghosts)):
                pos_str = ghost_pos_str + str(i)
                if (x, y) == ghosts_pos[i]:
                    kb.append(logic.PropSymbolExpr(pos_str, x, y, 0))
                else:
                    kb.append(~logic.PropSymbolExpr(pos_str, x, y, 0))
            if walls[x + 1][y]:
                blocked_east_positions.append((x, y))
            if walls[x - 1][y]:                    
                blocked_west_positions.append((x, y))

    for i in range(len(ghosts)):
        east_str = ghost_east_str + str(i)
        if ghosts_pos[i] not in blocked_east_positions:
            kb.append(logic.PropSymbolExpr(east_str, 0))
        else:
            kb.append(~logic.PropSymbolExpr(east_str, 0))

    kb.append(logic.PropSymbolExpr(pacman_alive_str, 0))
    #print(kb)

    # loop each time
    for t in range(50):
        #print(t)

        #exactly one action each time
        lst = []
        for a in actions:
            lst.append(logic.PropSymbolExpr(a, t)) 
        kb.append(exactlyOne(lst))

        # SSAs
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                kb.append(logic.to_cnf(pacmanSuccessorStateAxioms(x, y, t + 1, walls)))
                kb.append(logic.to_cnf(pacmanAliveSuccessorStateAxioms(x, y, t + 1, num_ghosts)))
                for i in range(len(ghosts)):
                    kb.append(logic.to_cnf(ghostPositionSuccessorStateAxioms(x, y, t + 1, i, walls)))
        
        for i in range(len(ghosts)):
            kb.append(logic.to_cnf(ghostDirectionSuccessorStateAxioms(t + 1, i, blocked_west_positions, blocked_east_positions)))

        # goal KB
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if food[x][y]:
                    lst = []
                    for t in range(t + 1):
                        lst.append(logic.PropSymbolExpr(pacman_str, x, y, t))
                    kb.append(atLeastOne(lst))

        # whether satisfy the model
        model = logic.pycoSAT(logic.conjoin(kb))
        if model:
            return extractActionSequence(model, actions)

        # pop goal KB
        for x in range(1, width + 1):
            for y in range(1, height + 1):
                if food[x][y]:
                    kb.pop()
コード例 #56
0
ファイル: logicPlan.py プロジェクト: jesseyli/OldProjects
def foodGhostLogicPlan(problem):
    """
    Given an instance of a FoodGhostPlanningProblem, return a list of actions that help Pacman
    eat all of the food and avoid patrolling ghosts.
    Ghosts only move east and west. They always start by moving East, unless they start next to
    and eastern wall. 
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """

    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    not_walls = []
    for x in range(1,width+1):
        for y in range(1,height+1):
            if not walls[x][y]:
                not_walls += [(x,y)]
    ghosts = problem.getGhostStartStates()
    start, foodGrid = problem.getStartState()[0],problem.getStartState()[1]
    start_axiom = [logic.PropSymbolExpr(pacman_str,start[0],start[1],0)]
    start_axiom.append(logic.PropSymbolExpr(pacman_alive_str,0))
    blocked_west_positions = []
    blocked_east_positions = []
    ghost_num = 0
    num_ghosts = len(ghosts)
    reachable = {}
    all_reachable = []

    ghost_y = []
    for ghost in ghosts:
        ghost_start = ghost.getPosition()
        x = ghost_start[0] + 1
        y = ghost_start[0] - 1
        ghost_y.append(ghost_start[1])
        start_axiom.append(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),ghost_start[0],ghost_start[1],0))
        if not walls[ghost_start[0]+1][ghost_start[1]]:
            start_axiom.append(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),ghost_start[0]+1,ghost_start[1],1))
            start_axiom.append(logic.PropSymbolExpr(ghost_east_str+str(ghost_num),0))
        elif not walls[ghost_start[0]-1][ghost_start[1]]:
            start_axiom.append(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),ghost_start[0]-1,ghost_start[1],1))
            start_axiom.append(~logic.PropSymbolExpr(ghost_east_str+str(ghost_num),0))
        else:        
            start_axiom.append(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),ghost_start[0],ghost_start[1],1))
            start_axiom.append(logic.PropSymbolExpr(ghost_east_str+str(ghost_num),0))
        for space in not_walls:
                if (space[0] != ghost_start[0] or space[1] != ghost_start[1]):
                        start_axiom.append(~logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),space[0],space[1],0))
        reachable[ghost_num] = [(ghost_start[0],ghost_start[1])]
        all_reachable.append((ghost_start[0],ghost_start[1]))
        while not walls[x][ghost_start[1]]:
            reachable[ghost_num].append((x,ghost_start[1]))
            all_reachable.append((x,ghost_start[1]))
            x += 1
        while not walls[y][ghost_start[1]]:
            reachable[ghost_num].append((y,ghost_start[1]))
            all_reachable.append((y,ghost_start[1]))
            y -= 1
        ghost_num += 1
    for space in not_walls:
        if walls[space[0]-1][space[1]]: 
            blocked_west_positions.append((space[0],space[1]))
        if walls[space[0]+1][space[1]]:
            blocked_east_positions.append((space[0],space[1]))
        if (space[0] != start[0] or space[1] != start[1]):
            start_axiom.append(~logic.PropSymbolExpr(pacman_str,space[0],space[1],0))
    start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',0), 
                                logic.PropSymbolExpr('West',0),
                                logic.PropSymbolExpr('South',0),
                                logic.PropSymbolExpr('North',0)]))
    for t in range(1,51):
        pops = 0
        start_axiom.append(exactlyOne([logic.PropSymbolExpr('East',t), 
                            logic.PropSymbolExpr('West',t),
                            logic.PropSymbolExpr('South',t),
                            logic.PropSymbolExpr('North',t)]))
        position_t = []
        for space in not_walls:
            start_axiom.append(pacmanSuccessorStateAxioms(space[0],space[1],t,walls))
            if space in all_reachable:
                start_axiom.append(pacmanAliveSuccessorStateAxioms(space[0], space[1], t, num_ghosts))
            for ghost_num in xrange(num_ghosts):
                if space in reachable[ghost_num]:
                    start_axiom.append(ghostPositionSuccessorStateAxioms(space[0], space[1], t, ghost_num, walls))
                    start_axiom.append(ghostDirectionSuccessorStateAxioms(t, ghost_num, blocked_west_positions, blocked_east_positions))
                else:
                    start_axiom.append(~logic.PropSymbolExpr(ghost_pos_str+str(ghost_num),space[0],space[1],t))
        for x in range(1,width+1):
            for y in range(1,height+1):
                visit = []
                if foodGrid[x][y]:
                    for i in range(1,t+1):
                        visit.append(logic.PropSymbolExpr(pacman_str,x,y,i))
                    start_axiom.append(atLeastOne(visit))
                    pops += 1
        model = logic.pycoSAT(logic.conjoin(start_axiom))
        if model:
            directions = [game.Directions.NORTH,game.Directions.SOUTH,game.Directions.EAST,game.Directions.WEST]
            actions = extractActionSequence(model, directions)
            return actions
        for i in range(0,pops):
            start_axiom.pop()
コード例 #57
0
ファイル: logicPlan.py プロジェクト: aparsrinara/logic_plan
def foodGhostLogicPlan(problem):
    """
    Given an instance of a FoodGhostPlanningProblem, return a list of actions that help Pacman
    eat all of the food and avoid patrolling ghosts.
    Ghosts only move east and west. They always start by moving East, unless they start next to
    and eastern wall. 
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    walls = problem.walls
    width, height = problem.getWidth(), problem.getHeight()
    "*** YOUR CODE HERE ***"
    initialState = problem.getStartState();
    (x, y) = initialState[0]
    foodGrid = initialState[1]
    initial = []
    num_ghosts = len(problem.getGhostStartStates())
    initial.append(logic.PropSymbolExpr(pacman_str, x, y, 0) & logic.PropSymbolExpr(pacman_alive_str, 0))
    gStart = []
    for ghost_num in range(0, num_ghosts):
        gStart.append(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num), problem.getGhostStartStates()[ghost_num].getPosition()[0], problem.getGhostStartStates()[ghost_num].getPosition()[1], 0))
    foodLoc = []
    foodLoac = []
    blockedWest = []
    blockedEast = []
    for r in xrange(1, width+1):
        for c in xrange(1, height+1):
            if not walls[r][c]:
                if ((r,c) != (x,y)):
                    initial.append(~(logic.PropSymbolExpr(pacman_str, r, c, 0)))
                for ghost_num in range(0, num_ghosts):
                    if ((r, c) != (problem.getGhostStartStates()[ghost_num].getPosition()[0], problem.getGhostStartStates()[ghost_num].getPosition()[1])):
                        a = ~(logic.PropSymbolExpr(ghost_pos_str+str(ghost_num), r, c, 0))
                        gStart.append(a)
                if not walls[r][c] and walls[r+1][c]:
                    blockedEast.append((r, c))
                if not walls[r][c] and walls[r-1][c]:
                    blockedWest.append((r, c))
                if foodGrid[r][c]:
                    foodLoc.append(logic.PropSymbolExpr(pacman_str,r,c,0))
                    foodLoac.append((r,c))
    for ghost_num in range(0, num_ghosts):
        startPos = (problem.getGhostStartStates()[ghost_num].getPosition()[0], problem.getGhostStartStates()[ghost_num].getPosition()[1])
        if startPos in blockedEast:
            gStart.append(~logic.PropSymbolExpr(ghost_east_str+str(ghost_num), 0))
        else:
            gStart.append(logic.PropSymbolExpr(ghost_east_str+str(ghost_num), 0))

    init = logic.to_cnf(logic.conjoin(initial + gStart))
    

    pacmanAliveList = []
    ghostDirList = []
    pacmanPositionList = []
    ghostPositionList = []
    lst = []
    for t in range(1, 51):
        for ghost_num in range(0, num_ghosts):
            ghostDirList.append(ghostDirectionSuccessorStateAxioms(t, ghost_num, blockedWest, blockedEast))
        for r in xrange(1, width+1):
            for c in xrange(1, height+1):
                if not walls[r][c]:
                    pacmanPositionList.append(pacmanSuccessorStateAxioms(r, c, t, walls))
                    pacmanAliveList.append(pacmanAliveSuccessorStateAxioms(r, c, t, num_ghosts))
                    for ghost_num in range(0, num_ghosts):
                        ghostPositionList.append(ghostPositionSuccessorStateAxioms(r, c, t, ghost_num, walls))            
        d = []
        d.append(logic.PropSymbolExpr(game.Directions.NORTH, t-1))
        d.append(logic.PropSymbolExpr(game.Directions.SOUTH, t-1))
        d.append(logic.PropSymbolExpr(game.Directions.EAST, t-1))
        d.append(logic.PropSymbolExpr(game.Directions.WEST, t-1))
        lst.append(exactlyOne(d))
        for food in foodLoac:
            foodLoc[foodLoac.index(food)] = foodLoc[foodLoac.index(food)] | logic.PropSymbolExpr(pacman_str,food[0],food[1],t)
        goalState = logic.to_cnf(logic.conjoin(foodLoc) & logic.PropSymbolExpr(pacman_alive_str, t))
        lisst = logic.to_cnf(logic.conjoin(list(set(pacmanPositionList)) + list(set(pacmanAliveList)) + list(set(ghostPositionList)) + list(set(ghostDirList)) + list(set(lst))))
        result = lisst & init & goalState
        model = logic.pycoSAT(result)
        if model != False:
            seq = extractActionSequence(model, [game.Directions.NORTH, game.Directions.SOUTH,game.Directions.EAST, game.Directions.WEST])
            return seq
    util.raiseNotDefined()
コード例 #58
0
ファイル: logicPlan.py プロジェクト: Roboball/Pacman
def ghostDirectionSuccessorStateAxioms(t, ghost_num, blocked_west_positions, blocked_east_positions):
    """
    Successor state axiom for patrolling ghost direction state (t) (from t-1).
    west or east walls.
    Current <==> (causes to stay) | (causes of current)
    """
    pos_str = ghost_pos_str+str(ghost_num)
    east_str = ghost_east_str+str(ghost_num)

    "*** YOUR CODE HERE ***"
    wlst, elst = [], []

    for (x, y) in blocked_east_positions:
        elst.append(~logic.PropSymbolExpr(pos_str, x, y, t))
    for (x, y) in blocked_west_positions:
        wlst.append(logic.PropSymbolExpr(pos_str, x, y, t))

    if not elst and wlst:
        return logic.PropSymbolExpr(east_str, t) % (logic.PropSymbolExpr(east_str, t - 1) | (~logic.PropSymbolExpr(east_str, t - 1) & logic.disjoin(wlst)))
    elif elst and not wlst:
        return logic.PropSymbolExpr(east_str, t) % (logic.PropSymbolExpr(east_str, t - 1) & logic.conjoin(elst))
    elif not elst and not wlst:
        return logic.PropSymbolExpr(east_str, t) % logic.PropSymbolExpr(east_str, t - 1)
    else:
        return logic.PropSymbolExpr(east_str, t) % ((logic.PropSymbolExpr(east_str, t - 1) & logic.conjoin(elst)) | (~logic.PropSymbolExpr(east_str, t - 1) & logic.disjoin(wlst)))