World Champion chess player Garry Kasparov was defeated by IBM s Deep Blue chess-playing computer in a sixgame match in May, The match received

Transcription

1

2 World Champion chess player Garry Kasparov was defeated by IBM s Deep Blue chess-playing computer in a sixgame match in May, The match received enormous media coverage, much of which emphasized the notion that Kasparov was defending humanity s honor.

3

4

5 Games

6 Minimax for 2-player games Minimax is a standard AI strategy for 2-player games that are alternating: players take turns deterministic: each move has a well-defined outcome (there is no randomness) perfect-information: each player knows the complete state of the game (there is no hidden information zero-sum: if I win you lose, and vice versa what s good for me is bad for you (but draws are allowed)

7 Example: Nim Start with 15 pebbles To make a move you pick up 1, 2, or 3 pebbles Whoever picks up the last pebble loses e.g., 1. You pick up 3 (12 left) 2. I pick up 3 (9 left) 3. You pick up 2 (7 left) 4. I pick up 2 (5 left) 5. You pick up 1 (4 left) 6. I pick up 3 (1 left) 7. You pick 1 (0 left) 8. I win!

8 Example: Nim Nim actually has a winning strategy for the player going first! Consider Nim with 5 pebbles. If it s your turn and there are 5 pebbles left then you lose: if you take 1, I take 3, and there is 1 left; if you take 2, I take 2; if you take 3 I take 1. Similarly: 9 5, , etc. The pattern: if it s your turn and pebbles mod 4 1 then I have a winning strategy: choose always to leave the number of pebbles congruent to 1 mod 4.

9 Example: Nim Nim is special: a quick calculation tells who will win. For a game like chess (or Kalaha!) you can t tell (in constant time) just by looking at a board who will win. So, we must use computation to search possible future states. Build a game tree where nodes are states and edges are moves. Each row is labeled with the player whose turn it is.

10 Example: Nim Starting with 3 pebbles: 3 Maxie Minnie Maxie 0 Minnie

11 Example: Nim Next assign each node a value, saying who wins. Maxie wins if the value is 1. Minnie wins if the value is Maxie Minnie Maxie First label the leaves. 0-1 Minnie

12 Example: Nim Then propagate the labels up the tree. If it s Maxie s turn the value is the maximum of the children (because Maxie will choose the maximising move). If it s Minnie s it is the minimum. First level Maxie Minnie Maxie Minnie

13 Example: Nim Next level. 3 Maxie For example, on the rightmost subtree if there are two pebbles left then Minnie should take 1, leaving 1, rather than 2, leaving Minnie -1 Maxie 0-1 Minnie

14 Example: Nim Next level. 1 3 Maxie Maxie should take 2, leaving 1, rather than taking 3 or Minnie -1 Maxie 0-1 Minnie

15 Minimax algorithm Minimax computes the value of a game state assuming both players will play optimally. It does not account for things like that chess board is confusing, so it will be easy to make a mistake For a game with a bigger search space than this we can t draw out the whole tree! Instead, a heuristic must approximate the value of the board. Nim has a perfect heuristic: number of pebbles congruent to 1 mod 4.

16 Minimax algorithm The overall algorithm is: 1. explore the game tree up to a certain depth 2. use the heuristic to approximate the value when the depth is reached. For chess, a given heuristic would include which pieces are left, where they are positioned, etc.

17 GameTree.hs [live coding]

18 Abstract Data Types Chapter 16 of Thompson

19 Information Hiding Abstract data types (ADTs) allow information hiding on types. They hide the representation (or model) behind an abstract set of operations. Separates: data type definition from representation function declaration from implementation Application Specification Implementation User Implementor Interface

20 Information Hiding Consider modeling a computer s Random Access Memory (RAM), which stores values in memory variables. We might model RAM in different ways: [(Integer,Var)] (Var -> Integer) -- a list of integer/variable pairs -- a function from vars to integers Regardless of the model, operations to obtain an initial store and access/update variables have well-defined specifications: initial :: Store read :: Store -> Var -> Integer write :: Store -> Var -> Integer -> Store

21 Information Hiding The operation signatures specify the interface, upon which users and implementers agree, allowing them to work independently. But we want to isolate users from the model: allows evolution of the model without affecting users prevents manipulating the model in unintended ways e.g., prevent list operations on list model, composition on function model

22 Example: Signature Modules support information hiding by exposing only operations in the signature of the module header: module Store ( Store, initial, value, update ) where -- Store -- Store -> Var -> Integer -- Store -> Var -> Integer -> Store

23 Example: Implementation I data Store = Store [ (Integer,Var) ] initial :: Store initial = Store [] value :: Store -> Var -> Integer value (Store []) v = 0 value (Store ((n,w):s)) v v==w = n otherwise = value (Store s) v update :: Store -> Var -> Integer -> Store update (Store s) v n = Store ((n,v):s)

24 Example: Implementation II data Store = Store (Var -> Integer) initial :: Store initial = Store (\v -> 0) value :: Store -> Var -> Integer value (Store s) v = s v update :: Store -> Var -> Integer -> Store update (Store s) v n = Store (\w -> if v==w then n else s w)

25 Example: Implementations I and II Note that in both implementations storing more than once to the same variable will result in adding the new value to the store, but not removing the old one! Implementation I prepends to the list Implementation II constructs a new function as a conditional expression with the old function as the condition s else part

26

27 Queues: First-In First-Out (FIFO) module Queue ( Queue, emptyq, -- Queue a isemptyq, -- Queue a -> Bool addq, -- a -> Queue a -> Queue a remq -- Queue a -> ( a, Queue a ) ) where

28 Queues: Implementation I newtype Queue a = Queue [a] emptyq :: Queue a emptyq = Queue [] isemptyq :: Queue a -> Bool isemptyq (Queue []) = True isemptyq _ = False addq :: a -> Queue a -> Queue a addq x (Queue xs) = Queue (xs++[x]) remq :: Queue a -> ( a, Queue a ) remq q@(queue xs) not (isemptyq q) = (head xs, Queue (tail xs)) otherwise = error "remq"

29 Queues: Implementation II addq x (Queue xs) = Queue (x:xs) remq q@(queue xs) not (isemptyq q) = (last xs, Queue (init xs)) otherwise = error "remq"

30 Queues: a two-list queue Remove from left. Add to right. Only case of empty queue on left is expensive: reverse right list to left list.

31 Queues: Implementation III data Queue a = Queue [a] [a] emptyq :: Queue a emptyq = Queue [] [] isemptyq :: Queue a -> Bool isemptyq (Queue [] []) = True isemptyq _ = False addq :: a -> Queue a -> Queue a addq x (Queue xs ys) = Queue xs (x:ys) remq :: Queue a -> ( a, Queue a ) remq (Queue (x:xs) ys) = (x, Queue xs ys) remq (Queue [] ys@(z:zs)) = remq (Queue (reverse ys) []) remq (Queue [] []) = error "remq"

32 Designing ADTs to solve problems 1. Identify and name the types in the system. 2. Informally describe them. 3. Write the signature of each ADT. What belongs in the signature? What doesn t? Create an instance Discriminate instances Get state from an instance Transform an instance Combine instances Collapse instances

33

34 Tree module module Tree (Tree, nil, isnil, isnode, leftsub, rightsub, treeval, instree, delete, mintree, ) where -- Tree a -- Tree a -> Bool -- Tree a -> Bool -- Tree a -> Tree a -- Tree a -> Tree a -- Tree a -> a -- Ord a => a -> Tree a -> Tree a -- Ord a => a -> Tree a -> Tree a -- Ord a => Tree a -> Maybe a

35 ADT signatures should be minimal Omit operations that can be defined in terms of other operations, so independent of implementation: size :: Tree a -> Integer size t isnil t = 0 otherwise = 1 + size (leftsub t) + size (rightsub t)

36 Search Trees A binary search tree is a binary tree whose elements are ordered. Recall: data Tree a = Nil Node a (Tree a) (Tree a) A tree (Node val t 1 t 2 ) is ordered if: all values in t 1 are smaller than val, all values in t 2 are larger than val, and the trees t 1 and t 2 are also ordered where the tree Nil is trivially ordered. We can use an ADT to enforce order, by making sure implementations of operations in the interface preserve order.

37 Search Trees: Signature module Tree (Tree, nil, isnil, isnode, leftsub, rightsub, treeval, instree, delete, mintree, elemt ) where -- Tree a -- Tree a -> Bool -- Tree a -> Bool -- Tree a -> Tree a -- Tree a -> Tree a -- Tree a -> a -- Ord a => a -> Tree a -> Tree a -- Ord a => a -> Tree a -> Tree a -- Ord a => Tree a -> Maybe a -- Ord a => a -> Tree a -> Bool

38 Search Trees: Insertion instree val (Node v t1 t2) v==val = Node v t1 t2 val > v = Node v t1 (instree val t2) val < v = Node v (instree val t1) t2

39 Search Trees: Deletion delete join t1 val t2 (Node v t1 t2) = val Node < mini v t1 = newt Node v (delete val t1) t2 val where > v = Node v t1 (delete val t2) isnil (Just t2 mini) = t1 mintree t2 isnil newt t1 = t2 delete mini t2 otherwise join t1 t2

40 Set Theory

41 Sets Lists impose order, and allow multiplicity. [Joe, Sue, Ben] [Joe, Sue, Sue, Ben] [Ben, Sue, Joe] [Joe, Sue, Ben, Sue] Whereas, there is only one set containing these people: {Ben, Joe, Sue} So, an implementation of the Set ADT must ensure uniqueness of elements.

42 Sets Example implementation: an ordered list of elements without repetition [Set.hs]

43 Relations A binary relation is a relationship among elements of a set. e.g., parents and children in a family isparent = {(Ben, Sue), (Ben,Leo), (Sue, Joe)} In general: type Relation a = Set (a,a) So, all set operations are available on Relation values.

44 Relations The image of an element: all elements related to a given element e.g., all of Ben s children image isparent Ben = {Sue, Leo} The image of a set of elements: all elements related to a set of elements: the union of the images (sets) of each of the elements: unionset {s 1,, s n } = s 1 s n = s 1 `union` `union` s n e.g., addchildren: take image of a set of people under isparent and add

45 Relations: defining isancestor The transitive closure of the isparent relation. First, consider grandparent starting from parents: e.g., (Ben,Sue), (Sue, Joe) isgrandparent = isparent `compose` isparent e.g., {(Ben,Joe)} Set product is used by compose to pair elements of a first set with elements of a second set. e.g., setproduct {Ben,Suzie} {Sue,Joe} = {(Ben,Sue),(Ben,Joe),(Suzie,Sue),(Suzie,Joe)}

46 Relations: transitive closure and limits A relation rel is transitive if for all (a,b) and (b,c) in rel, then (a,c) is also in rel. The transitive closure of a relation rel is the smallest relation extending rel that is transitive: repeat compose until nothing more is added. To do this, we can use limit f x to give the limit of the sequence: x, f x, f (f x), f (f (f x)),, f n x which is the value the sequence settles to if it exists, computed by taking the first element in the sequence whose successor is equal to the element itself: f n x = f n+1 x

47 Relations: example Given {(Ben,Sue), (Sue,Joe)} addchildren {Joe,Ben} = {Joe,Sue,Ben} limit addchildren {Ben}?? {Ben}=={Ben,Sue} False limit addchildren {Ben,Sue}?? {Ben,Sue}=={Ben,Joe,Sue} False limit addchildren {Ben,Joe,Sue}?? {Ben,Joe,Sue}=={Ben,Joe,Sue} True {Ben,Joe,Sue}

48 Graphs Another way of thinking of relations is as directed graphs: e.g., graph1 = {(1,2),(1,3),(3,2),(3,4),(4,2),(2,4)} Here, transitive closure represents paths of reachability in the graph: e.g., the transitive closure contains (1,4), but not (2,1)

49 Graphs: strongly connected components Nodes connected by a path to all other nodes in the component: e.g., the components of graph1 are {1}, {3}, {2,4}

50 Computing strongly connected components First form the relation that links points in the same component There is a path from x to y and vice versa if both (x,y) and (y,x) are in the closure: connect :: Ord a => Relation a -> Relation a connect rel = clos `inter` solc where clos = tclosure rel solc = inverse clos where inverse swaps all pairs in the relation: inverse = mapset swap where swap (x,y) = (y,x)

51 Computing strongly connected components Next form the components (or equivalance classes) generated by this relation Start with the nodes (e.g., {{1},{2},{3},{4}}) and close over them using the relation: classes :: Ord a => Relation a -> Set (Set a) classes rel = limit (addimages rel) start where start = mapset sing (eles rel)