Пример #1
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))
Пример #2
0
def positionLogicPlan(problem):
    """
    Given an instance of a PositionSearchProblem, 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.
    """
    actions = [
        game.Directions.EAST, game.Directions.SOUTH, game.Directions.WEST,
        game.Directions.NORTH
    ]
    init_t = util.manhattanDistance(problem.getStartState(),
                                    problem.getGoalState())
    goal_s = problem.getGoalState()
    preds = getPredecessors(problem)
    start_pos = problem.getStartState()
    init_state = [logic.Expr("&", logic.PropSymbolExpr("P", start_pos[0],start_pos[1],0),\
                *[logic.Expr("~", logic.PropSymbolExpr("P", s[0],s[1],0)) for s in preds.keys() if s != start_pos])]
    for t in xrange(init_t, 51):
        goal = [logic.PropSymbolExpr("P", goal_s[0], goal_s[1]), \
                logic.to_cnf(logic.Expr(">>", logic.PropSymbolExpr("P", goal_s[0], goal_s[1]),\
               logic.Expr("|", *[logic.PropSymbolExpr("P", goal_s[0], goal_s[1], time) for time in xrange(1,t+1)])))]
        successors = generateSuccessorState(preds, t)
        exps = goal + successors + init_state
        model = logic.pycoSAT(exps)
        if model:
            return extractActionSequence(model, actions)
    return []
Пример #3
0
def exactlyOne(expressions):
    """
    Given a list of logic.Expr instances, 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.
    """
    return logic.Expr("|", *[logic.Expr("&", expr_i, \
        *[logic.Expr("~", expr_j) for expr_j in expressions if expr_i != expr_j]) for expr_i in expressions])
Пример #4
0
def atMostOne(expressions):
    """
    Given a list of logic.Expr instances, 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.
    """
    exact = exactlyOne(expressions)
    none = logic.Expr("&", logic.Expr("~", *expressions))
    return logic.Expr("|", none, exact)
Пример #5
0
def foodGhostLogicPlan(problem):
    """
    Given an instance of a FoodGhostSearchProblem, 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
    an eastern wall.
    Available actions are game.Directions.{NORTH,SOUTH,EAST,WEST}
    Note that STOP is not an available action.
    """
    actions = [
        game.Directions.EAST, game.Directions.SOUTH, game.Directions.WEST,
        game.Directions.NORTH
    ]

    # this is my food grid as a list [(x,y), (x,y) ...]
    food_list = problem.getStartState()[1].asList()

    # this is a list of the distances from my start state to each food on the grid
    manhattan_food_distances = [
        util.manhattanDistance(problem.getStartState()[0], food)
        for food in food_list
    ]

    # for the predecessors function
    extractState = lambda x: x[0][0]
    generateState = lambda x: (x, problem.getStartState()[1])

    # return the food that is furthest away
    init_t = max(manhattan_food_distances)

    preds = getPredecessors(problem, extractState, generateState)
    start_pos = problem.getStartState()[0]
    init_state = [logic.Expr("&", logic.PropSymbolExpr("P", start_pos[0],start_pos[1],0),\
                *[logic.Expr("~", logic.PropSymbolExpr("P", s[0],s[1],0)) for s in preds.keys() if s != start_pos])]
    ghost_pos_arrays = [
        getGhostPositionArray(problem, ghost.getPosition())
        for ghost in problem.getGhostStartStates()
    ]

    for t in xrange(init_t, 51):
        ghosts = reduce(lambda x,y: x + y, [[[~logic.PropSymbolExpr("P", g[i%len(g)][0],g[i%len(g)][1],i+1),\
                    ~logic.PropSymbolExpr("P", g[i%len(g)][0],g[i%len(g)][1],i)]\
                    for i in xrange(t+1)] for g in ghost_pos_arrays])
        ghosts = reduce(lambda x, y: x + y, ghosts)
        goal_list = []
        for food in food_list:  # food is an (x, y) coordinate
            goal_list.append([logic.PropSymbolExpr("P", food[0], food[1]), \
                logic.to_cnf(logic.Expr(">>", logic.PropSymbolExpr("P", food[0], food[1]),\
               logic.Expr("|", *[logic.PropSymbolExpr("P", food[0], food[1], time) for time in xrange(t+1)])))])
        successors = generateSuccessorState(preds, t)

        # makes goal_list a list, previously was a list of lists
        goal_list = reduce(lambda x, y: x + y, goal_list)
        exps = goal_list + successors + init_state + ghosts
        model = logic.pycoSAT(exps)
        if model:
            return extractActionSequence(model, actions)
    return []
Пример #6
0
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')
    return logic.conjoin([(A | B), ((~A) % ((~B) | C)), ((~A) | (~B) | C)])
Пример #7
0
def foodLogicPlan(problem):
    """
    Given an instance of a FoodSearchProblem, 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.
    """
    # need a list where all the food is
    # go through with the logic phrase, for each food make sure at some time step t I will be there

    actions = [
        game.Directions.EAST, game.Directions.SOUTH, game.Directions.WEST,
        game.Directions.NORTH
    ]

    # this is my food grid as a list [(x,y), (x,y) ...]
    food_list = problem.getStartState()[1].asList()

    # this is a list of the distances from my start state to each food on the grid
    manhattan_food_distances = [
        util.manhattanDistance(problem.getStartState()[0], food)
        for food in food_list
    ]

    # for the predecessors function
    extractState = lambda x: x[0][0]
    generateState = lambda x: (x, problem.getStartState()[1])

    # return the food that is furthest away
    init_t = max(manhattan_food_distances)

    preds = getPredecessors(problem, extractState, generateState)
    start_pos = problem.getStartState()[0]
    init_state = [logic.Expr("&", logic.PropSymbolExpr("P", start_pos[0],start_pos[1],0),\
                *[logic.Expr("~", logic.PropSymbolExpr("P", s[0],s[1],0)) for s in preds.keys() if s != start_pos])]

    for t in xrange(init_t, 51):
        goal_list = []
        for food in food_list:  # food is an (x, y) coordinate
            goal_list.append([logic.PropSymbolExpr("P", food[0], food[1]), \
                logic.to_cnf(logic.Expr(">>", logic.PropSymbolExpr("P", food[0], food[1]),\
               logic.Expr("|", *[logic.PropSymbolExpr("P", food[0], food[1], time) for time in xrange(1,t+1)])))])
        successors = generateSuccessorState(preds, t)

        # makes goal_list a list, previously was a list of lists
        goal_list = reduce(lambda x, y: x + y, goal_list)
        exps = goal_list + successors + init_state
        model = logic.pycoSAT(exps)
        if model:
            return extractActionSequence(model, actions)
    return []
Пример #8
0
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')
    one = A | B
    two = (~A) % ((~B) | C)
    three = logic.disjoin((~A), (~B), C)
    return logic.conjoin([one, two, three])
Пример #9
0
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')
    First = A | B
    Second = ~A % (~B | C)
    Third = logic.disjoin(~A, ~B, C)
    return logic.conjoin(First, Second, Third)
Пример #10
0
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')
    NOT_A, NOT_B = ~A, ~B
    E1 = A | B
    E2 = (NOT_A) % ((NOT_B) | C)
    E3 = logic.disjoin([NOT_A, NOT_B, C])
    return logic.conjoin([E1, E2, E3])
Пример #11
0
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')
    r1 = A | B
    r2 = (~A) % ((~B) | C)
    r3 = logic.disjoin(~A, ~B, C)
    return logic.conjoin(r1, r2, r3)
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')
    aaa = logic.disjoin(A, B)
    a_or_b = ~A % (~B | C)
    not_a = logic.disjoin(~A, ~B, C)
    return logic.conjoin(aaa, a_or_b, not_a)
Пример #13
0
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')

    L1 = A | B
    L2 = (~A) % ((~B) | C)
    L3 = logic.disjoin((~A), (~B), C)

    return logic.conjoin(L1, L2, L3)
Пример #14
0
def sentence1():
    """Returns a logic.Expr instance that encodes that the following inits 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')
    s1 = A | B
    s2 = (~A) % (~B | C)
    s3 = logic.disjoin([~A, ~B, C])
    return logic.conjoin([s1, s2, s3])
Пример #15
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')
    return logic.conjoin([(C % (B | D)), (A >> ((~B) & (~D))),
                          (~(B & (~C)) >> A), ((~D) >> C)])
Пример #16
0
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')
    expr1 = A | B
    expr2 = (~A) % ((~B) | C)
    expr3 = logic.disjoin([~A, ~B, C])
    return logic.conjoin([expr1, expr2, expr3])
Пример #17
0
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")
    s1 = A | B
    s2 = (~A) % ((~B) | C)
    s3 = logic.disjoin([(~A), (~B), C])
    return logic.conjoin([s1, s2, s3])
Пример #18
0
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')
    sentence1 = logic.disjoin(a,B)
    sentence2 = logic.disjoin(~a%(~B|C))
    sentence3 = logic.disjoin(~a,~B,C)
    return logic.conjoin(sentence1,sentence2,sentence3)
    util.raiseNotDefined()
Пример #19
0
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")
    first = logic.disjoin(A, B)

    second = (~A) % logic.disjoin(~B, C)
    third = logic.disjoin(~A, ~B, C)
    return logic.conjoin(first, second, third)
Пример #20
0
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 = logic.disjoin(A, B)
    Two = ~A % logic.disjoin(~B, C)
    Three = logic.disjoin(~A, ~B, C)
    return logic.conjoin(A_or_B, Two, Three)
    util.raiseNotDefined()
Пример #21
0
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")

    p1 = A | B
    p2 = ~A % (~B | C)
    p3 = logic.disjoin(~A, ~B, C)
    return logic.conjoin(p1, p2, p3)
Пример #22
0
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')
    s1 = logic.to_cnf(A | B)
    s2 = ~A % (~B | C)
    s3 = logic.to_cnf(~A | ~B | C)
    return logic.conjoin(s1, s2, s3)
    util.raiseNotDefined()
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')
    aaa = C % (B | D)
    a_or_b = A >> (~B & ~D)
    not_a = ~(B & ~C) >> A
    not_d = ~D >> C
    return logic.conjoin(aaa, a_or_b, not_a, not_d)
Пример #24
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)
    """
    "*** YOUR CODE HERE ***"
    return logic.Expr('A') # Replace this with your expression
Пример #25
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
    """
    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    D = logic.Expr('D')
    r1 = C % (B | D)
    r2 = A >> ((~B) & (~D))
    r3 = (~(B & (~C))) >> A
    r4 = (~D) >> C
    return logic.conjoin(r1, r2, r3, r4)
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
    not_A_iff_not_B_or_C = ~A % (~B | C)
    not_A_or_not_B_or_C = logic.disjoin(~A, ~B, C)
    sentence = logic.conjoin(A_or_B, not_A_iff_not_B_or_C, not_A_or_not_B_or_C)
    return sentence
Пример #27
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, B, C, D = logic.Expr('A'), logic.Expr('B'), logic.Expr('C'), logic.Expr(
        'D')
    NOT_A, NOT_B, NOT_C, NOT_D = ~A, ~B, ~C, ~D
    E1 = (C) % (B | D)
    E2 = A >> (NOT_B & NOT_D)
    E3 = (~(B & NOT_C)) >> A
    E4 = NOT_D >> C
    return logic.conjoin([E1, E2, E3, E4])
Пример #28
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
    """
    A = logic.Expr('A')
    B = logic.Expr('B')
    C = logic.Expr('C')
    D = logic.Expr('D')
    one = C % (B | D)
    two = A >> ((~B) & (~D))
    three = (~(B & (~C))) >> A
    four = (~D) >> C
    return (logic.conjoin([one, two, three, four]))
Пример #29
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, B, C, D = logic.Expr('A'), logic.Expr('B'), logic.Expr('C'), logic.Expr(
        'D')

    L1 = C % (B | D)
    L2 = A >> ((~B) & (~D))
    L3 = (~(B & (~C))) >> A
    L4 = (~D) >> C

    return logic.conjoin(L1, L2, L3, L4)
Пример #30
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")
    s1 = C % (B | D)
    s2 = A >> ((~B) & (~D))
    s3 = (~(B & (~C))) >> A
    s4 = (~D) >> C
    return logic.conjoin([s1, s2, s3, s4])