Lecture 01 May 2, May 4

Save this PDF as:

Size: px
Start display at page:

Transcription

1 CS 860: Quantum Algorithms and Complexity Spring 2006 Lecture 0 May 2, May 4 Lecturer: Andris Ambainis Scribe: David L. Yeung 0 Course Outline 0. Topics covered in this course. Quantum algorithms for graph problems 2. Quantum lower bounds (a) versions of the adversary method (b) limitations of the adversary method (c) the polynomial method (d) time-space lower bounds 3. Quantum random access codes 4. Quantum complexity classes (a) quantum algorithms with advice (b) quantum interactive proofs; quantum zero knowledge proofs 5. Quantum coin flipping 0.2 Course Requirements The requirements for the students who are registered are:. Scribe notes for 2 to 3 lectures (20%), 2. Complete 2 to 3 homework assignments (40%), 3. Paper presentation: these will take place at the end of term, with one presentation per lecture period (40%). 0-

2 Quantum Complexity of Graph Problems. Problem Definitions Beginning in today s lecture, we will consider three problems on graphs, and examine the complexity of the quantum algorithms. Given a graph G, we want to solve the following problems:. Connectivity We want to determine if G is connected (and find the connected components). 2. Maximum/perfect matching A matching of a graph is a set of edges of G with no vertices in common. A maximum matching is a matching that includes as many edges as possible. A perfect matching is one that covers all vertices of the graph. Note that a perfect matching is also a maximum matching. We want to determine if G has a perfect matching (or we may want to find the maximum matching). 3. Triangle A triangle in a graph is a set of three vertices with the property that there is an edge between each pair of them. We want to determine if a graph has triangles (and more generally, we want to determine if it has a clique of size k). In this course, we will typically use the adjacency matrix representation for graphs. In particular, a graph G is specified by variables g i,j which are indexed by pairs of vertices (i, j): { if (i, j) is an edge, g ij = 0 if (i, j) is not an edge. We access these variables by means of a black box that stores the graph and answers the query: i, j g i,j. That is, we query the black box with a pair of vertices, and it tells us whether or not they are joined by an edge..2 Complexity of the Problems There are two ways of looking at the complexity:. Query complexity We count only the number of queries to the black box, and ignore how much time the overall computation takes. 2. Time complexity We are concerned with the overall computation time. We want both the number of queries and the overall computation time to be small. We will primarily be concerned about the time complexity. 0-2

3 2 Computational Model 2. Classical algorithm with quantum subroutines For our computational model, we will be using classical algorithms which will make calls to quantum subroutines. For the three algorithms we re considering, it turns out to be enough to define only a few quantum subroutines. We first describe these subroutines, and later we will describe the classical algorithms which makes calls to these subroutines. (We will not explain how these quantum subroutines are implemented. For such details, see, e.g., Nielsen and Chuang [NC00].) 2.2 Subroutine : Grover s search for one of k items We have N boolean variables X,..., X N {0, }, of which k have a value of (we call these marked ). In other words, {i : X i = } = k (where k is unknown). The task is to find i : X i =, that is, we want to find one of the k variables which is marked. There s a subroutine that, with probability, ( ) N finds some i : X i = in O log queries, if such an i exists, and k ( N ) outputs no such i after O log queries, if no such i exists. 2.3 Subroutine 2: Grover s search for all k items Instead of finding one of the k items, this variant of the above subroutine finds all k items: ( Nk ) finds all i : X i = in O log queries, if such i exist, and ( N ) outputs no such i after O log queries (the same as in Subroutine ), if no such i exists. Note that the complexity of the above subroutines is given in terms of queries. The time complexity is essentially the same (with possibly an extra factor of log N). 3 Problem : Graph Connectivity 3. The Breadth-First Search (BFS) algorithm The first of the three problems which we will study is graph connectivity. Given a graph G such as in Figure, we want to determine if G is connected (if there is a path from every vertex to every other vertex). 0-3

4 B D G C A F E Figure. An example graph G which is connected. The classical algorithm works by choosing an arbitrary vertex, say A, and building either a Breadth-First Search (BFS) tree or a Depth-First Search (DFS) tree starting at that vertex. If the tree does not include a particular vertex v, then we know that vertex v is not reachable from A. The Breadth-First Search (BFS) algorithm:. Let d(v) = for all v V. (Mark every vertex as unvisited.) 2. Let d(a) = 0, Q = {A}. (Assign the starting vertex a distance of 0, and create a queue containing only it.) 3. While Q is non-empty: (a) Let u = first(q). (Get the first vertex from the queue.) (b) Let V = {v g u,v =, d(v) = }. (Find all of its unvisited neighbours.) (c) For all v V, let d(v) = d(u) +. (Mark all the neighbours of u as visited by assigning each of them a distance of more than u.) (d) Add all v V to the end of Q, and remove u. Figure 2 shows the BFS built for G starting at vertex A. The algorithm evolves the queue Q as follows (the distance assigned to each vertex is given in superscript): {A 0 } {B, C, E } {C, E, D 2 } {E, D 2, F 2 } {D 2, F 2 } {F 2, G 3 } {G 3 } {}. The algorithm terminates when Q is empty. 0-4

5 B D G A C F E Level: Figure 2. The Breadth-First Search (BFS) tree for the graph shown in Figure. What is the complexity of this algorithm? The most expensive step is Step 3(b) the complexity of this step is the same as the number of vertices n, and thus Step 3(b) takes O(n) time. Furthermore, Step 3 is repeated n times. Therefore, the total running time of the classical algorithm is O(n 2 ). The idea behind the quantum version of this algorithm (due to Dürr et al. [DHHM04]) is to take Step 3(b), and substitute Grover s search in its place. We introduce the notation Õ( ) to mean that we ignore a polylog factor in the running time, i.e., we ve dropped polynomials in log n. Theorem 3.. The BFS tree can be found by a quantum algorithm in time Õ(n 3 2 ) Proof: Substitute Subroutine 2 in Step 3(b). Formally, we define the variables: { if g u,v =, d(v) = - X v = 0 otherwise Then we run the quantum subroutine on these variables. Each variable can be checked in 2 operations (we need to check that g u,v = and d(v) = ), so the total running time for this step is the same order as for Subroutine Running Time Analysis What s the running time of the quantum algorithm? Let n be the number of vertices in G, and let V be the set of vertices found in Step 3(b) (then V is the number of vertices found). Note that for the quantum version of Step 3(b), the order of the number of queries is: 0-5

6 ( n V ) O log if V, and O ( n log ) if V = 0. We can be more specific. Let V u be the set of unvisited neighbours V, found in Step 3(b), for the vertex u. Since each vertex u V will be added to the queue Q once in Step 3, the sum u n Vu will give us a bound for the running time of the whole algorithm: n Vu = n Vu (since n is independent of u) u u n n V u (by the Cauchy-Schwartz inequality) u n n n (each vertex is visited at most once, so u V n n) n 3 2 Thus, we have that u n Vu n 3 2, and it is easy to see that the running time of all the times that Step 3(b) is invoked is O(n 3 2 log ). Every other step in the algorithm takes less time than this, so the running time of the algorithm is dominated by the running time of Step 3(b). There is one more point to remember. We must choose correctly so that the algorithm works. We are invoking the quantum subroutine n times, and we want a high probability that the subroutine works every time. We can choose =. Then the probability that the 3n subroutine is incorrect in one call is less than, and the probability that it fails in (at least 3n one of) n calls is at most n =. 3n 3 Thus, we can find the BFS tree for a graph with the above quantum algorithm, and since graph connectivity reduces to BFS (and checking every vertex), we can check for graph connectivity with a quantum algorithm in Õ(n 3 2 ) time. 4 Problem 2: Matching 4. Definition and Previous Results Given a graph G, a matching of the graph is a set of edges with the property that every vertex is incident to at most one edge. A maximum matching is a matching that has the largest possible number of edges, and a perfect matching is one in which every vertex is incident to exactly one edge. (Note that this means every perfect matching is also a maximum matching but the converse is not true.) Figure 3(a) shows two matchings for a graph. 0-6

7 (a) A E (b) not matched B F in matching C G not in matching D H not matched Figure 3. (a) A bipartite graph G with two matchings shown. The matching shown in bold is maximum. (b) An augmenting path a path that begins and ends in a free vertex and alternates between free and matched edges. The best classical algorithm for finding maximum matchings is due to Mucha and Sankowski [MS04] and has running time O(n ω ), where ω is the exponent of the best matrix multiplication algorithm. Currently, the best running time is order O(n ). We will work with an older (and simpler) algorithm, due to Hopcroft and Karp [HK73], with running time O(n 2.5 ). We will derive a quantum algorithm from this algorithm, using the same ideas as before, with the resulting running time of Õ(n2 ). 4.2 The Hopcroft-Karp Algorithm The basic idea is to search for an augmenting path, which is a path that begins and ends in a vertex not incident to any edge in the matching, and alternates between free and matched edges. Figure 3(b) shows an example of an augmenting path, which has 2 matched edges and 3 unmatched edges. Note that we can remove the 2 edges from the matching and add the 3 edges in their place, which increases the size of the matching by. Lemma 4.. A matching is not maximum there exists an augmenting path. Proof: The direction is clear, since we can increase the size of the matching by as in the above example. We will prove the direction. Suppose we are given a graph G, such as in Figure 4, with a non-maximum matching M. Since M is not maximum, there exists some maximum matching M larger than M. Now, consider the connected components in M M. Note that every vertex is incident to at most 2 edges in M M (since every vertex is incident to at most edge in each of 0-7

8 M non-maximum matching M some maximum matching Figure 4. A graph with 2 connected components, a non-maximum matching M and a maximum matching M. Cycle: Path: ( ) M non-maximum matching M some maximum matching Figure 5. Each connected component in M M is either a cycle or a path. M and M ). Therefore, each connected component is either a cycle or a path. Figure 5 illustrates the two cases. If a connected component is a cycle, it must have the same number of edges from M as from M. On the other hand, if a connected component is a path, then it either has the same number of edges from M as from M, or it has exactly one more edge from one than from the other. Since M is a maximum matching while M is not, M has more edges than M and there must be at least one augmenting path in some connected component of M M. In fact, we can improve this lemma. If we have a lot of edges missing in our matching, the augmenting paths will be small. Lemma 4.2. If we have a non-maximum matching M with k fewer edges than the maximum matching M, that is, if M M k, then there is an augmenting path of length at most n k. 0-8

9 Proof: The proof is essentially the same as the above, but with more bookkeeping. Again, we look at the connected components of M M. In each of these connected components, the number of edges from M and M will either be the same, or there will be one more edge from M. Thus, there are at least k components with one more edge from M than from M (these are augmenting paths). The largest possible matching is a perfect matching, which matches every vertex, so M n. Since there are at least k augmenting paths, there exists an augmenting path 2 with at most M n edges from M. This augmenting path has length at most n. k 2k k We are now prepared for the (classical) Hopcroft-Karp matching algorithm. We use the expression add the augmenting path to the matching as a short-hand to mean that the edges in the augmenting path already in the matching should be removed, and the edges in the augmenting path not in the matching should be added. The Hopcroft-Karp Matching Algorithm [HK73] While there exists an augmenting path, repeat the following:. Let d be the minimum length of an augmenting path. 2. Find a maximal set of augmenting paths of length d. (That is, find a set of augmenting paths after adding which there are no more augmenting paths of length (at most) d.) 3. Add those augmenting paths to the matching. Note that Step is just a Breadth-First Search (BFS), while Step 2 is a Depth-First Search (DFS), as we will show below in Section 4.3. Classically, each of Steps and 2 takes time O(n 2 ), but in the quantum case they can be implemented in time Õ(n 3 2 ). So the running time of the algorithm is just that multiplied by the number of repetitions of the main cycle of the algorithm. Lemma 4.3. The number of repetitions of the main loop of the Hopcroft-Karp algorithm is O( n) (in fact, it is at most 2 n). Proof: By Lemma 4.2, if we have a non-maximum matching M with n fewer edges than the maximum matching M (that is, M M n), then there is an augmenting path of length at most n n = n < n. By the contrapositive of this lemma, if the shortest augmenting path has length n or greater, then M > M n. In every iteration of the main loop of the Hopcroft-Karp algorithm, we are adding a maximum set of augmenting paths, so the length of the shortest augmenting path d is increasing with each iteration: d =, 2,..., n. In particular, after n iterations we have d > n, at which point (by the contrapositive of Lemma 4.2) there are fewer than n edges missing in the current matching M. It then takes at most another n iterations to find the perfect matching. 0-9

10 (a) (b) A F A F B G B G C H C H D I D I E J E J Figure 6. (a) A graph with a (non-maximum) matching. Solid edges are in the matching and dotted edges are free. (b) The graph with orientations assigned to the edges. An augmenting path must begin at B or D and end at G or I. 4.3 Finding augmenting paths Figure 6(a) shows a graph with a (non-maximum) matching of size 3. To increase the size of this matching, we must do 2 things: () find the shortest augmenting path, and then (2) find a maximum set of augmenting paths of the same length. We will show how the first of these reduces to BFS, while the second reduces to DFS. We ve shown above that BFS can be implemented in time Õ(n 3 2 ) in the quantum model, and we will show below that the same time complexity holds for DFS. To begin, we create a directed graph by assigning edge directions: for example, we make edges in the matching point to the left and edges not in the matching point to the right. The result is illustrated in Figure 6(b). Note that now an augmenting path is just a path respecting the directions of the graph, starting in an unmatched vertex on the left (one of B or D), and ending in an unmatched vertex on the right (one of G or I). To find the shortest augmenting path, we build a BFS forest starting at the vertices B and D, as shown in Figure 7. The shortest augmenting path found in our example is {(B, H), (H, C), (C, G)}, with a length of 3. This can be found in time Õ(n 3 2 ) by the quantum algorithm of Section 3.. We now verify that DFS can also be implemented in Õ(n 3 2 ) time with a quantum algorithm. 0-0

11 G B H C I D J E Level: Figure 7. BFS forest for the graph shown in Figure The Depth-First Search (DFS) Algorithm We show how quantum Subroutine can be helpful in speeding up DFS. The algorithm below finds a maximal set of paths of length d. In particular, paths within a set are vertex-disjoint (each vertex belongs to at most path). The Depth-First Search (DFS) algorithm:. Let u(v) = for all v V. (Mark every vertex as unvisited.) 2. Repeat while there exists s : level(s) = 0, u(s) =... (Pick an unmatched vertex on the left that hasn t been visited.) (a) Set s 0 = s, l = 0, u(s) = 0 (Mark vertex as visited and try to build an augmenting path with it as a starting point.) (b) Repeat until l = : i. If l = d, add {(s 0, s ), (s, s 2 ),..., (s d, s d )} to the matching (and go back to start of Step 2). (If an augmenting path of length d has been found, add it to the matching.) ii. Otherwise, use Subroutine to find v : level(v) = l +, g sl,v =, u(v) =. (Find a neighbour on the next level which hasn t been visited yet.) iii. If found, set s l+ = v, u(v) = 0, l = l +. (Increase the depth of the search.) iv. Otherwise, let l = l. (Go back one level of depth and try another branch.) The DFS algorithm terminates after all augmenting paths of length d have been found and added to the matching. 0-

12 4.5 Running Time Analysis The analysis of the DFS algorithm is somewhat similar to that of the BFS algorithm we analysed earlier in Section 3.2. We want to bound the complexity of Step 2(b)ii; the complexity of every one of the the other steps is O(n). For each particular vertex v, Step 2(b)ii may be performed multiple times. Lemma 4.4. The time for all runs of Subroutine with s l = v is O ( nd v log ), where dv is the number of successful runs, O ( n log ) if dv = 0, i.e., there were no successful runs. Proof: Suppose that there are d v successful runs. What s the running time for the ith run? During the ith run, there are at least d v i + vertices still left to be found, since vertex is found in the current ( run and d v i will be found in future runs. Thus, for ith run, ) the running time is O n log d v i+. Now we sum these over all i from to d v : d v dv n n d v i + = i 2 nd v i= In a sense, one can think of the multiple runs of Subroutine as one run of Subroutine 2, distributed over time (i.e., the marked items not all found at once, but one-by-one). To get the running time of the DFS algorithm, we have to sum up these running times over all vertices of G. In other words, we want to bound v ndv. First, it is easy to see that v:d v=0 n n n. Then: ndv = n dv (since n is independent of v) i= v v n n d v (by the Cauchy-Schwartz inequality) v n n n (each vertex can be chosen at most once, so v d v n) n 3 2 Thus, the quantum version of DFS takes time O(n 3 2 log ), for error. Now we are ready to analyse the running time of the quantum version of the Hopcroft- Karp matching algorithm. Recall (Lemma 4.3) that the main loop of the algorithm makes 0-2

13 O( n) repetitions. In each iteration, one call is made to each of the quantum BFS and DFS algorithms, both of which we have shown have running time O(n 3 2 log ). Choosing = n C for a sufficiently large constant C, we see that the running time of the quantum matching algorithm is Õ(n2 ), compared to the classical Hopcroft-Karp algorithm which has running time in O(n 2.5 ). 5 A few related Open Problems We briefly mention a few open problems related to the above:. Improving the matching algorithm Can the running time of Õ(n2 ) be improved? 2. Quantum complexity of network flows The network flow problem is closely related to the problem of maximum bipartite matching Figure 8. Graph of a single-source single-sink network flow. Suppose that we are given a flow network with n vertices, m edges, and integer capacities bounded by U, such as in Figure 8. The classical running time is dependent on m, n, and log U. The fastest known quantum algorithm (due to Ambainis and Špalek [AŠ06]) has running time O(min(n 7 6 mu 3, num) log n). If U = (that is, the capacities are either 0 or ), then the quantum algorithm is better than any known classical algorithm. Can this be improved? It turns out that as the maximum capacity becomes larger than, the quantum algorithm becomes no better than the classical ones. Can one design a quantum algorithm so that the dependence on U is eliminated? 3. Quantum algorithm for matrix multiplication There is no graph structure in the matrix multiplication problem. However, the matrix multiplication problem is related to matching by the fact that the best classical 0-3

14 algorithm known for matching [MS04] uses matrix multiplication as a subroutine (see Section 4. above). Thus, if matrix multiplication can be performed by a quantum algorithm in time less than Õ(n2 ), the running time of the quantum matching algorithm will also be improved. 4. Quantum algorithm for deciding if det(a) = 0? We want to determine if det(a) = 0 without necessarily computing it. A little bit is known regarding possible approaches to tackling questions #3 and #4. Suppose that we re given n n matrices A, B, and C, and we want to check if AB = C. The best quantum algorithm known (due to Buhrman and Špalek [BŠ06]) has running time Õ(n 5 3 ), while the best classical algorithm (a randomized algorithm given by Freivalds [Fre79]) has running time O(n 2 ). The idea behind the classical randomized algorithm is as follows: pick a random vector x, and check if A(Bx) = Cx by right-multiplication. Clearly, if the equality AB = C holds, then ABx = Cx will also hold. On the other hand, if AB C, then with high probability, ABx Cx for a random x. In the next lecture, we will cover random walks and Markov chains, and develop a quantum version of random walk to solve the element k-distinctness problem. We will be building up to a quantum algorithm to solve the third of our three graph problems, namely, recognizing triangles (and more generally, k-cliques). References [AŠ06] [BŠ06] Andris Ambainis and Robert Špalek. Quantum Algorithms for Matching and Network Flows. In Proceedings of the 23rd International Symposium on Theoretical Aspects of Computer Science (STACS 2006), pages Springer LNCS 3884, Harry Buhrman and Robert Špalek. Quantum Verification of Matrix Products. In Proceedings of the Seventeenth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2006), pages , Miami, Florida, USA, ACM Press. [DHHM04] Christoph Dürr, Mark Heiligman, Peter Høyer, and Mehdi Mhalla. Quantum Query Complexity of Some Graph Problems. In Proceedings of the 3st International Colloquium on Automata, Languages and Programming (ICALP 2004), pages , Turku, Finland, July

15 [Fre79] Rusins Freivalds. Fast Probabilistic Algorithms. In Proceedings of the 8th Symposium on Mathematical Foundations of Computer Science (MFCS 979), pages 57 69, 979. [HK73] John E. Hopcroft and Richard M. Karp. An n 5 2 Algorithm for Maximum Matchings in Bipartite Graphs. SIAM Journal on Computing, 2(4):225 23, 973. [MS04] [NC00] Marcin Mucha and Piotr Sankowski. Maximum Matchings via Gaussian Elimination. In Proceedings of the 45th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2004), pages , Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, Cambridge, United Kingdom,

Solutions to Exercises 8

Discrete Mathematics Lent 2009 MA210 Solutions to Exercises 8 (1) Suppose that G is a graph in which every vertex has degree at least k, where k 1, and in which every cycle contains at least 4 vertices.

princeton univ. F 13 cos 521: Advanced Algorithm Design Lecture 6: Provable Approximation via Linear Programming Lecturer: Sanjeev Arora

princeton univ. F 13 cos 521: Advanced Algorithm Design Lecture 6: Provable Approximation via Linear Programming Lecturer: Sanjeev Arora Scribe: One of the running themes in this course is the notion of

Polynomial Degree and Lower Bounds in Quantum Complexity: Collision and Element Distinctness with Small Range

THEORY OF COMPUTING, Volume 1 (2005), pp. 37 46 http://theoryofcomputing.org Polynomial Degree and Lower Bounds in Quantum Complexity: Collision and Element Distinctness with Small Range Andris Ambainis

Notes on Matrix Multiplication and the Transitive Closure

ICS 6D Due: Wednesday, February 25, 2015 Instructor: Sandy Irani Notes on Matrix Multiplication and the Transitive Closure An n m matrix over a set S is an array of elements from S with n rows and m columns.

CSL851: Algorithmic Graph Theory Semester I Lecture 1: July 24

CSL851: Algorithmic Graph Theory Semester I 2013-2014 Lecture 1: July 24 Lecturer: Naveen Garg Scribes: Suyash Roongta Note: LaTeX template courtesy of UC Berkeley EECS dept. Disclaimer: These notes have

CS2 Algorithms and Data Structures Note 11. Breadth-First Search and Shortest Paths

CS2 Algorithms and Data Structures Note 11 Breadth-First Search and Shortest Paths In this last lecture of the CS2 Algorithms and Data Structures thread we will consider the problem of computing distances

Chapter 4. Trees. 4.1 Basics

Chapter 4 Trees 4.1 Basics A tree is a connected graph with no cycles. A forest is a collection of trees. A vertex of degree one, particularly in a tree, is called a leaf. Trees arise in a variety of applications.

5.1 Bipartite Matching

CS787: Advanced Algorithms Lecture 5: Applications of Network Flow In the last lecture, we looked at the problem of finding the maximum flow in a graph, and how it can be efficiently solved using the Ford-Fulkerson

Math 443/543 Graph Theory Notes 4: Connector Problems

Math 443/543 Graph Theory Notes 4: Connector Problems David Glickenstein September 19, 2012 1 Trees and the Minimal Connector Problem Here is the problem: Suppose we have a collection of cities which we

Approximated Distributed Minimum Vertex Cover Algorithms for Bounded Degree Graphs

Approximated Distributed Minimum Vertex Cover Algorithms for Bounded Degree Graphs Yong Zhang 1.2, Francis Y.L. Chin 2, and Hing-Fung Ting 2 1 College of Mathematics and Computer Science, Hebei University,

Lecture 7: Approximation via Randomized Rounding

Lecture 7: Approximation via Randomized Rounding Often LPs return a fractional solution where the solution x, which is supposed to be in {0, } n, is in [0, ] n instead. There is a generic way of obtaining

Depth-Independent Lower Bounds on the Communication Complexity of Read-Once Boolean Formulas

Depth-Independent Lower Bounds on the Communication Complexity of Read-Once Boolean Formulas Rahul Jain 1, Hartmut Klauck 2, and Shengyu Zhang 3 1 Centre for Quantum Technologies and Department of Computer

Finding and counting given length cycles

Finding and counting given length cycles Noga Alon Raphael Yuster Uri Zwick Abstract We present an assortment of methods for finding and counting simple cycles of a given length in directed and undirected

Quantum Computation CMU BB, Fall 2015

Quantum Computation CMU 5-859BB, Fall 205 Homework 3 Due: Tuesday, Oct. 6, :59pm, email the pdf to pgarriso@andrew.cmu.edu Solve any 5 out of 6. [Swap test.] The CSWAP (controlled-swap) linear operator

10. Graph Matrices Incidence Matrix

10 Graph Matrices Since a graph is completely determined by specifying either its adjacency structure or its incidence structure, these specifications provide far more efficient ways of representing a

Relations Graphical View

Relations Slides by Christopher M. Bourke Instructor: Berthe Y. Choueiry Introduction Recall that a relation between elements of two sets is a subset of their Cartesian product (of ordered pairs). A binary

Lecture 9. 1 Introduction. 2 Random Walks in Graphs. 1.1 How To Explore a Graph? CS-621 Theory Gems October 17, 2012

CS-62 Theory Gems October 7, 202 Lecture 9 Lecturer: Aleksander Mądry Scribes: Dorina Thanou, Xiaowen Dong Introduction Over the next couple of lectures, our focus will be on graphs. Graphs are one of

Sample Problems in Discrete Mathematics

Sample Problems in Discrete Mathematics This handout lists some sample problems that you should be able to solve as a pre-requisite to Computer Algorithms Try to solve all of them You should also read

Analysis of Algorithms, I

Analysis of Algorithms, I CSOR W4231.002 Eleni Drinea Computer Science Department Columbia University Thursday, February 26, 2015 Outline 1 Recap 2 Representing graphs 3 Breadth-first search (BFS) 4 Applications

COLORED GRAPHS AND THEIR PROPERTIES

COLORED GRAPHS AND THEIR PROPERTIES BEN STEVENS 1. Introduction This paper is concerned with the upper bound on the chromatic number for graphs of maximum vertex degree under three different sets of coloring

The Goldberg Rao Algorithm for the Maximum Flow Problem

The Goldberg Rao Algorithm for the Maximum Flow Problem COS 528 class notes October 18, 2006 Scribe: Dávid Papp Main idea: use of the blocking flow paradigm to achieve essentially O(min{m 2/3, n 1/2 }

(67902) Topics in Theory and Complexity Nov 2, 2006. Lecture 7

(67902) Topics in Theory and Complexity Nov 2, 2006 Lecturer: Irit Dinur Lecture 7 Scribe: Rani Lekach 1 Lecture overview This Lecture consists of two parts In the first part we will refresh the definition

Separation in Quantum and Randomized Query Complexity based on Cheat Sheet model

Separation in Quantum and Randomized Query Complexity based on Cheat Sheet model Hardik Bansal Advisor : Prof. Rajat Mittal Abstract Recent result by Shalev [1] have shown super-quadratic separation between

Graph. Consider a graph, G in Fig Then the vertex V and edge E can be represented as:

Graph A graph G consist of 1. Set of vertices V (called nodes), (V = {v1, v2, v3, v4...}) and 2. Set of edges E (i.e., E {e1, e2, e3...cm} A graph can be represents as G = (V, E), where V is a finite and

CS5314 Randomized Algorithms. Lecture 16: Balls, Bins, Random Graphs (Random Graphs, Hamiltonian Cycles)

CS5314 Randomized Algorithms Lecture 16: Balls, Bins, Random Graphs (Random Graphs, Hamiltonian Cycles) 1 Objectives Introduce Random Graph Model used to define a probability space for all graphs with

Minimum cost maximum flow, Minimum cost circulation, Cost/Capacity scaling

6.854 Advanced Algorithms Lecture 16: 10/11/2006 Lecturer: David Karger Scribe: Kermin Fleming and Chris Crutchfield, based on notes by Wendy Chu and Tudor Leu Minimum cost maximum flow, Minimum cost circulation,

Minimize subject to. x S R

Chapter 12 Lagrangian Relaxation This chapter is mostly inspired by Chapter 16 of [1]. In the previous chapters, we have succeeded to find efficient algorithms to solve several important problems such

4 Basics of Trees. Petr Hliněný, FI MU Brno 1 FI: MA010: Trees and Forests

4 Basics of Trees Trees, actually acyclic connected simple graphs, are among the simplest graph classes. Despite their simplicity, they still have rich structure and many useful application, such as in

Definition 11.1. Given a graph G on n vertices, we define the following quantities:

Lecture 11 The Lovász ϑ Function 11.1 Perfect graphs We begin with some background on perfect graphs. graphs. First, we define some quantities on Definition 11.1. Given a graph G on n vertices, we define

CMSC 451: Graph Properties, DFS, BFS, etc.

CMSC 451: Graph Properties, DFS, BFS, etc. Slides By: Carl Kingsford Department of Computer Science University of Maryland, College Park Based on Chapter 3 of Algorithm Design by Kleinberg & Tardos. Graphs

Exponential time algorithms for graph coloring

Exponential time algorithms for graph coloring Uriel Feige Lecture notes, March 14, 2011 1 Introduction Let [n] denote the set {1,..., k}. A k-labeling of vertices of a graph G(V, E) is a function V [k].

Social Media Mining. Graph Essentials

Graph Essentials Graph Basics Measures Graph and Essentials Metrics 2 2 Nodes and Edges A network is a graph nodes, actors, or vertices (plural of vertex) Connections, edges or ties Edge Node Measures

8.1 Min Degree Spanning Tree

CS880: Approximations Algorithms Scribe: Siddharth Barman Lecturer: Shuchi Chawla Topic: Min Degree Spanning Tree Date: 02/15/07 In this lecture we give a local search based algorithm for the Min Degree

Approximation Algorithms

Approximation Algorithms or: How I Learned to Stop Worrying and Deal with NP-Completeness Ong Jit Sheng, Jonathan (A0073924B) March, 2012 Overview Key Results (I) General techniques: Greedy algorithms

Homework 15 Solutions

PROBLEM ONE (Trees) Homework 15 Solutions 1. Recall the definition of a tree: a tree is a connected, undirected graph which has no cycles. Which of the following definitions are equivalent to this definition

Lecture 11: Graphical Models for Inference

Lecture 11: Graphical Models for Inference So far we have seen two graphical models that are used for inference - the Bayesian network and the Join tree. These two both represent the same joint probability

Problem Set 7 Solutions

8 8 Introduction to Algorithms May 7, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Handout 25 Problem Set 7 Solutions This problem set is due in

Math 4707: Introduction to Combinatorics and Graph Theory

Math 4707: Introduction to Combinatorics and Graph Theory Lecture Addendum, November 3rd and 8th, 200 Counting Closed Walks and Spanning Trees in Graphs via Linear Algebra and Matrices Adjacency Matrices

Lecture 1: Course overview, circuits, and formulas

Lecture 1: Course overview, circuits, and formulas Topics in Complexity Theory and Pseudorandomness (Spring 2013) Rutgers University Swastik Kopparty Scribes: John Kim, Ben Lund 1 Course Information Swastik

2.1 Complexity Classes

15-859(M): Randomized Algorithms Lecturer: Shuchi Chawla Topic: Complexity classes, Identity checking Date: September 15, 2004 Scribe: Andrew Gilpin 2.1 Complexity Classes In this lecture we will look

CSC2420 Fall 2012: Algorithm Design, Analysis and Theory

CSC2420 Fall 2012: Algorithm Design, Analysis and Theory Allan Borodin November 15, 2012; Lecture 10 1 / 27 Randomized online bipartite matching and the adwords problem. We briefly return to online algorithms

Author(s)Kiyomi, Masashi; Saitoh, Toshiki; Ue.

JAIST Reposi https://dspace.j Title Voronoi Game on a Path Author(s)Kiyomi, Masashi; Saitoh, Toshiki; Ue Citation IEICE TRANSACTIONS on Information an E94-D(6): 1185-1189 Issue Date 2011-06-01 Type Journal

From Dynamic Matrix Inverse to Dynamic Shortest Distances

From Dynamic Matrix Inverse to Dynamic Shortest Distances Piotr Sankowski sank@mimuw.edu.pl Institute of Informatics Warsaw University - p. 1/51 FOCS 04 Highlights - p. 2/51 FOCS 04 Highlights Hardness

2.3 Scheduling jobs on identical parallel machines

2.3 Scheduling jobs on identical parallel machines There are jobs to be processed, and there are identical machines (running in parallel) to which each job may be assigned Each job = 1,,, must be processed

Graph Theory. Introduction. Distance in Graphs. Trees. Isabela Drămnesc UVT. Computer Science Department, West University of Timişoara, Romania

Graph Theory Introduction. Distance in Graphs. Trees Isabela Drămnesc UVT Computer Science Department, West University of Timişoara, Romania November 2016 Isabela Drămnesc UVT Graph Theory and Combinatorics

Lecture 3: Linear Programming Relaxations and Rounding

Lecture 3: Linear Programming Relaxations and Rounding 1 Approximation Algorithms and Linear Relaxations For the time being, suppose we have a minimization problem. Many times, the problem at hand can

Computing Relations in the Quantum Query Model 1

Scientific Papers, University of Latvia, 2011. Vol. 770 Computer Science and Information Technologies 68 89 P. Computing Relations in the Quantum Query Model 1 Alina Vasilieva, Taisia Mischenko-Slatenkova

COT5405 Analysis of Algorithms Homework 3 Solutions

COT0 Analysis of Algorithms Homework 3 Solutions. Prove or give a counter example: (a) In the textbook, we have two routines for graph traversal - DFS(G) and BFS(G,s) - where G is a graph and s is any

The multi-integer set cover and the facility terminal cover problem

The multi-integer set cover and the facility teral cover problem Dorit S. Hochbaum Asaf Levin December 5, 2007 Abstract The facility teral cover problem is a generalization of the vertex cover problem.

COMBINATORIAL PROPERTIES OF THE HIGMAN-SIMS GRAPH. 1. Introduction

COMBINATORIAL PROPERTIES OF THE HIGMAN-SIMS GRAPH ZACHARY ABEL 1. Introduction In this survey we discuss properties of the Higman-Sims graph, which has 100 vertices, 1100 edges, and is 22 regular. In fact

Connectivity and cuts

Math 104, Graph Theory February 19, 2013 Measure of connectivity How connected are each of these graphs? > increasing connectivity > I G 1 is a tree, so it is a connected graph w/minimum # of edges. Every

Network Flow I. Lecture 16. 16.1 Overview. 16.2 The Network Flow Problem

Lecture 6 Network Flow I 6. Overview In these next two lectures we are going to talk about an important algorithmic problem called the Network Flow Problem. Network flow is important because it can be

Guessing Game: NP-Complete?

Guessing Game: NP-Complete? 1. LONGEST-PATH: Given a graph G = (V, E), does there exists a simple path of length at least k edges? YES 2. SHORTEST-PATH: Given a graph G = (V, E), does there exists a simple

Online Adwords Allocation Shoshana Neuburger May 6, 2009 1 Overview Many search engines auction the advertising space alongside search results. When Google interviewed Amin Saberi in 2004, their advertisement

A Review And Evaluations Of Shortest Path Algorithms

A Review And Evaluations Of Shortest Path Algorithms Kairanbay Magzhan, Hajar Mat Jani Abstract: Nowadays, in computer networks, the routing is based on the shortest path problem. This will help in minimizing

Why? A central concept in Computer Science. Algorithms are ubiquitous.

Analysis of Algorithms: A Brief Introduction Why? A central concept in Computer Science. Algorithms are ubiquitous. Using the Internet (sending email, transferring files, use of search engines, online

Basic Notions on Graphs. Planar Graphs and Vertex Colourings. Joe Ryan. Presented by

Basic Notions on Graphs Planar Graphs and Vertex Colourings Presented by Joe Ryan School of Electrical Engineering and Computer Science University of Newcastle, Australia Planar graphs Graphs may be drawn

Midterm Exam Solutions CS161 Computer Security, Spring 2008

Midterm Exam Solutions CS161 Computer Security, Spring 2008 1. To encrypt a series of plaintext blocks p 1, p 2,... p n using a block cipher E operating in electronic code book (ECB) mode, each ciphertext

A note on properties for a complementary graph and its tree graph

A note on properties for a complementary graph and its tree graph Abulimiti Yiming Department of Mathematics Institute of Mathematics & Informations Xinjiang Normal University China Masami Yasuda Department

arxiv: v2 [math.co] 30 Nov 2015

PLANAR GRAPH IS ON FIRE PRZEMYSŁAW GORDINOWICZ arxiv:1311.1158v [math.co] 30 Nov 015 Abstract. Let G be any connected graph on n vertices, n. Let k be any positive integer. Suppose that a fire breaks out

Outline. NP-completeness. When is a problem easy? When is a problem hard? Today. Euler Circuits

Outline NP-completeness Examples of Easy vs. Hard problems Euler circuit vs. Hamiltonian circuit Shortest Path vs. Longest Path 2-pairs sum vs. general Subset Sum Reducing one problem to another Clique

CSE 20: Discrete Mathematics for Computer Science. Prof. Miles Jones. Today s Topics: Graphs. The Internet graph

Today s Topics: CSE 0: Discrete Mathematics for Computer Science Prof. Miles Jones. Graphs. Some theorems on graphs. Eulerian graphs Graphs! Model relations between pairs of objects The Internet graph!

DO NOT RE-DISTRIBUTE THIS SOLUTION FILE

Professor Kindred Math 04 Graph Theory Homework 7 Solutions April 3, 03 Introduction to Graph Theory, West Section 5. 0, variation of 5, 39 Section 5. 9 Section 5.3 3, 8, 3 Section 7. Problems you should

136 CHAPTER 4. INDUCTION, GRAPHS AND TREES

136 TER 4. INDUCTION, GRHS ND TREES 4.3 Graphs In this chapter we introduce a fundamental structural idea of discrete mathematics, that of a graph. Many situations in the applications of discrete mathematics

1. What s wrong with the following proofs by induction?

ArsDigita University Month : Discrete Mathematics - Professor Shai Simonson Problem Set 4 Induction and Recurrence Equations Thanks to Jeffrey Radcliffe and Joe Rizzo for many of the solutions. Pasted

Introduction to Algorithms Review information for Prelim 1 CS 4820, Spring 2010 Distributed Wednesday, February 24

Introduction to Algorithms Review information for Prelim 1 CS 4820, Spring 2010 Distributed Wednesday, February 24 The final exam will cover seven topics. 1. greedy algorithms 2. divide-and-conquer algorithms

max cx s.t. Ax c where the matrix A, cost vector c and right hand side b are given and x is a vector of variables. For this example we have x

Linear Programming Linear programming refers to problems stated as maximization or minimization of a linear function subject to constraints that are linear equalities and inequalities. Although the study

Two General Methods to Reduce Delay and Change of Enumeration Algorithms

ISSN 1346-5597 NII Technical Report Two General Methods to Reduce Delay and Change of Enumeration Algorithms Takeaki Uno NII-2003-004E Apr.2003 Two General Methods to Reduce Delay and Change of Enumeration

/ Approximation Algorithms Lecturer: Michael Dinitz Topic: Steiner Tree and TSP Date: 01/29/15 Scribe: Katie Henry

600.469 / 600.669 Approximation Algorithms Lecturer: Michael Dinitz Topic: Steiner Tree and TSP Date: 01/29/15 Scribe: Katie Henry 2.1 Steiner Tree Definition 2.1.1 In the Steiner Tree problem the input

Markov random fields and Gibbs measures

Chapter Markov random fields and Gibbs measures 1. Conditional independence Suppose X i is a random element of (X i, B i ), for i = 1, 2, 3, with all X i defined on the same probability space (.F, P).

Triangle deletion. Ernie Croot. February 3, 2010

Triangle deletion Ernie Croot February 3, 2010 1 Introduction The purpose of this note is to give an intuitive outline of the triangle deletion theorem of Ruzsa and Szemerédi, which says that if G = (V,

(Refer Slide Time: 01:35)

Artificial Intelligence Prof. Sudeshna Sarkar Department of Computer Science and Engineering Indian Institute of Technology, Kharagpur Lecture - 6 Informed Search -2 Today we start our 6 th lecture. This

Homework MA 725 Spring, 2012 C. Huneke SELECTED ANSWERS

Homework MA 725 Spring, 2012 C. Huneke SELECTED ANSWERS 1.1.25 Prove that the Petersen graph has no cycle of length 7. Solution: There are 10 vertices in the Petersen graph G. Assume there is a cycle C

Chapter 6 Planarity. Section 6.1 Euler s Formula

Chapter 6 Planarity Section 6.1 Euler s Formula In Chapter 1 we introduced the puzzle of the three houses and the three utilities. The problem was to determine if we could connect each of the three utilities

Lecture 7: NP-Complete Problems

IAS/PCMI Summer Session 2000 Clay Mathematics Undergraduate Program Basic Course on Computational Complexity Lecture 7: NP-Complete Problems David Mix Barrington and Alexis Maciel July 25, 2000 1. Circuit

(a) (b) (c) Figure 1 : Graphs, multigraphs and digraphs. If the vertices of the leftmost figure are labelled {1, 2, 3, 4} in clockwise order from

4 Graph Theory Throughout these notes, a graph G is a pair (V, E) where V is a set and E is a set of unordered pairs of elements of V. The elements of V are called vertices and the elements of E are called

Lecture 15 An Arithmetic Circuit Lowerbound and Flows in Graphs

CSE599s: Extremal Combinatorics November 21, 2011 Lecture 15 An Arithmetic Circuit Lowerbound and Flows in Graphs Lecturer: Anup Rao 1 An Arithmetic Circuit Lower Bound An arithmetic circuit is just like

Planar Tree Transformation: Results and Counterexample

Planar Tree Transformation: Results and Counterexample Selim G Akl, Kamrul Islam, and Henk Meijer School of Computing, Queen s University Kingston, Ontario, Canada K7L 3N6 Abstract We consider the problem

Handout #Ch7 San Skulrattanakulchai Gustavus Adolphus College Dec 6, 2010. Chapter 7: Digraphs

MCS-236: Graph Theory Handout #Ch7 San Skulrattanakulchai Gustavus Adolphus College Dec 6, 2010 Chapter 7: Digraphs Strong Digraphs Definitions. A digraph is an ordered pair (V, E), where V is the set

Lecture notes from Foundations of Markov chain Monte Carlo methods University of Chicago, Spring 2002 Lecture 1, March 29, 2002

Lecture notes from Foundations of Markov chain Monte Carlo methods University of Chicago, Spring 2002 Lecture 1, March 29, 2002 Eric Vigoda Scribe: Varsha Dani & Tom Hayes 1.1 Introduction The aim of this

Week 5 Integral Polyhedra

Week 5 Integral Polyhedra We have seen some examples 1 of linear programming formulation that are integral, meaning that every basic feasible solution is an integral vector. This week we develop a theory

Influences in low-degree polynomials

Influences in low-degree polynomials Artūrs Bačkurs December 12, 2012 1 Introduction In 3] it is conjectured that every bounded real polynomial has a highly influential variable The conjecture is known

Answers to some of the exercises.

Answers to some of the exercises. Chapter 2. Ex.2.1 (a) There are several ways to do this. Here is one possibility. The idea is to apply the k-center algorithm first to D and then for each center in D

CS420/520 Algorithm Analysis Spring 2010 Lecture 04

CS420/520 Algorithm Analysis Spring 2010 Lecture 04 I. Chapter 4 Recurrences A. Introduction 1. Three steps applied at each level of a recursion a) Divide into a number of subproblems that are smaller

A simpler and better derandomization of an approximation algorithm for Single Source Rent-or-Buy

A simpler and better derandomization of an approximation algorithm for Single Source Rent-or-Buy David P. Williamson Anke van Zuylen School of Operations Research and Industrial Engineering, Cornell University,

Graph definition Degree, in, out degree, oriented graph. Complete, regular, bipartite graph. Graph representation, connectivity, adjacency.

Mária Markošová Graph definition Degree, in, out degree, oriented graph. Complete, regular, bipartite graph. Graph representation, connectivity, adjacency. Isomorphism of graphs. Paths, cycles, trials.

2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]

Code No: R05220502 Set No. 1 1. (a) Describe the performance analysis in detail. (b) Show that f 1 (n)+f 2 (n) = 0(max(g 1 (n), g 2 (n)) where f 1 (n) = 0(g 1 (n)) and f 2 (n) = 0(g 2 (n)). [8+8] 2. (a)

Lecture Notes on Spanning Trees

Lecture Notes on Spanning Trees 15-122: Principles of Imperative Computation Frank Pfenning Lecture 26 April 26, 2011 1 Introduction In this lecture we introduce graphs. Graphs provide a uniform model

the lemma. Keep in mind the following facts about regular languages:

CPS 2: Discrete Mathematics Instructor: Bruce Maggs Assignment Due: Wednesday September 2, 27 A Tool for Proving Irregularity (25 points) When proving that a language isn t regular, a tool that is often

a 11 x 1 + a 12 x 2 + + a 1n x n = b 1 a 21 x 1 + a 22 x 2 + + a 2n x n = b 2.

Chapter 1 LINEAR EQUATIONS 1.1 Introduction to linear equations A linear equation in n unknowns x 1, x,, x n is an equation of the form a 1 x 1 + a x + + a n x n = b, where a 1, a,..., a n, b are given

Learning Threshold Functions with Small Weights using Membership Queries

Learning Threshold Functions with Small Weights using Membership Queries Elias Abboud Research Center Ibillin Elias College P.O. Box 102 Ibillin 30012 Nader Agha Research Center Ibillin Elias College P.O.

Semi-Matchings for Bipartite Graphs and Load Balancing

Semi-Matchings for Bipartite Graphs and Load Balancing Nicholas J. A. Harvey Richard E. Ladner László Lovász Tami Tamir Abstract We consider the problem of fairly matching the left-hand vertices of a bipartite

One last point: we started off this book by introducing another famously hard search problem:

S. Dasgupta, C.H. Papadimitriou, and U.V. Vazirani 261 Factoring One last point: we started off this book by introducing another famously hard search problem: FACTORING, the task of finding all prime factors

9 On the Cover Time of Random Walks on Graphs

Journal of Theoretical Probability, Vol. 2, No. 1, 1989 9 On the Cover Time of Random Walks on Graphs Jeff D. Kahn, 1 Nathan Linial, 2'3 Noam Nisan, 4 and Michael E. Saks 1'5 Received June 28, 1988 This

1 The Line vs Point Test

6.875 PCP and Hardness of Approximation MIT, Fall 2010 Lecture 5: Low Degree Testing Lecturer: Dana Moshkovitz Scribe: Gregory Minton and Dana Moshkovitz Having seen a probabilistic verifier for linearity

Lesson 3. Algebraic graph theory. Sergio Barbarossa. Rome - February 2010

Lesson 3 Algebraic graph theory Sergio Barbarossa Basic notions Definition: A directed graph (or digraph) composed by a set of vertices and a set of edges We adopt the convention that the information flows

Notes on Complexity Theory Last updated: August, 2011. Lecture 1

Notes on Complexity Theory Last updated: August, 2011 Jonathan Katz Lecture 1 1 Turing Machines I assume that most students have encountered Turing machines before. (Students who have not may want to look

Graphical degree sequences and realizations

swap Graphical and realizations Péter L. Erdös Alfréd Rényi Institute of Mathematics Hungarian Academy of Sciences MAPCON 12 MPIPKS - Dresden, May 15, 2012 swap Graphical and realizations Péter L. Erdös