Ordered Pairs, Products, Sets versus Lists, Lambda Abstraction, Database Query

Transcription

1 Ordered Pairs, Products, Sets versus Lists, Lambda Abstraction, Database Query Jan van Eijck May 2, 2003 Abstract Ordered pairs, products, from sets to lists, from lists to sets. Next, we take a further look at lambda abstraction, explain the use of lambda abstraction for database query, and demonstrate how lambda abstracts can be used in Haskell.

2 Ordered Pairs The two sets {a, b} and {b, a} are equal: it follows from the extensionality principle that order of presentation does not count. The ordered pair of objects a and b is denoted by (a, b). Here, a is the first and b the second coordinate of (a, b). Ordered pairs behave according to the following rule: (a, b) = (x, y) = a = x b = y. Note that (a, b) = (b, a) only holds when a = b.

3 Cartesian Products The (Cartesian) product of the sets A and B is the set of all pairs (a, b) where a A and b B. In symbols: A B = { (a, b) a A b B }. Instead of A A one usually writes A 2. Here is an implementation of the list product operation in Haskell listproduct :: [a] -> [b] -> [(a,b)] listproduct xs ys = [ (x,y) x <- xs, y <- ys ]

4 This gives: Main> listproduct [1..4] [ A.. C ] [(1, A ),(1, B ),(1, C ),(2, A ),(2, B ),(2, C ), (3, A ),(3, B ),(3, C ),(4, A ),(4, B ),(4, C )] Main> listproduct [1..4] [True, False] [(1,True),(1,False),(2,True),(2,False),(3,True), (3,False),(4,True),(4,False)]

5 Useful Product Laws For arbitrary sets A, B, C, D the following hold: 1. (A B) (C D) = (A D) (C B), 2. (A B) C = (A C) (B C); (A B) C = (A C) (B C), 3. (A B) (C D) = (A C) (B D), 4. (A B) (C D) = (A C) (A D) (B C) (B D), 5. [(A C) B] [A (B D)] (A B) (C D).

6 Example Proof To be proved: (A B) C = (A C) (B C): : Suppose that p (A B) C. Then a A B and c C exist such that p = (a, c). Thus (i) a A or (ii) a B. (i). In this case, p A C, and hence p (A C) (B C). (ii). Now p B C, and hence again p (A C) (B C). Thus p (A C) (B C). Therefore, (A B) C (A C) (B C).

7 Example Proof, continued : Conversely, assume that p (A C) (B C). Thus (i) p A C or (ii) p B C. (i). In this case a A and c C exist such that p = (a, c); a fortiori, a A B and hence p (A B) C. (ii). Now b B and c C exist such that p = (b, c); a fortiori b A B and hence, again, p (A B) C. Thus p (A B) C. Therefore, (A C) (B C) (A B) C. The required result follows using Extensionality.

8 Ordered n-tuples Ordered n-tuples over some base set A, for every n N. Definition by recursion. 1. A 0 := { }, 2. A n+1 := A A n. Note that ordered n-tuples are pairs. From Sets to Lists Finally, let A = n N An. Then A is the set of all finite lists over A. Note that the list [a, b, c, d] gets represented as the pair (a, (b, (c, (d, )))).

9 Taking Lists as Basic Definition of lists in Haskell: [] is a list. If x is an object and l is a list, then x : l is a list, provided that the types agree. The type of a list is derived from the type of its objects: if x :: a, then lists of objects of that type have type [a]. Under the typing restrictions of Haskell, it is impossible to put objects of different types together in one list. The operation (:) has type a -> [a] -> [a].

10 Lists and List Equality data [a] = [] a : [a] deriving (Eq, Ord) Prelude> :t (:) (:) :: a -> [a] -> [a] instance Eq a => Eq [a] where [] == [] = True (x:xs) == (y:ys) = x==y && xs==ys _ == _ = False

11 List Ordering instance Ord a => Ord [a] where compare [] (_:_) = LT compare [] [] = EQ compare (_:_) [] = GT compare (x:xs) (y:ys) = primcompaux x y (compare xs ys) primcompaux :: Ord a => a -> a -> Ordering -> Ordering primcompaux x y o = case compare x y of EQ -> o; LT -> LT; GT -> GT

12 List indexing Consider the list indexing function (!!) :: does the following: Prelude> [ a..]!! 0 a Prelude> [ a..]!! 3 d How would you implement this? [a] -> Int -> a that (!!) :: [a] -> Int -> a (x:_)!! 0 = x (_:xs)!! n n>0 = xs!! (n-1) (_:_)!! _ = error "!!: negative index" []!! _ = error "!!: index too large"

13 Fundamental List Operations head :: [a] -> a head (x:_) = x tail :: [a] -> [a] tail (_:xs) = xs last :: [a] -> a last [x] = x last (_:xs) = last xs init :: [a] -> [a] init [x] = [] init (x:xs) = x : init xs null :: [a] -> Bool null [] = True null (_:_) = False

14 Lambda Abstraction A very convenient notation for function construction is by means of lambda abstraction. In this notation, λx.x+1 encodes the specification x x + 1. The lambda operator is a variable binder, so λx.x + 1 and λy.y + 1 denote the same function. In fact, every time we specify a function foo in Haskell by means of foo x y z = t we can also define foo by means of: foo = \ x y z -> t If the types of x, y, z, t are known, this also specifies a domain and a range. For if x :: a, y :: b, z :: c, t :: d, then λxyz.t has type a -> b -> c -> d.

15 Lambda Abstraction (2) Haskell allows construction of functions by means of lambda abstraction: Prelude> (\x -> x + 1) 4 5 Prelude> (\s -> "hello, " ++ s) "dolly" "hello, dolly" Prelude> :t (\s -> "hello, " ++ s) \s -> "hello, " ++ s :: [Char] -> [Char] Prelude> (\x y -> x^y)

16 Lambda Abstraction (3) Such functions can be passed as arguments: Prelude> map (\x -> x + 3) [1..5] [4,5,6,7,8] Prelude> filter (\x -> x^2 < 20) [1..10] [1,2,3,4] Prelude> ((\x -> x + 1). (\y -> y + 2)) 5 8

17 List Comprehension and Database Query module DB where type WordList = [String] type DB = [WordList] db :: DB db = [ ["release", "Blade Runner", "1982"], ["release", "Alien", "1979"], ["release", "Titanic", "1997"], ["release", "Good Will Hunting", "1997"], ["release", "Pulp Fiction", "1994"], ["release", "Reservoir Dogs", "1992"], ["release", "Romeo and Juliet", "1996"],

18 ["direct", "Brian De Palma", "The Untouchables"], ["direct", "James Cameron", "Titanic"], ["direct", "James Cameron", "Aliens"], ["direct", "Ridley Scott", "Alien"], ["direct", "Ridley Scott", "Blade Runner"], ["direct", "Ridley Scott", "Thelma and Louise"], ["direct", "Gus Van Sant", "Good Will Hunting"], ["direct", "Quentin Tarantino", "Pulp Fiction"], {-... -}

19 ["play", "Leonardo DiCaprio", "Romeo and Juliet", "Romeo"], ["play", "Leonardo DiCaprio", "Titanic", "Jack Dawson"], ["play", "Robin Williams", "Good Will Hunting", "Sean McGuire"], ["play", "John Travolta", "Pulp Fiction", "Vincent Vega"], ["play", "Harvey Keitel", "Reservoir Dogs", "Mr White"], {-... -}

20 The database can be used to define the following lists of database objects, with list comprehension. characters = nub [ x ["play",_,_,x] <- db ] movies = [ x ["release",x,_] <- db ] actors = nub [ x ["play",x,_,_] <- db ] directors = nub [ x ["direct",x,_] <- db ] dates = nub [ x ["release",_,x] <- db ] universe = nub (characters ++ actors ++ directors ++ movies ++ dates)

21 Next, define lists of tuples, again by list comprehension: direct = [ (x,y) ["direct",x,y] <- db ] act = [ (x,y) ["play",x,y,_] <- db ] play = [ (x,y,z) ["play",x,y,z] <- db ] release = [ (x,y) ["release",x,y] <- db ]

22 Finally, define one placed, two placed and three placed predicates by means of lambda abstraction. charp = \ x -> elem x characters actorp = \ x -> elem x actors moviep = \ x -> elem x movies directorp = \ x -> elem x directors datep = \ x -> elem x dates actp = \ (x,y) -> elem (x,y) act releasep = \ (x,y) -> elem (x,y) release directp = \ (x,y) -> elem (x,y) direct playp = \ (x,y,z) -> elem (x,y,z) play

23 Example Queries Give me the actors that also are directors. q1 = [ x x <- actors, directorp x ] Give me all actors that also are directors, together with the films in which they were acting. q2 = [ (x,y) (x,y) <- act, directorp x ]

24 Give me all directors together with their films and their release dates. The following is wrong. q3 = [ (x,y,z) (x,y) <- direct, (y,z) <- release ] The problem is that the two ys are unrelated. In fact, this query generates an infinite list. This can be remedied by using the equality predicate as a link: q4 = [ (x,y,z) (x,y) <- direct, (u,z) <- release, y == u ]

25 A Datatype for Sets module SetEq (Set,emptySet,isEmpty,inSet,subSet, insertset,deleteset,powerset,takeset, list2set,(!!!)) where import List newtype Set a = Set [a] instance Eq a => Eq (Set a) where set1 == set2 = subset set1 set2 && subset set2 set1

26 subset :: (Eq a) => Set a -> Set a -> Bool subset (Set []) _ = True subset (Set (x:xs)) set = (inset x set) && subset (Set xs) set inset :: (Eq a) => a -> Set a -> Bool inset x (Set s) = elem x s This gives: Main> Set [2,3,3,1,1,1] == Set [1,2,3] True

27 instance (Show a) => Show (Set a) where showsprec _ (Set s) str = showset s str showset [] str = showstring "{}" str showset (x:xs) str = showchar { (shows x (sh xs str)) where sh [] str = showchar } str sh (x:xs) str = showchar, (shows x (sh xs str)) This gives: SetEq> Set [1..10] {1,2,3,4,5,6,7,8,9,10}

28 emptyset :: Set a emptyset = Set [] isempty :: Set a -> Bool isempty (Set []) = True isempty _ = False

29 insertset :: (Eq a) => a -> Set a -> Set a insertset x (Set ys) inset x (Set ys) = Set ys otherwise = Set (x:ys) deleteset :: Eq a => a -> Set a -> Set a deleteset x (Set xs) = Set (delete x xs) list2set :: Eq a => [a] -> Set a list2set [] = Set [] list2set (x:xs) = insertset x (list2set xs)

30 powerset :: Eq a => Set a -> Set (Set a) powerset (Set xs) = Set (map (\xs -> (Set xs)) (powerlist xs)) takeset :: Eq a => Int -> Set a -> Set a takeset n (Set xs) = Set (take n xs) infixl 9!!! (!!!) :: Eq a => Set a -> Int -> a (Set xs)!!! n = xs!! n

31 Five Levels From the Set Theoretic Universe module Hierarchy where import SetEq data S = Void deriving (Eq,Show) empty :: Set S empty = Set [] v0 = empty v1 = powerset v0 v2 = powerset v1 v3 = powerset v2 v4 = powerset v3 v5 = powerset v4