class: center, middle # Artificial Intelligence ### Lab 3 --- class: medium # Lab 3 * In Lab 3 you will take the elevator domain we already briefly saw and extend it * The Lab consists of two sub-tasks: - Add more elevators - Add restrictions to the elevators (e.g. "can only stop on even numbered floors") * For each sub-task, you will create a separate PDDL domain and problem --- # Lab 3 * Start with [this zip file](/CS4200/assets/lab3.zip) * You will find one domain (`elevator_domain.pddl`) with three problems (`elevator_problem.pddl`, `elevator_problem1.pddl`, and `elevator_problem2.pddl`) * Try to understand what is there before you start modifying it * Definitely get your workflow set up before you modify anything --- # Workflow * [VS Code](https://code.visualstudio.com/) ("Runs everywhere") with the [PDDL Extension](https://marketplace.visualstudio.com/items?itemName=jan-dolejsi.pddl) * [Online editor](http://editor.planning.domains/) * In either case: Store/share your code using your favorite SCM (e.g. git)! * First step: Get the planner running; each of the three problems should be solvable in a few seconds --- # Elevator Domain You will be working with a domain representing an abstraction of [Schindler Miconic 10](https://elevation.fandom.com/wiki/Schindler_Miconic_10) elevators: <quote> Instead of "calling a car by push buttons", the destination floor is entered via a telephone-style keypad. (...) Once they (passengers) are inside the elevator, the doors will close and the elevator will go straight to their desired floors. They don't need to select floors inside as there are no visible floor buttons[7] on the car station other than door open, door close and alarm buttons. </quote> Also interesting: "The minimum amount of elevator cars used with this system is two. " --- # Elevator Domain Abstraction: * We have a building with several floors * There is a number of passengers * For each passenger we know where they are, and where they want to go * In other words: All passengers call the elevator(s) simultaneously --- # Miconic Domain Our "agent" is the elevator controller. It can (currently): * Make the elevator go from the floor it currently is to a floor above `(up ?f1 ?f2)` * Make the elevator go from the floor it currently is to a floor below `(down ?f1 ?f2)` * Make the elevator stop and open its door at its current floor `(stop ?f1)` --- # Adding More Elevators * First thing to notice: The current version only has one elevator car ("**the** elevator") * But in reality this system is always used with multiple cars! * Your first task is to add this capability * This requires some modifications --- # Types Currently: ```Lisp ;; Domain (:types passenger - object floor - object ) ;; Problem (:objects p0 p1 - passenger f0 f1 f2 f3 f4 f5 - floor ) ``` You will want an additional type for "elevators". --- # Up Action Currently: ```Lisp ;;drive up (:action up :parameters (?f1 - floor ?f2 - floor) :precondition (and (lift-at ?f1) (above ?f1 ?f2)) :effect (and (lift-at ?f2) (not (lift-at ?f1))) ) ``` To allow the controller to use different elevators, you need to modify this action to have a parameter representing which elevator to move. --- # Predicates Let's look at the precondition: ```Lisp :precondition (and (lift-at ?f1) (above ?f1 ?f2)) ``` It says `(lift-at ?f1)` ... but: Which lift? ```Lisp (:predicates ... (lift-at ?floor - floor) ;; current position of the lift is at ?floor ) ``` You will have to change this predicate with an additional parameter, so you can represent **which** lift is where. --- # Testing * Come up with a new problem * (At least) 5 passengers and 8 floors and 2 elevators * Look at the produced plan * Report the plan (**summarize**, don't just enumerate the actions) * Note: The planner may not use all elevators --- class: medium # Adding Restrictions For the second task, add restrictions to your elevators: - One elevator can only stop at even floors (0 is even for our purposes) - One elevator can only stop at odd floors - One elevator can only stop at floors divisible by 3 --- # Forcing Multiple Elevators * Say there is a passenger that wants to go from floor 6 to floor 1 * Elevators 1 and 3 can stop at floor 6, but not at floor 1 * Elevator 2 can stop at floor 1, but not at floor 6 * The passenger therefore has to get on one elevator (e.g. elevator 3), go to another floor (3), and then take another elevator (2) to get to their destination --- # Restrictions * This task has several possible approaches * You **do not** have to do arithmetic in PDDL * One way: Add a predicate representing which floors are reachable by each elevator * You then manually enumerate these reachabilities --- # Stopping Currently: ```Lisp (:action stop :parameters (?f - floor) :precondition (lift-at ?f) :effect (and (forall (?p - passenger) (when (and (boarded ?p) (destin ?p ?f)) (and (not (boarded ?p)) (served ?p)))) (forall (?p - passenger) (when (and (origin ?p ?f) (not (served ?p))) (boarded ?p))) ) ) ``` --- # Stopping Suggestion: * Add a predicate for where a passenger is located * Initially they are at their origin * Add actions that allows one/all passengers to enter/leave the elevator * What's the difference? --- # Testing * Come up with another problem * (At least) 7 passengers and 12 floors (using the 3 elevators described above) * Look at the produced plan * Report the plan (**summarize**, don't just enumerate the actions) * You can also experiment with other configurations! --- # Report In your report describe: * How you support multiple elevators (changes to predicates/actions) * How did you implement the floor restrictions? * How did you allow passengers to change elevators * **Summarize** the plans produced by the planner for your test cases --- class: center, middle # Exam Review --- # Question 1 * Which of the four types of intelligence we discussed does (AI) planning fall under and why? * Since Planning is based in logic, something "rational" is more appropriate * Whether it's "thinking" or "acting" depends on how you view it (some of you cleverly put both!) * 51% of you argued for "thinking rationally", 37% for "acting rationally" --- # Question 2a * BFS on the CSU map, from CSUSB to CSULB * BFS will produce a path consisting of two edges: CSUSB - CSUSM, CSUSM - CSULB * It is rather long, measured in miles * But BFS produces it because it ignores costs, and produces the path with the least number of edges --- # Question 2b * A\* from CSUDH to CPP * The shortest path is CSUDH - CalState LA, CalState LA - CPP, with 45 miles * If you returned CPP with 48 miles (via CSULB, CSUF) you did not produce the shortest path * The **cost** in the frontier is the **total cost** to get to a node, not just the most recent edge --- # Question 3 * Complete game tree for the binary number game where you win if the number is divisible by 3 * **Every** node has a value * When you have drawn the tree, you determine points for the leaf nodes * Then you propagate the values upwards, choosing the minimum/maximum --- class: medium # Question 4a * Define an interpretation W that is a model for the given formulas (using `crossing` and `parallel`) * This was a bit tricky: You may have your own ideas what "crossing" and "parallel" means/entails, but logic does not * For example: Just because you write `parallel(a,b)` does **not** mean that `parallel(b,a)` is automatically true, too * `\(\forall x: \forall y: \mathit{crossing}(x,y) \vee \mathit{parallel}(x,y)\)` means there have to be (at least) 16 entries (x=a, y=a is possible) --- class: medium # Question 4b * Determine whether your interpretation is a model for the given formulas * If you did 4a right, the first formula `\(\exists x: \forall y: \mathit{crossing}(y,x)\)` can never be true, it would require a line to cross itself * The second formula tried to nudge you towards defining parallel as symmetrical * The third formula tried to show you that things can be parallel to themselves * The fourth formula had a typo and was therefore always true