Zipping Search Trees. Tom Schrijvers. with Denoit Desouter and Bart Demoen

Transcription

1 Zipping Search Trees Tom Schrijvers with Denoit Desouter and Bart Demoen

2 Motivation 2

3 Earlier Work 3

4 Earlier Work Monadic Constraint Programming T. S., P. Stuckey, P. Wadler. (JFP 09) Haskell 3

5 Earlier Work Monadic Constraint Programming T. S., P. Stuckey, P. Wadler. (JFP 09) Haskell C++ Search Combinators T. S., G. Tack, P. Wuille, H. Samulowitz, P. Stuckey. (CONSTRAINTS 13) 3

6 Earlier Work Monadic Constraint Programming T. S., P. Stuckey, P. Wadler. (JFP 09) Haskell C++ Search Combinators T. S., G. Tack, P. Wuille, H. Samulowitz, P. Stuckey. (CONSTRAINTS 13) Tor: extensible search with hookable disjunction T.S., M. Triska, B. Demoen. (SCP 13) Prolog 3

7 On implementing Prolog in Functional Programming M. Carlsson. (NGC 84) Prological Features in a Functional Setting R. Hinze. (FLOPS 98) Algebra of Logic Programming S. Seres, M. Spivey, T. Hoare. (ICLP 99) Typed Logic Variables in Haskell K. Claessen, P. Ljunglöf. (Haskell 00) Many FP models of tree search Escape from Zurg: An Exercise in Logic Programming M. Erwig. (JFP 04) Deriving Backtracking Monad Transformers R. Hinze. (ICFP 00) Backtracking, Interleaving and Terminating Monad Transformers O. Kyselyov, C. Shan, D. Friedman, A. Sabry. (ICFP 05) Algebras for Combinatorial Search M. Spivey. (JFP 09)... 4

8 Depth-First Search Model problem :: [A] Lazy lists naturally express DFS 5

9 Flexible Search Strategies problem :: MonadPlus m => m A Different strategies by instantiating m differently 6

10 Unrealistic Model Most systems have a hard-wired strategy (usually DFS) Highly optimized for fixed strategy Prolog / WAM SAT solvers LP solvers CP solvers... 7

11 Best of Both? 8

12 Best of Both? works for actual systems 8

13 Best of Both? works for actual systems easy to change strategy 8

14 Best of Both? works for actual systems easy to change strategy FP-based approach 8

15 Example Enumeration label :: MonadPlus m => [[Int]] -> m [Int] label [] = return [] label ([]:ls) = mzero label ((v:vs):ls) = liftm (v:) (label ls) `mplus` label (vs:ls) 9

16 label [[1..3],[1..3]] X #= 1 X #\= 1 Y #= 1 Y #/= 1 X #=2 X #= 3 Y #= 2 Y #= 3 Y #= 1 Y #/= 1 Y #= 1 Y #/= 1 Y #= 2 Y #= 3 Y #= 2 Y #= 3 10

17 With Depth Limit X #= 1 X #\= 1 Y #= 1 Y #/= 1 X #=2 X #= 3 Y #= 2 Y #= 3 Y #= 1 Y #/= 1 Y #= 1 Y #/= 1 Y #= 2 Y #= 3 Y #= 2 Y #= 3 11

18 Example Enumeration label :: MonadPlus m => Int -> [[Int]] -> m [Int] label _ [] = return [] label _ ([]:ls) = mzero label d ((v:vs):ls) = guard (d > 0) >> ( liftm (v:) (label (d-1) ls) `mplus` label (d-1) (vs:ls)) 12

19 Range of Expressible Heuristics Limits Depth Limit Discrepancy Limit Node Limit Backtracking Limit Credit Limit Restarts Optimization Iterative Deepening Branch and Bound Limited Discrepancy Search 13

20 Progress! works for actual systems easy to change strategy 14

21 O(n m) code problems heuristics 15

22 Not the Way to Go copy-paste-modify anti-pattern wasting programmer time error-prone non-optimal code quality reduced exploration of heuristics simple heuristic + complex search = very complex implementation 16

23 What We Want problems heuristics O(n+m) code 17

24 Zipping Approach = search heuristic search problem heuristic search zip composition operator 5518

25 Depth-Bounded Search Heuristic 19

26 Depth-Bounded Search Heuristic dbs d = do guard (d > 0) dbs (d-1) `mplus` dbs (d-1) 20

27 dbs 4 problem 21

28 zip (dbs 4) problem 21

29 Problem Solved! works for actual systems easy to change strategy 22

30 Remaining Challenges 1.How to specify zip? 2.How to implement it? 23

31 Derived Heuristics = Depth Limit Discrepancy Limit Both Limits zip (zip (dbs depth) (discbs disc)) problem 24

32 Derived Heuristics = Delay Node Limit Node Limit at Depth zip (and (delay depth) (nbs nodes)) problem 25

33 FP Model 26

34 Search Trees data Tree = Success Failure Or Tree Tree refied essence of tree search (encapsulated search in FLP ) Success `Or` (Failure `Or` Success) 27

35 Depth-First Search Semantics :: Tree - > [()] Failure = [] Success = [()] Or t 1 t 2 = t 1 ++ t 2 28

36 Overloaded Semantics class Search d where :: Tree - > d 29

37 Compositional Semantics class CSearch d where fail :: d succeed :: d Signature or :: d - > d - > d 30

38 Compositional Semantics instance CSearch d => Search d where Failure = fail Success = succeed Or g 1 g 2 = g 1 `or` g 2 31

39 DFS Algebra instance CSearch [()] where fail = [] succeed = [()] or = (++) 32

40 Counting Algebra instance CSearch Int where fail = 0 succeed = 1 or = (+) 33

41 Boolean Algebra instance CSearch Bool where fail = False succeed = True or = ( ) 34

42 Initial Algebra instance CSearch Tree where fail = Failure succeed = Success or = Or 35

43 No Monoid Laws fail `or` d fail d `or` fail fail d1 `or`(d2 `or` d3) (d1 `or`d2) `or` d3 36

44 No Monoid Laws fail `or` d fail d `or` fail fail d1 `or`(d2 `or` d3) (d1 `or`d2) `or` d3 36

45 Non-Monoidal Algebra newtype BFS a = L {unl :: [[a]]} instance CSearch (BFS ()) where fail = L [] succeed = L [[()]] or d1 d2 = demote (merge d1 d2) Algebras for Combinatorial Search M. Spivey. (JFP 09) 37

46 Non-Monoidal Algebra fail L [] fail `or` fail L [[]] 38

47 Conjunction 39

48 Conjunction Syntax data Tree = Success Failure Or Tree Tree And Tree Tree 40

49 Overloaded Semantics class Search d => Search d where :: Tree - > d 41

50 Syntactic Instance instance Search Tree where Success = Success Failure = Failure Or t1 t2 = Or t1 t2 And t1 t2 = go t1 where go Success go Failure = t2 = Failure go (Or t3 t4) = Or (go t3) (go t4) 42

51 Semantics Specification. Tree -> d (Tree -> d). (Tree -> Tree) (useful as default implementation) 43

52 Compositional Semantics class CSearch d => CSearch d where and :: d - > d - > d 44

53 Stronger Specification and succeed d d and d succeed d and d1 (and d2 d3) and (and d1 d2) d3 and fail d fail and (or d1 d2) d3 or (and d1 d3) (and d2 d3) 45

54 DFS Algebra instance Search [()] where p 1 `and` p 2 = [() x <- p 1, y <- p 2 ] 46

55 Counting Instance instance Search Int where and = (*) 47

56 Monadic Search 48

57 Side Effects During Search State e.g., collecting constraints, unification, learning,... I/O 49

58 50

59 onads to the rescue! 50

60 Monadic Interface class Monad m => MSearch m where mfail mor :: m a :: m a - > m a - > m a 51

61 Monadic Interface class Monad m => MSearch m where mfail mor :: m a :: m a - > m a - > m a instance MSearch m => Search (m ()) where fail or = mfail = mor succeed = return () 51

62 Monadic Interface class Monad m => MSearch m where mfail mor :: m a :: m a - > m a - > m a instance MSearch m => Search (m ()) where fail or = mfail = mor succeed = return () instance MSearch m => Search (m ()) where and = (>>) 51

63 Instances instance MSearch [] where mfail = [] mor = (++) 52

64 Instances instance MSearch [] where mfail = [] mor = (++) instance MSearch (StateT Subst []) 52

65 Instances instance MSearch [] where mfail = [] mor = (++) instance MSearch (StateT Subst []) instance MSearch (WriterT String []) 52

66 Only 2 Laws (+ monad laws) and succeed d d and d succeed d and d1 (and d2 d3) and (and d1 d2) d3 and fail d fail and (or d1 d2) d3 or (and d1 d3) (and d2 d3) 53

67 Only 2 Laws (+ monad laws) and succeed d d and d succeed d and d1 (and d2 d3) and (and d1 d2) d3 mfail >>= f mfail (mor d1 d2) >>= f mor (d1 >>= f) (d2 >>= f) 54

68 Zipping 55

69 Zipping Lists zip :: [a] -> [b] -> [(a,b)] zip [] l = [] zip l [] = [] zip (x:xs) (y:ys) = (x,y) : zip xs ys 56

70 Zipping Naturals data Nat = Z S Nat min :: Nat -> Nat -> Nat min Z n = Z min n Z = Z min (S x) (S y) = S (min x y) 57

71 Zipping Plain Trees data PTree = L F PTree PTree zip :: PTree -> PTree -> PTree zip L n = L zip n L = L zip (F l1 r1) (F l2 r2) = F (zip l1 l2) (zip r1 r2) 58

72 Zipping Search Trees Failure n = Failure Success n = Success (Or l r) Failure (Or l r) Success = Failure = Success (Or l1 r1) (Or l2 r2) = Or (l1 l2) (r1 r2) 59

73 Monoid Tree,,ε ε t t ε = Or ε ε t ε t l1 (l2 l3) (l1 l2) l3 60

74 Zip Syntax data Tree = Success Failure Or Tree Tree And Tree Tree Zip Tree Tree 61

75 Overloaded Semantics class Search d => Search d where :: Tree - > d 62

76 Syntactic Instance instance Search Tree where Success = Success Failure = Failure Or t1 t2 = Or t1 t2 And t1 t2 = and t1 t2 Zip t1 t2 = t1 t2 63

77 Semantics Specification. Tree -> d (Tree -> d). (Tree -> Tree) (useful as default implementation) 64

78 Compositional Semantics class CSearch d => CSearch d where zip :: d - > d - > d 65

79 Stronger Specification zip fail d fail zip succeed d succeed zip (or d1 d2) fail fail zip (or d1 d2) succeed succeed zip (or d1 d2) (or d3 d4) or (zip d1 d3) (zip d2 d4) zip d1 (zip d2 d3) zip (zip d1 d2) d3 66

80 Efficient Instances? 67

81 Not for non-trivial Monoidal Algebras fail (ZIPFAIL law) fail `zip` succeed (OR/FAIL monoid law) (fail `or` succeed) `zip` succeed (ZIPORSUCCEED law) succeed 68

82 69

83 Free instance with free-monad transformer newtype ForkT m a = F { unf :: m (Result m a) } data Result m a = Ret a Fork (ForkT m a) (ForkT m a) 70

84 Free instance with free-monad transformer instance Monad m => Monad (ForkT m) where return = F. return. Ret m >>= f = F (unf m >>= go) where go (Ret x) = unf (f x) go (Fork l r) = return (Fork (l >>= f) (r >>= f)) 71

85 Free instance with free-monad transformer instance MSearch m => MSearch (ForkT m) where mfail = F mfail mor l r = F $ return (Fork l r) suspend disjunctions 72

86 Run runf :: MSearch m => ForkT m a - > m a runf m = unf m >>= go where go (Ret x) = return x go (Fork l r) = mor (go l) (go r) resume disjunctions 73

87 Lemma comp = runf comp for comp :: MSearch m => m A 74

88 Zip Implementation instance MSearch m => CSearch (ForkT m ()) where synchronize disjunctions zip l r = F $ unf l >>= gol where gol (Ret ()) = unf succeed gol (Fork l1 r1) = unf r >>= gor gor (Ret ()) = unf succeed gor (Fork l2 r2) = unf $ or (zip l1 l2) (zip r1 r2) 75

89 Theorm comp = runf comp for comp :: CSearch d => d 76

90 Unrealistic Solution Hard to add ForkT to existing systems - cross-cutting - overrides definition of (>>=) Prolog / WAM SAT solvers LP solvers CP solvers... 77

91 Implementation Alternative Yield : Mainstream Delimited Continuations R. James, A. Sabry. (TPDC 11) 78

92 Free instance with free-monad transformer instance MSearch m => MSearch (ForkT m) where mfail = lift mfail mor l r = shift (\k - > Fork (l >>= k) (r >>= k)) suspend disjunctions 79

93 Run runf :: MSearch m => ForkT m a - > m a runf m = unf (reset m >>= go) where go (Ret x) = return x go (Fork l r) = lift (mor (runf l) (runf r)) resume disjunctions 80

94 Delimited Continuations instance MSearch m => CSearch (ForkT m ()) synchronize disjunctions where zip l r = reset l >>= gol where gol (Ret ()) = succeed gol (Fork l1 r1) = reset r >>= gor gor (Ret ()) = succeed gor (Fork l2 r2) = or (zip l1 l2) (zip r1 r2) 81

95 Port to Prolog 82

96 Delimited Continuations for Prolog Not a standard Prolog feature 83

97 Delimited Continuations for Prolog Not a standard Prolog feature Easy to implement in CPS-based BinProlog Logic Programming and Logic Grammars with First-order Continuations. P. Tarau, V. Dahl. (LOPSTR 94) 83

98 Delimited Continuations for Prolog Not a standard Prolog feature Easy to implement in CPS-based BinProlog Logic Programming and Logic Grammars with First-order Continuations. P. Tarau, V. Dahl. (LOPSTR 94) New WAM extension Delimited continuations for Prolog. T.S., B. Demoen, B. Desouter, J. Wielemaker. (submitted to ICLP 13) 83

99 Wrapping Up 84

100 Summary zipping search trees to get modular search heuristics compatible with a fixed search strategy syntactic specification implemented with delimited continuations port to Prolog 85

101 Future Work variations on zip swapping branches other functors 86

102 Thank You! 87