Lecture 4 - Planning Intro

Question 1

What are the three assumptions made for graph planning?

Answer 1

The state is known
The map is known
Map is mostly static

Question 2

Give two potential queries for graph planning:

Answer 2

Can you reach B from A?

What’s the shortest path from node A to B that does not hit obstacles?`

Question 3

What’s the difference between Dynamic Programming map algorithm and Dijkstra’s?

Answer 3

Dynamic programming calculates Cost-to-go to destination, whereas D’s algorithm calculates cost-to-come

Question 4

Describe Dijsktra’s algorithm in steps

Answer 4

Start with D(vsrc) = 0
Set all surrounding nodes to D(v) = inf
Add all nodes nodes to priority queue Q with cost-to-come as priority
While Q is not empty:
* Extract node v with minimum c-t-c from Q
* if found goal, done
* remove v from queue
The cost-to-come of v is final at this point, need to check if we can reduce the c-t-c of its neighbors
For U in neighborhood of V:
* if d(u,v) + D(v) < D(u) then update priority

Question 5

What’s the main problem with Dijkstra’s algorithm?

Answer 5

Many nodes are explored unnecessarily because the algorithm prioritizes fast paths over slow paths that go towards goal

Question 6

How does A* improve Dijkstra’s algorithm?

Answer 6

By using a heuristic (cost-to-go, eg total distance to goal)

Question 7

What are two properties needed for A* heuristics

Answer 7

They need to be admissible (understimate cost-to-go from v to dest) and monotonic (satisfy the triangle inequality)

Question 8

What’s the idea behind Configuration spaces?

Answer 8

To dilate obstacles to take into account the dimensions of the robot, which allows us to plan the robot as a point, instead of taking account the ways the body can collide to the obstacles during planning.

Note: This idea is typically not used for robots with high-dimensional states.

Question 9

Name one algorith that can be used to dilate obstacles:

Answer 9

Minkowski Sum

Question 10

Explain what Subsumption Architecture is.

Answer 10

An architecture where planning is not necessary and only a hierarchy of reactive behaviors/controllers is used.

Question 11

Explain what Deliberative Architechture is.

Answer 11

An architecture where you sense, build models and plans, then move. There’s no loop to update the map in case shit changes.

Question 12

Why is the Sense-Plan-Act model better than Subsumption or Deliberative architechture?

Answer 12

Because you need to plan and construct careful algorithms for effectiveness, but also be willing to re-plan at any point using sensor data, in case the map or state changes.

Question 13

What is a plan (formally)?

Answer 13

1. A sequence of states.
2. A feasible plan is one where all states from start to end, and the transitions in between, are feasible.
3. Takes into account kinematics and maps

Question 14

What are the inputs and outputs of a planning algorithm?

Answer 14

Input: a start, a goal, kinematic constraints and a
map
Output: a path/plan, or“impossible”

Question 15

What are 4 planner properties?

Answer 15

• Correct: if every plan they’re output is feasible
• Complete: if they find a plan whenever one exists
• Terminating: if they execute in a finite time (guaranteed)
• Complexity: is measured by the worst-case memory and run-time in the map/robot dimensions, path length, etc.

Question 16

Does “always turning left” work as a plan (is it complete)?

Answer 16

No, because the obstacle could be wrapping the goal with only an entrance by taking a right turn.

Question 17

Does “turn left, then follow wall until back on track to goal, without an obstable in the way” work as a plan (is it complete)?

Answer 17

Yes.

Question 18

What do nodes and edges on a graph represent?

Answer 18

Nodes represent states.

Edges represent transitions/actions with weight as “energy” used.

Question 19

What’s the worst case complexity for Dynamic Programming mapping?

Answer 19

O(|V^2|

O(|V|) in 2D

Question 20

What’s the worst case complexity for Dijkstra’s algorithm?

Answer 20

O(|E|*T(update) + |V| T(remove min)) = O(|E| + |V|log|V|) (heaps)