CS 6515 Algos Test 3

Exact 4SAT (8.8)

->3SAT. Check clause satisfaction in O(m) time Directly assign clauses with one variable. For two/three variables use auxiliary variables to make each clause have 4 variables. For both cases, any assignment of C' assigns auxiliary variables true or false, which makes C also satisfied. For an assignment satisfying C, C' is satisfied without added variables

k-Spanning Tree (8.12)

1) Verify polynomial time solution: verify that S has no cycles and that every node has degree <=k. 2) Use rudrata path. k =2. A tree with a degree <= 2 is a path. if the k-spanning tree algo says a path exists, than there exists a path for all vertices in G (ie that's the rudrate path). If there's no tree with k =2, then there's no path

Steps for an NP Proof

1. Demonstrate that problem B is in the class of NP problems 2. Demonstrate that problem B is at least as hard as a problem believed to be NP-Complete*. This is done via reduction from a known problem A (A→B) 2a. Show how an instance of A is converted to B in polynomial time 2b. Show how a solution to B can be converted to a solution for A, again in polynomial time 2c. Show that a solution for B exists if-and-only-if (IFF) a solution to A exists. You must prove both directions parts: - If you have a solution to B you have a solution to A If there is no solution for B, then no solution exists for A. This may be done via the contra-positive approach, showing that if a solution exists for A then a solution for B must exist

RUDRATA (s,t)-PATH−→RUDRATA CYCLE Reduction

1. The reduction maps an instance (G = (V, E), s, t) of RUDRATA (s, t)-PATH into an instance G′ = (V ′, E′) of RUDRATA CYCLE as follows: G′ is simply G with an additional vertex x and two new edges {s, x} and {x, t} 2. How do we recover a Rudrata(s,t)-pathinG given any Rudrata cycle in G′? Easy, we just delete the edges {s, x} and {x, t} from the cycle 1. When the instance of RUDRATA CYCLE has a solution. Since the new vertex x has only two neighbors, s and t, any Rudrata cycle in G′ must consec- utively traverse the edges {t, x} and {x, s}. The rest of the cycle then traverses every other vertex en route from s to t. Thus deleting the two edges {t, x} and {x, s} from the Rudrata cycle gives a Rudrata path from s to t in the original graph G. 2. When the instance of RUDRATA CYCLE does not have a solution. In this case we must show that the original instance of RUDRATA (s,t)-PATH cannot have a solution either. It is usually easier to prove the contrapositive, that is, to show that if there is a Rudrata (s, t)-path in G, then there is also a Rudrata cycle in G′. But this is easy: just add the two edges {t, x} and {x, s} to the Rudrata path to close the cycle. One last detail, crucial but typically easy to check, is that the pre- and postprocessing functions take time polynomial in the size of the instance (G, s, t).

3 coloring -> k-coloring

3-Coloring problem can be proved NP-Complete making use of the reduction from 3SAT Graph Coloring (from 3SAT). Reduction from 3-Coloring instance: adding an extra vertex to the graph of 3-Coloring problem, and making it adjacent to all the original vertices.

IS with degree <=4 (8.6)

3SAT -> IS. The conclusion was that an IS in this graph provides a satisfying assignment for 3SAT, but obviously in the constructed graph each vertex only has a degree of (at most) 4!

Kite Definition

A kite is a graph on an even number of vertices (|V | = 2n) in which n of the vertices form a clique and the other n are connected in a "tail" that is simply a path from one of the vertices in the clique (think quite literally of a kite and its string, except the kite itself is a fully-connected graph).

Node-Disjoint Paths (8.23)

A path is sequence of vertices: s, v_1, .., v_m, t. Two paths s, v_1, .., v_m, t and s, u_1, ..., u_k, t are called node-disjoint if v_i != u_j for any valid i and j. We can reduce this problem to finding the maximum number of edge-disjoint paths by splitting each vertex (except for the source and the target) into two, adding an edge from the first copy to the second copy, redirecting all edges that end in this vertex to the first copy and all outgoing edges from the second copy. After that, the answer is the maximum flow in this graph (all edges should have a unit capacity).

Reduction

A reduction from search problem A to search problem B is a polynomial-time algorithm f that transforms any instance I of A into an instance f(I) of B, together with another polynomial-time algorithm h that maps any solution S of f(I) back into a solution h(S) of I; see the following diagram. If f(I) has no solution, then neither does I

Search Problem

A search problem is specified by an algorithm C that takes two inputs, an instance I and a proposed solution S, and runs in time polynomial in |I|. We say S is a solution to I if and only if C(I, S) = true

Directed Rudrata Path (8.11)

A) directed rudrata path -> undirected. Starting from undirected, you'd add two edges (one forward, one back) to make a directed graph. B)directed rudrata path -> undirected with ST. Add forward and back edges to the undirected, start and endpoints

Clique & Independent Set Problem (8.14)

Clique & Independent Set Problem: Input: An undirected graph, G = (V, E) and a integer goal k.Output: A clique C ⊆ V of size k, and an independent set S ⊂ V of size k, or "no" if both don't exist We will show a reduction from the IS problem (whose input is (G,g)) to this new clique+IS problem. Verifying a solution to the Clique+IS problem is just a matter of ver- ifying each part individually, and we showed in lecture that this can be done in polynomial time for both. Therefore, this problem is within np. we introduce a new (g + 1)-node clique, Q, into the original graph. Running the clique+IS algorithm on G′ and a goal k = g + 1 will now obviously always find a clique. It will also give an independent set S of size g + 1, but, critically, no more than one of those vertices comes from the "fake" clique (since cliques are fully-connected) so it must mean there is a size g clique in the original graph. orward Direction — If there is an independent set S′ of size g in the original graph G, then by introducing the new clique to craft G′, we know that there is a (g+1)-sized clique (by construction) and a (g + 1)-sized independent set (just add any vi from the fake clique to S′). Reverse Direction—If there is both an independent set S and a clique C of size k = g + 1 in G′, then by dropping any vi from S, we get an independent set of size g (since there can be at most one such vi). If there is no such vi, we have a direct solution since |S| ≥ g as required by the IS problem.

3SAT with 3 literals (8.7)

Create a bipartite graph with clauses on the left, variables on the right, and edges whenever a variable appears in a clause. Create a master source and sink. Then its a max flow problem and solvable in poly time

INDEPENDENT SET−→CLIQUE Reduction

Define the complement of a graph G = (V,E) to be G = (V,E), where E contains precisely those unordered pairs of vertices that are not in E. Then a set of nodes S is an independent set of G if and only if S is a clique of G. To paraphrase, these nodes have no edges between them in G if and only if they have all possible edges between them in G. Therefore, we can reduce INDEPENDENT SET to CLIQUE by mapping an instance (G,g) of INDEPENDENT SET to the corresponding instance (G, g) of CLIQUE; the solution to both is identical.

Rudrata cycle -> SAT (8.5)

Following the hint given in the book, we define variables xij to mean that vertex i is the j th vertex in the Rudrata cycle. We require that each vertex appears once and only once in the cycle, and that neighbors in the cycle are connected by an edge. For the first requirement, we first add a clause (xi1 ∨ xi2 ∨ · · · ∨ xin) for each vertex i. Next, for each cycle entry j, we add clauses for each pair i, k of vertices ensuring that no more than one vertex can be assigned to the entry: (¯xij ∨ x¯kj ). For the second requirement, if there is no edge between some vertex i and k we want to express the statement (xij ∧ xk,j+1) for every cycle location j. Therefore, for each pair of items i, k such that there is no edge between i and k, for and every cycle entry j, add clause (¯xij ∨ x¯k,j+1), letting j + 1 = 1 when j = n. We assert that this reduction is correct by construction. Construction of the sat instance involves the creation of n clauses with n entries each plus n 3 clauses with 2 entries each for the first requirement. The second requirement adds at most another n 3 clauses with 2 entries each. Therefore the reduction takes O(n 3 ) time.

Hitting Set (8.9)

Given a family of sets S1...Sn...and a budget b, we wish to find a set H <= size b with intersects every Si. Verifying NP - H intersect with every Si is calculating n intersections, which take m operations, so O(nm). Reduction of Vertex cover -> hitting set (since vertex has a budget). Construct the sets by assigning each vertex a number and letting each edge be a set. The hitting set F will include at least one value from each of the above sets by definition. This means it includes one vertex from each edge which is a vertex cover.

Independent Set Definition

Given a graph G = (V, E) and an integer k, is there a subset of vertices S ⊆ V such that | S | ≥ k, and for each edge at most one of its endpoints is in S ?

RUDRATA CYCLE−→TSP Reduction

Given a graph G = (V, E), construct the following instance of the TSP: the set of cities is the same as V , and the distance between cities u and v is 1 if {u, v} is an edge of G and 1 + α otherwise, for some α > 1 to be determined. The budget of the TSP instance is equal to the number of nodes, |V |. It is easy to see that if G has a Rudrata cycle, then the same cycle is also a tour within the budget of the TSP instance; and that conversely, if G has no Rudrata cycle, then there is no solution: the cheapest possible TSP tour has cost at least n + α (it must use at least one edge of length 1 + α, and the total length of all n − 1 others is at least n − 1). Thus RUDRATA CYCLE reduces to TSP.

Clique-3 (8.4)

Given an input graph G = (V, E), a goal g, and a potential solution set S ⊆ V , it is easy to verify whether S is a clique by checking that all pairs of vertices in S are connected in O(n2) time, and to check that |S| ≥ g in O(n) time. Since a solution can be verified in polynomial time, clique-3 is in NP.

3SAT−→INDEPENDENT SET Reduction

Given an instance I of 3SAT, we create an instance (G, g) of INDEPENDENT SET as follows. • Graph G has a triangle for each clause (or just an edge, if the clause has two literals), with vertices labeled by the clause's literals, and has additional edges between any two vertices that represent opposite literals. • The goal g is set to the number of clauses. 1. Given an independent set S of g vertices in G, it is possible to efficiently recover a satis- fying truth assignment to I. For any variable x, the set S cannot contain vertices labeled both x and x, because any such pair of vertices is connected by an edge. So assign x a value of true if S contains a vertex labeled x, and a value of false if S contains a vertex labeled x (if S contains neither, then assign either value to x). Since S has g vertices, it must have one vertex per clause; this truth assignment satisfies those particular literals, and thus satisfies all clauses. 2. If graph G has no independent set of size g, then the Boolean formula I is unsatisfiable. It is usually cleaner to prove the contrapositive, that if I has a satisfying assignment then G has an independent set of size g. This is easy: for each clause, pick any literal whose value under the satisfying assignment is true (there must be at least one such literal), and add the corresponding vertex to S.

Duality Theorem

If a linear program has a bounded optimum, then so does its dual, and the two optimum values coincide

ZOE−→ILP

In ILP we are looking for an integer vector x that satisfies Ax ≤ b, for given matrix A and vector b. To write an instance of ZOE in this precise form, we need to rewrite each equation of the ZOE instance as two inequalities (recall the transformations of Section 7.1.4), and to add for each variable xi the inequalities xi ≤ 1 and −xi ≤ 0.

Sequencing by Hybridization (8.21)

In this problem, we are given a multiset (a set which can contain elements more than once) of something called k-mers—a k-mer is a substring of length k. From these substrings, we need to reconstruct the full, original string. We say that Γ(x) is the multiset of a string x's k-mers. ow do we know that two particular k-mers "match"? That is, how do we know that thequ and hequi are part of the same string, and thequ and quick aren't? Obviously because the 2-through-kth characters of one match the 1-through-(k − 1)th of the other. To resolve these ambiguities, we make every k-mer a vertex in a graph and connect them if the above condition holds. We use a different string with 3-mers and repeat substrings We need to prove correctness, though. At the very least, every substring of the original string will be in the reconstruction, since the Rudrata path will touch every vertex only once. If there are duplicate vertices (like the ands above), it doesn't matter which a given prefix chooses, since they'll all have the same incoming and outgoing degree; in other words, duplicate k-mers are identical vertices.

Max SAT (8.10c)

Input: A Boolean formula f in conjunctive normal form with n variables and m clauses; and a goal g. Output: An assignment that satisfies at least g clauses in f. Recall that we discussed the optimization variant of Max-SAT in terms of linear programming in section 5.4. This version is a generalization of SAT with g = m.

Stingy SAT (8.3)

Input: A Boolean formula in CNF with m clauses composed of n vari- ables. An integer k. Output: A satisfying assignment in which ≤ k variables are set to true, if such an assignment exists. Solution: This is a generalization of SAT: simply let k = n to allow every variable to be set to true if necessary. Longer solution: First, we show that Stingy SAT is in NP. Let the input formula be denoted by f, and let n be the number of variables and m be the number of clauses. Given a satisfying assignment σ of F, we can just check clause by clause that σ satisfies every one; this takes O(n) time per clause and thus O(nm) total time. Then in O(n) time, we count how many variables are set to be TRUE in σ and check that the number is larger than k or not. Now, we show: SAT → Stingy SAT. Suppose you have an input formula f for SAT with n variables and m clauses. Now, run Stingy SAT on f with k = n. Clearly, every assignment over n variables will have at most n variables set to true, so this extra restriction will not constrain the set of solutions. Then, if Stingy SAT returns a satisfying assignment, that assignment will also satisfy the original SAT problem. Likewise, if Stingy SAT returns that there is no such assignment, then there can be no solution to the SAT problem. This completes the reduction, which is clearly polynomial time (the only change was setting k = n). Then, since SAT is NP-complete, Stingy SAT must also be NP-complete.

Clique Input / Output

Input: A graph G = (V, E) and a goal, g. Output: A subset of vertices, S ⊆ V where S is a clique whose size meets the goal, so |S| ≥ g.

Vertex Cover Input/Output

Input: A graph, G = (V, E) and a budget, b Output: A set of vertices S ⊂ V that form a vertex cover with a size that is under-budget, so |S| ≤ b.

Dominating Set (8.20)

Input: A graph, G = (V, E) and a budget, b. Output: A dominating set, D ⊆ V of size |D| ≤ b, in which every vertex v ∈ V is either within D or has a neighbor within D (if it exists). Solution The description of a dominating set sounds remarkably similar to that of a vertex cover; the term "budget" should clue us in. We will thus reduce from the vertex cover problem to the dominating set problem. Transformation Given a graph, we modify each edge to force the dominating set to include at least one endpoint and result in a valid vertex cover. Specifically, we create a triangle to each edge: for each edge (u, v), we introduce a new vertex w and add the edges (w, u) and (w, v). Forward Direction This is trivial: a vertex cover is a dominating set by definition. Since every edge in the graph has at least one of its vertices in the VC and its other vertex is obviously its neighbor, this is a dominating set. Reverse Direction Any of our given triangles needs at least one vertex to be within D; this is obvious—if the original vertices are covered by the dominating set condition without using w, then w is left out. Now if w is used, we can use u or v instead and still maintain a dominating set. And since u and/or v is always used for any given edge, this is a vertex cover!

Dense Subgraph (8.10d)

Input: A graph, G = (V, E), and two integers a and b. Output: A set of a vertices V ′ ⊆ V such that there are at least b edges between them. Solution This can be interpreted as a generalization of the independent set problem: simply let a = g, the IS goal, and let b = 0, so there are no edges between the vertices (the definition of a g-sized independent set). This can also be viewed as a generalization of the clique problem, where we try to find a = g vertices with b = g(g−1)/2 edges between them. We calculate b by a simple analysis: for a g-sized clique, the first vertex needs g − 1 edges to the other vertices, the second needs (since the previous case covered (v1,v2)), and so on. This comes out to just being the sum of the first g integers

Independent Set Input/Output

Input: An undirected graph, G = (V, E). A goal g. Output: The independent set S with size |S| ≥ g, if one exists.

Integer Linear Programming (ILP) Input/Output

Input: Ax <= b where A is a m x n matrix, b is an m-Vector Output: Non-Negative Integer Vector x satisfying the inequality Ax <= b

Rudrata (s, t)-Path Input/Output

Input: Graph G = (V, E), Start and End Vertices (s, t) Output: A path that starts at s, ends at t, and goes through every vertex of the graph exactly once

Rudrata Cycle Input/Output

Input: Graph G = (V, E)Output: A cycle that goes through every vertex of the graph exactly once

Maximum Common Subgraph (8.15)

Input: Two graphs, G1 = (V1, E1) and G2 = (V2, E2) and a budget, b. Output: Two sets of vertices V1′ ⊆ V1 and V2′ ⊆ V2 such that deleting them from their respective graphs leaves at least b nodes in each graph and makes the graphs identical. Solution At first it may seem that this has a relationship to the Subgraph Isomorphism problem above (see 8.10a), and it sort of does, in the sense that all of the graph problems are sort of similar. We proceed by a reduction from the vertex cover problem. Within np) We technically need a mapping from one set of vertices to another in this for it to truly be verifiable in polynomial time, but if we just consider equal graph structure to mean equal graphs, then it's pretty trivial. All we need to do is confirm that the amount of vertices matches (constant time, or linear if your data structure is garbage) and that the edges are the same per-vertex. We can do this by finding the vertex in V1 \ V1′ that has the same edges as in V2 \ V2′ in O(mn) time: compare each edge list (which is ≤ m edges long) of each vertex (which is ≤ n long), and do this for every vertex. Since both graphs could be fully-connected in the worst case, this takes O(n3) time overall. Transformation) Let G1 = (V,E) be the original graph, G2 = (V2,∅) be simply b′ disconnected vertices (where b′ is the input budget to the VC problem rather than the above budget), and the budget be b = b′ (meaning nothing in G2 gets removed). Then, we claim that the Max-Common-Subgraph problem has a solution iff the VC problem has a solution. Forward Direction) Given a solution V ∗ ⊆ V to the VC problem with the input (G, b′), the above problem also has a solution since one could simply drop V1′ = V ∗ (and V2′ = ∅, so no action there is required). By the definition of a vertex cover, V \V1′ would leave no edges and leave exactly b = b′ = |V2| = |V \ V1′| vertices behind (and thus match G2). Reverse Direction) Given a solution pair (V1′, V2′) to the Max-Common-Subgraph as described above, the VC problem will also have a solution: just drop V1′ from the original graph and return the resulting set of vertices.

ZERO-ONE EQUATIONS (ZOE) Input/Output

Input: a 𝑚×𝑛m×n matrix 𝐴A, all of whose entries are 0 or 1 Goal: Find a 𝑛n-vector 𝑥x, all of whose entries are 0 or 1, such that 𝐴𝑥=1Ax=1, where 11 denotes the all-ones vector

SAT Input/Output

Input: n clauses with any number of literals in each clause Output: An assignment of literals that satisfy all the clauses of the input

3SAT Input/Output

Input: n clauses with at most 3 unique literals each Output: An assignment if literals that satisfy all the clauses of the input

Kite (8.19)

Kite Search: Input: A graph G = (V,E) and a goal g. Output: A subgraph of G which is also a kite and contains 2g nodes. Solution trying to find a clique within a graph and some extra stuff (the "tail")? This is how the reduction will proceed. Transformation If Kite can find a solution, so can Clique by simply dropping the path. Thus, the transformation from (G, g) (the graph and goal from finding cliques) just involves adding a g-length path from an arbitrary vertex in G to fulfill the kite requirements. Under this transformation, we need to show that: Forward Direction Given a solution Q to (G, g), we can just add a g-length "tail" to any of the vertices in Q and get a solution to the kite problem. Reverse Direction Given a solution Q to the kite problem on the transformed G as input, we can drop the tail from the solution to obtain a solution for getting a g-size clique.

Set Cover (8.10f)

Let E = {e1, e2, .., en} be a set of n elements. Let S1, S2, .., Sm be subsets of E with associated costs c1, .., cm. In the set cover problem, our goal is to pick a minimum cost collection of sets from among S1, · · · , Sm, such that the union of these sets is E; in other words, this collection "covers" E. The set cover problem is NP-hard. it is a generalization of vertex cover, because in the latter, we can think of the edges as the elements and the vertices as sets of elements containing the edges incident on them ILP can also encode set cover

Poly or NP Complete? 8.13b: A set of nodes L ⊆ V , and you must find a spanning tree such that its set of leaves is precisely the set L

NP-complete. (b) is in NP. Given a spanning tree T , we can verify, in polynomial time, that whether its leaves are exactly vertices in L. (b) can be reduced from RUDRATA (s, t)-PATH. Given the input G, s, t to RUDRATA (s,t)-PATH problem, let G,L := {s,t} be the input to (b). If G has a RUDRATA (s,t)-path P, then G has a spanning tree, which is P, with the set of its leaves being L = {s, t}. If G has a spanning tree T with the set of its vertices being L, then G has a RUDRATA (s,t)-path, which is T. The reduction is done in polynomial time.

Poly or NP Complete? 8.13a: A set of nodes L ⊆ V , and you must find a spanning tree such that its set of leaves includes the set L

Poly. Remove vertices in L. Build a spanning tree T in the remaining graph using BFS or DFS. For each vertex v ∈ L, connect it to any of its neighbor(s) present in T . If some vertex in L doesn't have a neighbor in T , then we cannot find a spanning tree that has all vertices in L, otherwise the spanning tree must include all vertices in L.

Breaking RSA (8.18)

RSA relies on the fundamental mathematical difficulty that factoring a product of two primes, N = pq is not doable in polynomial time. If it is, then finding the separate p and q becomes trivial, so an adversary can find φ (N) = (p − 1)(q − 1) and compute the inverse of e under mod φ (N) themselves (recall that ed ≡ 1 (mod φ (N ))), revealing the decryption key

ZOE−→RUDRATA CYCLE Reduction

RUDRATA CYCLE problem we seek a cycle in a graph that visits every vertex exactly once. We shall prove it NP-complete in two stages: first we will reduce ZOE to a generalization of RUDRATA CYCLE, called RUDRATA CYCLE WITH PAIRED EDGES, and then we shall see how to get rid of the extra features of that problem and reduce it to the plain RUDRATA CYCLE problem.

3D MATCHING−→ZOE (Zero to One Equations)

Recall that in ZOE we are given an m×n matrix A with 0−1 entries, and we must find a 0−1 vector x = (x1, . . . , xn) such that the m equations Ax = 1 are satisfied, where by 1 we denote the column vector of all 1's. 3D MATCHING (m boys, m girls, m pets, and n boy-girl-pet triples) in the language of ZOE. We have 0 − 1 variables x1, . . . , xn, one per triple, where xi = 1 means that the ith triple is chosen for the matching, and xi = 0 means that it is not chosen. Now all we have to do is write equations stating that the solution described by the xi's is a legitimate matching. For each boy (or girl, or pet), suppose that the triples containing him (or her, or it) are those numbered j1, j2, . . . , jk; the appropriate equation is then xj1 +xj2 +···+xjk =1, which states that exactly one of these triples must be included in the matching.

Experimental Cuisine (8.16)

Reduce 3SAT to this problem. The columns correspond to variables and the rows to clauses. A winning position corresponds to a value assignment satisfying all clauses and vice versa.

Reliable Network (8.10g)

The Reliable Network problem is a generalization of the Hamiltonian Cycle problem. Consider a given graph G=(V,E) V={1, ..., n} as an instance of the Hamiltonian Cycle Problem. If we take dij=1 for each edge ij ϵ E and dij=2 for each edge ij ∉E, b=n, and every rij=2 then this is equivalent to an instance of the Reliable Network problem. We pick edges such that the weights of all edges add up to n and each pair i,j is part of a cycle. This would mean that the graph is connected (since each pair of vertices has 2 paths between them forming a cycle). Since the weight of each edge is 1, there must be exactly n edges for the sum of weights to be n and exactly one cycle since there are exactly n vertices and n edges and the graph is connected. Since the Hamiltonian Cycle problem is NP-complete, the Reliable Network problem is also NP-complete

TSP-OPT -> TSP (8.1)

The idea of this reduction is to use binary search with the b input for TSP to find the length of the shortest tour (then TSP will find the shortest tour itself). Let the distance matrix be denoted D. First, we need to find an upper bound B for the length of the shortest path. We can set B to be the sum of all distances in the distance matrix (so B = i,j Di,j). Then, we run TSP with inputs D and B/2. If this finds a tour with length at most B/2, then we know the shortest tour has length in the range [0,B/2]. Otherwise, the shortest tour has length in the range [B/2, B]. Here is where we can apply binary search; for each successive iteration, run TSP on the midpoint of the remaining range for the length of the shortest path, then eliminate half of the range based on whether TSP finds a tour. Continue this recursive process until the range is narrowed to a single integer number, then return the path found by TSP on this integer. TSP will be run O(log B) times (since this is a binary search from 0 to B). The input size of TSP-OPT must be of length Ω(log B), since B was the sum of all the distances in D. Therefore, this reduction is polynomial, and if TSP can be solved in polynomial time, then so can TSP-OPT.

Poly or NP Complete? 8.13e: An integer k, and you must find a spanning tree with k or more leaves.

This is NP-complete. (e) is in NP. Given a spanning tree T, we can verify, in polynomial time, that whether it has k or more leaves. (e) can be reduced from CONNECTED DOMINATING SET problem, which wants to find a connected dominating set in G that has at most b vertices (see 8.20 for definition of dominating set). Given input G,b to CONNECTED DOMINATING SET, let G,k := n−b be the input to (e), where n = |V|. If G has a connected dominating set D of size at most b, then for each vertex v ∈ V − D, connect it to one of its neighbors in D. We get a spanning tree T with at least n − b leaves. If G has a spanning tree with at least k leaves, then G has a connected dominating set D, which is formed by removing all leaves from T . Obviously, D has at most n − k vertices. The reduction is done in polynomial time.

Poly or NP Complete? 8.13d: An integer k, and you must find a spanning tree with k or fewer leaves.

This is NP-complete. The proof is left as an exercise. (Hint: reducing from RUDRATA (s, t)-PATH and consider k = 2)

Poly or NP Complete? 8.13f: An integer k, and you must find a spanning tree with exactly k leaves

This is NP-complete. The proof is left as an exercise. (Hint: reducing from RUDRATA (s, t)-PATH and consider k = 2)

Poly or NP Complete? 8.13c: A set of nodes L ⊆ V , and you must find a spanning tree such that its set of leaves is included in the set L.

This is NP-complete.(b) is in NP. Given a spanning tree T , we can verify, in polynomial time, that whether its leaves are included in L.(b) can be reduced from RUDRATA (s, t)-PATH. Given the input G, s, t to RUDRATA (s,t)-PATH problem, let G,L := {s,t} be the input to (b). If G has a RUDRATA (s,t)-path P, then G has a spanning tree, which is P, with the set of its leaves being included in L = {s, t}. If G has a spanning tree T with the set of its vertices being included in L, then G has a RUDRATA (s,t)-path, which is T. Here we can only consider graphs having at least 2 vertices. The reduction is done in polynomial tim

Sparse Subgraph (8.10e)

This is a generalization of INDEPENDENT SET problem: given a graph and find a set of a vertices where there are no edges between any pair of vertices. If we set the b in SPARSE SUBGRAPH to be zero, it becomes INDEPENDENT SET problem.

ZOE−→SUBSET SUM Reduction

This is a reduction between two special cases of ILP: one with many equations but only 0 − 1 coefficients, and the other with a single equation but arbitrary integer coefficients. But if we think of the columns as binary integers (read from top to bottom), we are looking for a subset of the integers 18, 5, 4, 8 that add up to the binary integer 111112 = 31.

INDEPENDENT SET−→VERTEX COVER Reduction

To reduce INDEPENDENT SET to VERTEX COVER we just need to notice that a set of nodes S is a vertex cover of graph G = (V, E) (that is, S touches every edge in E) if and only if the remaining nodes, V − S, are an independent set of G (Figure 8.9). Therefore, to solve an instance (G, g) of INDEPENDENT SET, simply look for a vertex cover of G with |V | − g nodes. If such a vertex cover exists, then take all nodes not in it. If no such vertex cover exists, then G cannot possibly have an independent set of size g.

3SAT with each literal appearing once (8.6)

Use a bipartite graph, set up as a max flow problem with a master source and sink. This can be solved in poly time.

3D Matching -> SAT (8.5)

We are given a set of n "edges" which each contain three items. A valid matching exists if we can choose a set of edges such that every item appears in an edge, but no item appears in more than one edge. Define variables {e1, e2, . . . , en} where true indicates that an edge is chosen. For every item (of any type), let a be a k-vector of indices of edges in which the item appears; e.g., if the item appears in e1, e3, and e7, then a = [1, 3, 7] (and k = 3). Create clauses as follows: • Add clause (ea1 ∨ ea2 ∨ . . . eak ). This clause ensures that the item appears at least once. • For every pair i, j ∈ {1..k}, add clause (¯eai ∨ e¯aj ). Taken together these clauses ensure that the item cannot appear more than once. We must show that this reduction takes polynomial time. If there are m items and n edges, then we must iterate over m items, generating for each item one clause with at most n entries and at most n(n−1) clauses with 2 entries. Thus the overall reduction is O(mn2 ).

3SAT−→3D MATCHING

We must reduce 3SAT to the problem of finding, among a set of boy-girl-pet triples, a subset that contains each boy, each girl, and each pet exactly once. In short, we must design sets of boy-girl-pet triples that somehow behave like Boolean variables and gates! To then transform an instance of 3SAT to one of 3D MATCHING, we start by creating a copy of the preceding gadget for each variable x. Call the resulting nodes px1,bx0,gx1, and so on. The intended interpretation is that boy bx0 is matched with girl gx1 if x = true, and with girl gx0 if x = false. We have to make sure that for every occurrence of a literal in a clause c there is a different pet to match with bc and gc. But this is easy: by an earlier reduction we can assume that no literal appears more than twice, and so each variable gadget has enough pets, two for negated occurrences and two for unnegated. The reduction now seems complete: from any matching we can recover a satisfying truth assignment by simply looking at each variable gadget and seeing with which girl bx0 was matched. And from any satisfying truth assignment we can match the gadget corresponding to each variable x so that triples (bx0, gx1, px0) and (bx1, gx0, px2) are chosen if x = true and triples (bx0, gx0, px1) and (bx1, gx1, px3) are chosen if x = false; and for each clause c match bc and gc with the pet that corresponds to one of its satisfying literals.

Show that any problem within np can be solved in O(2^p(n)) time, where p(n) is some polynomial (8.17)

With an input size of n elements, we can simply do an exhaustive search over all of them since verifying their correctness takes polynomial time (by the nature of being within np). There are 2n possible inputs, and each takes some q(n) time to verify (where q is the verification algorithm), thus its big-O is: O(2^ (n+q(n))) or 2^n · 2^q(n)

Zero-One (0-1) Integer Linear Programming (ILP): Definition

an approach used for problems that can be set up as linear programs with the additional requirement that some or all of the decision recommendations be integer values The unknowns are binary, and only the restrictions must be satisfied. Note: General ILP is NP-HARD if ILP includes an objective function then it would classify as NP-Hard but not NP-Complete, as we have no known polynomial-time algorithm for validating the solution. By removing the objective function we essentially make it a search problem -- is there a set of values for the variables which satisfy all the constraints? That is easily validated in linear time.

Vertex Cover Reduction -> Hitting Set

eduction from VC by making each edge a set, so the hitting set always contains one vertex from each edge

Feedback Arc Set (FAS) (8.22)

feedback edge set is a set of edges which, when removed from the graph, leave a DAG. Put another way, it's a set containing at least one edge of every cycle in the graph. SHow NP completeness by a reduction from Vertex Cover. Make a directed graph with 2n vertices and n+2|E| edges To show that FAS is NP-hard, we give a reduction from VERTEX COVER. Let G(V, E), k be an instance of VERTEX COVER, which we transform to an instance of FAS G0 (V 0 , E0 ), k0 in linear time as follows: For every vertex v ∈ V , we add two corresponding vertices vin, vout ∈ V 0 that we connect by a directed edge (vin → vout), and for every edge (u, v) ∈ E, we add the directed edges (uout → vin) and (vout → uin) ∗ to E0 . Finally we set k 0 = k; and claim that G has a vertex cover of size at most k iff G0 has a FAS of size at most k. Suppose G has a vertex cover S where |S| ≤ k. For every v ∈ S, consider removing the edge (vin, vout) in G0 . The resulting graph is acyclic. If a cycle in G0 enters a vertex in vin, it can only leave through the edge (vin, vout) given our construction. Similarly, a cycle can only enter vout through the edge (vin, vout). Thus if a cycle in G0 uses the edge (uout, vin), it must use the edge (uin, uout) and the edge (vin, vout). At least one of the these two edges would have been removed since at least one of u or v must be in the vertex cover to cover the edge (u, v) ∈ E. Therefore if G has a vertex cover of size at most k then G0 has a feedback arc set of size at most k 0 = k as well Conversely, suppose G0 has a FAS S 0 of size at most k 0 . Without loss of generality, we assume that the only edges removed are of the form (uin, uout) because if some other edge (uout, vin) is removed, then all cycles in which this edge participated would have included the edge (vin, vout) too and we could remove this edge instead. We claim that the set of vertices v ∈ V for which the corresponding edge (vin, vout) is removed in E0 forms a vertex cover for G. Suppose not, and suppose there is some edge (u, v) ∈ E not covered. Then in G0 the cycle (uin, uout),(uout, vout),(vin, vout),(vout, uin) is unbroken by the removal of the edges contradicting the assumption. Thus (G, k) must have a vertex cover of size at most k = k 0 .

Clique definition

find a set of g ver- tices such that all possible edges between them are present

Vertex Cover definition

find b vertices that cover (touch) every edge. This is a special case of set cover

3SAT definition

given a Boolean formula in conjunctive normal form with at most 3 variables in each clause, either find a satisfying truth assignment or else report that none exists.

SAT Definition

given a Boolean formula in conjunctive normal form, either find a satisfying truth assignment or else report that none exists. A satisfying truth assignment is an assignment of false or true to each variable so that every clause contains a literal whose value is true.

Balanced Cut Definition

given a graph with n vertices and a budget b, partition the vertices into two sets S and T such that |S|,|T| ≥ n/3 and such that there are at most b edges between S and T

Rudrata Cycle Definition

given a graph, find a cycle that visits each vertex exactly once—or report that no such cycle exists

Rudrata Path Definition

given a graph, find a path that visits each vertex exactly once—or report that no such path exists

Primal Linear Program

max cTx Ax ≤ b x≥0

Dual Linear Program

min yTb yT A ≥ cT y≥0

SAT−→3SAT Reduction

reducing SAT to 3SAT: given an instance I of SAT, use exactly the same instance for 3SAT, except that any clause with more than three literals, (a1 ∨ a2 ∨ ··· ∨ ak) (where the ai's are literals and k > 3), is replaced by a set of clauses, where the yi's are new variables Conversely,if(a1 ∨a2 ∨···∨ak)issatisfied,thensomeai mustbetrue. Sety1,...,yi−2 to true and the rest to false. This ensures that the clauses on the right are all satisfied.

Vertex Cover Reduction -> Dominating Set

reduction from VC by forcing all edges to have a vertex in D through a triangle formation

VC -> Maximium Common Subgraph

reduction from VC where you keep the original graph the same and try to match to b discon- nected vertices (which would be a VC)

Clique -> Kite

reduction from clique sim- ply by adding a kite tail

3D Matching Definition

there are n boys and n girls, but also n pets, and the compatibilities among them are specified by a set of triples, each containing a boy, a girl,andapet. Intuitively,a triple(b,g,p) means that boy b,girl g,and pet p get along well together. We want to find n disjoint triples and thereby create n harmonious households

Set Cover Definition

we are given a set E and several subsets of it, S1, . . . , Sm, along with a budget b. We are asked to select b of these subsets so that their union is E

Rudrata Decision -> Rudrata Path (8.2)

we simply iteratively remove edges (in an arbi- trary, predetermined order) from G and check if there's still a Rudrata path. If there is, keep the edge removed permanently. By the end, we'll only be left with edges that are essential to the Rudrata path and thus are the Rudrata path. All of these operations take polynomial time, so the resulting algorithm is still polynomial

Subgraph isomorphism generalization (8.10a)

where you try to transform some generic graph H into a specific graph G by dropping vertices (generalization of Clique, where G is a clique you want to find) Input: Two graphs, G and H. Output: Determine whether or not we can turn H into G by dropping some amount of vertices or edges (up to "renaming" vertices). The corresponding mapping of vertices, V(G) → V(H). Solution This is a generalization of the Clique problem. There, we were given a graph Q and a goal of g. Here, we let H = Q and G is a fully-connected graph with g vertices (i.e. a clique of size g). Obviously if H can be turned into G, then Q has a clique of size g.

Dense subgraph generalization

where you want to find a vertices in a graph that contain b edges (generalization of independent set where you want to find vertices that contain no edges between them).

Longest path generalization (8.10b)

where you want to find the longest non-self-intersecting path (generalization of the Rudrata cycle). Input: A graph G and an integer g. Output: A simple path of length g (that is, a path that doesn't intersect itself). Solution This is a generalization of the Rudrata cycle problem: we let g be the total length of all vertices in the graph.