Abstract 1 Introduction 2 Our Results 3 FPT Algorithm for 𝒓AND 4 FPT Algorithms for 𝟐𝐀𝐄 References

Complexity of Local Search for CSPs Parameterized by Constraint Difference

Aditya Anand ORCID University of Michigan, Ann Arbor, MI, USA Vincent Cohen-Addad ORCID Google Research, NYC, USA Tommaso D’Orsi ORCID Bocconi University, Milan, Italy Anupam Gupta ORCID New York University, NY, USA Euiwoong Lee ORCID University of Michigan, Ann Arbor, MI, USA Debmalya Panigrahi ORCID Duke University, Durham, NC, USA Sijin Peng ORCID Massachusetts Institute of Technology, Cambridge, MA, USA
Abstract

In this paper, we study the parameterized complexity of local search, whose goal is to find a good nearby solution from the given current solution. Formally, given an optimization problem where the goal is to find the largest feasible subset S of a universe U, the new input consists of a current solution P (not necessarily feasible) as well as an ordinary input for the problem. Given the existence of a feasible solution S, the goal is to find a feasible solution as good as S in parameterized time f(k)nO(1), where k denotes the distance |PΔS|. This model generalizes numerous classical parameterized optimization problems whose parameter k is the minimum number of elements removed from U to make it feasible, which corresponds to the case P=U.

We apply this model to widely studied Constraint Satisfaction Problems (CSPs), where U is the set of constraints, and a subset U of constraints is feasible if there is an assignment to the variables satisfying all constraints in U. We give a complete characterization of the parameterized complexity of all boolean-alphabet symmetric CSPs, where the predicate’s acceptance depends on the number of true literals.

Keywords and phrases:
Constraint Satisfaction Problems, Parameterized Local Search, Optimization
Funding:
Anupam Gupta: Supported in part by NSF awards CCF-2224718 and CCF-2422926.
Euiwoong Lee: Supported in part by NSF award CCF-2236669 and by Google, Inc.
Debmalya Panigrahi: Supported in part by NSF awards CCF-1955703 and CCF-2329230.
Copyright and License:
[Uncaptioned image] © Aditya Anand, Vincent Cohen-Addad, Tommaso D’Orsi, Anupam Gupta, Euiwoong Lee,
Debmalya Panigrahi, and Sijin Peng; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Parameterized complexity and exact algorithms
Related Version:
Full Version: https://arxiv.org/abs/2512.03275
Editors:
Akanksha Agrawal and Erik Jan van Leeuwen

1 Introduction

The classical theory of NP-hardness sets limits on the polynomial-time tractability of a vast array of algorithmic problems. This raises the question: what additional information about the problem instance can one use to help overcome complexity barriers? A very successful line of research that aims to address this broad question is that of fixed parameter tractable (FPT) algorithms. The idea is to identify a parameter that has a small value in typical instances, and design an algorithm whose running time is exponential in the value of the parameter but polynomial in the overall size of the instance.

This philosophy has been widely applied to the following general class of optimization problems: let U be a universe and let 𝒮2U be an (often implicitly given) collection of feasible subsets of U, and the goal is to find S𝒮 that maximizes |S|, or equivalently to find the smallest T that puts UT𝒮. For instance, given a graph G=(V,E), if U=E and F𝒮 if (V,F) is 2-colorable, the problem corresponds to the famous MaxCut/MinUncut pair. Or given G=(V,E), if U=V and 𝒮 denotes the collection of all independent sets, then we have Independent Set/Vertex Cover. In this class, there are many situations where typical (or at least interesting) instances have the optimal value for the minimization version much smaller than |U|. (I.e., the universe U is already close to feasible.) Consequently, numerous results in the FPT literature study a problem from the above class - we let the parameter k be the optimal value for the minimization version, and give an algorithm of running time f(k)nO(1) (better than the naive running time of nO(k)).

Can we extend the applicability of this framework? We can interpret the algorithms in the above paragraph as one-step local search, where we are given a current solution (not necessarily feasible) close to some feasible solution S with the optimal value, and the algorithm finds a feasible solution as good as S. This motivates us to ask: if the algorithm is provided any current solution PU (as a solution for the max version) and there is a feasible solution SU close to P, can the algorithm efficiently recover a solution as good as S? Formally, we define the parameter k as the distance |PΔS|, and our goal is to design an algorithm whose runtime is arbitrary in k but polynomial in the size of the problem instance.111Actually, since |SΔS|=|(US)Δ(US)|, this parameter remains the same for both maximization and minimization versions.

We apply this model to Constraint Satisfaction Problems (CSPs), one of the most important classes of optimization problems in the theory of computation. Given a predicate R{0,1}r, MaxCSP(R) is the computational problem whose input consists of the set of variables V and the set of constraints 𝒞. Given an assignment α:V{0,1}, each constraint C𝒞 is satisfied when the values of the r specified literals (variables or their negations) belong to R. (See Section 2 for formal definitions.) The goal is to find an assignment that satisfies as many constraints as possible. Generalizing the MaxCut example above, we apply MaxCSP(R) to our model where U=𝒞 and a subset of constraints 𝒞𝒞 is feasible if there exists an assignment α that satisfies all of 𝒞 (i.e., 𝒞 is satisfiable); so the current solution 𝒫 is a set of constraints and we assume that it is close to some set of satisfiable constraints. It yields the following computational task.

Problem: ImproveMaxCSP(R)
Input: A CSP(R) instance I(V,𝒞), an integer k, and 𝒫𝒞.
Parameter: k
Promise: There exists an assignment α0 with the property |𝒞I(α0)Δ𝒫|k, where 𝒞I(α0) is the set of clauses α0 satisfies, and Δ represents symmetric difference.
Output: A good assignment α, where the word good simply means |𝒞I(α)||𝒞I(α0)|. (We do not require α to satisfy |𝒞I(α)Δ𝒫|k.)

Note that, given an instance (I(V,𝒞), k, 𝒫), the problem is essentially equivalent to find α such that |𝒞I(α)| is at least maxβ:|𝒞I(β)Δ𝒫|k|𝒞I(β)|; in words, find a feasible solution as good as any feasible k-neighbor of 𝒫. (Formally, we still will keep the fixed promised assignment α0 as part of the instance and define a good assignment based on α0.)

We also observe that if the decision version of CSP(R) (i.e., finding an assignment that satisfies every constraint) can be solved in polynomial time, an easy |𝒞|kpoly(|V|,|𝒞|)-time algorithm for ImproveMaxCSP(R) follows by exhaustively guessing (𝒞I(α0)Δ𝒫) and solving the decision version with constraints 𝒞I(α0); otherwise it is NP-hard even when k=0 (just letting 𝒫=𝒞), which concludes that ImproveMaxCSP(R) is in 𝐗𝐏 if and only if the decision version is in 𝐏. Also, if MaxCSP(R) is NP-hard, there is no poly(|V|,|𝒞|,k)-time algorithm for ImproveMaxCSP(R).

In this paper, we provide a complete characterization of the parameterized complexity of ImproveMaxCSP(R), where R is restricted to a symmetric predicate, whose acceptance only depends on the number of true literals. This still includes many well-known CSPs including rLIN (which generalizes MaxCut), rSAT, rAND, rNAE, and rAE, where AE and NAE abbreviate All-Equal and Not-All-Equal respectively. Namely, the main contribution of this paper is the following theorem:

Theorem 1 (Main Theorem (Informal)).

For any symmetric predicate R, ImproveMax CSP(R) is either FPT or W[1]-hard.

It turns out that among nontrivial predicates, rAND for any r1 and 2AE (generalizing MaxCut) are the only ones in FPT. We design parameterized algorithms for them extending the previous algorithms for MinCSP. While many predicates inherit their hardness result from the hardness of MinCSP, we also prove hardness for the problems whose MinCSP is tractable, namely rAE for r3 and 1-out-of-rSAT for r2. See Section 2.3 for our formal characterization.

In the context of local search, a natural special case of ImproveMaxCSP(R) is when the input 𝒫 is restricted to be 𝒞I(β) for some assignment β:V{0,1}. Theorem 1 addresses this special case as well, in the sense that our W[1]-hard reductions indeed have 𝒫=𝒞I(β) for some assignment β.

Related Work and Discussion

The parameterized complexity of local search, whose goal is to improve the current solution to a strictly better solution nearby, was indeed studied in the parameterized complexity literature. Fellows, Fomin, Lokshtanov, Rosamond, Saurabh, and Villanger [8] study various problems like r-Center, Vertex Cover, Odd Cycle Transversal, Max-Cut, and Max-Bisection on special classes of sparse graphs like planar, minor-free, and bounded-degree graphs, and Szeider [25] considers a similar framework for SAT and MaxSAT.

This (strict) local search model can be relaxed to another model called permissive local search [19]. Here we are given a solution S, and the goal is to find a solution S which has lower cost (which may differ from S in more than k vertices), or correctly conclude that every solution which differs from S in at most k vertices has higher cost. This model has been studied for a few problems - including a variant of stable marriage [19], Vertex Cover [9] and also in the context of Min Ones CSPs [14], extending Marx’s complete classification of the parameterized complexity of CSPs based on if there is a solution with exactly k ones [17].

One crucial difference between our model and all previous models on CSPs is how the distance between the two solutions is defined. The previous papers define it as the number of variables with different values in two solutions, but our definition concerns the set of constraints whose satisfaction changes between two solutions. In fact, recall that our definition of a solution is an arbitrary set 𝒫 of constraints not necessarily feasible (i.e., corresponding to a variable assignment), which allows 𝒫=𝒞 and captures algorithms parameterized by the number of unsatisfied constraints. In that sense, our model is slightly broader than traditional local search where one maintains a feasible solution and tries to strictly improve in every step.

Fixed parameter tractability of CSPs parameterized by the number of unsatisfied constraints has been an important and active research area [2, 11, 12, 13], where a complete classification for Boolean relations was obtained very recently. Their definition of CSPs is strictly more general than ours, where each constraint language contains multiple predicates, even with different arities. It is an exciting research direction to extend our framework for every CSP.

Our negative results can be interpreted as demonstrating the importance of near-perfect instances for classical FPT algorithms. For instance, we show ImproveMaxCSP(2SAT) is W[1]-hard while MinCSP(2SAT) is known to admit an FPT algorithm [23, 22, 6, 21], so the fact that the optimal solution indeed satisfies all but k constraints affects the parameterized complexity.

There are several natural research directions based on this paper. We believe that the following directions will be interesting to study further:

  1. 1.

    The most immediate one is to extend our characterization for all CSPs. One notable set of boolean relations whose complexity is still open in our model is {x=y,x¬y}.

  2. 2.

    A natural variant of our model is when the solution is represented as an assignment to the variables, which is guaranteed to have a Hamming distance at most k to a strictly better solution. For Min Ones CSP, where the goal is to find a satisfying assignment with the minimum number of true variables, this variant has been studied previously [14].

  3. 3.

    Other than CSPs, one framework that captures numerous results in the FPT literature is covering (resp. packing) problems, especially on graphs, where we want to select the smallest (resp. largest) subset SU subject to some covering (resp. packing) constraints. Local search naturally extends to this setting (i.e., we are given SU with |SΔS|k), and it will be interesting to see if classical FPT results on graph covering/packing problems extend to this model, including Multicut [3, 18], Min Bisection [5], k-Cut [10], Disjoint Paths [24].

  4. 4.

    In the approximation algorithms literature, there are numerous studies about CSPs on structured instances, most notably dense and expanding instances (see [1] and references therein). It would be interesting to see whether these structures, if suitably parameterized, help the problems become more tractable in our model.

2 Our Results

2.1 Constraint Satisfaction Problems

In this section we recall basic definitions of constraint satisfaction problems.

For integer r+, a boolean relation R is a subset of 𝔽2r. The integer r is called the arity of R. For a boolean relation R of arity r and b𝔽2r, define the boolean relation Rb:={αbαR}, where is the addition operator over 𝔽2r. When considering R as a clause in a CSP instance, operator can be seen as variable negations. For a relation R with index [r] and S[r], define the projection relation πS(R)={αSαR}, where αS means extracting the value on coordinates in S.

A boolean relation R of arity r is symmetric if for all (x1,,xr)𝔽2r and any permutation p:[r][r], (x1,,xr)R(xp(1),,xp(r))R. Equivalently, R is symmetric if there exists S{0,1,,r} such that (x1,,xr)Ri=1rxiS (where the addition is performed in ). We define SymRel(r,S) to be such R.

A boolean constraint language is a set of boolean relations. Two constraint languages are equivalent if they contain exactly the same set of relations. A clause C over a boolean constraint language Γ is a pair (VC,RC), where RCΓ and VC=(vC,1,,vC,r) is an r-tuple of variables where r is the arity of RC. We refer to VC as the scope of the clause C. An assignment α:VC{0,1} satisfies clause (VC,RC) if (α(vC,1),,α(vC,r))RC, and α violates the clause otherwise.

In this paper, we only consider a restricted set of boolean constraint languages, where the language Γ includes all possible negation patterns Rb for some symmetric predicate R of arity r and b𝔽2r. We use the notation SymLang-N(R)={Rbb𝔽2r} for such Γ, where SymLang-N stands for “symmetric language with negation”. We further define SymLang-N(r,S) to be SymLang-N(SymRel(r,S)).

For a boolean constraint language Γ, a CSP(Γ) instance I is a pair (VI,𝒞I), where VI is the set of variables, and 𝒞I is the set of clauses over the boolean constraint language Γ, all of which have scope inside VI. We say a variable v is incident to a clause C if v belongs to the scope of C.

For an assignment α:VI{0,1}, define 𝒞I(α) to be the set of clauses α satisfies in I. We further define costI(α)=|𝒞\𝒞I(α)|, the number of unsatisfied clauses, to be the cost of the assignment. We define the size of an instance I as max(|VI|,|𝒞I|) and denote it by nI. We ignore the subscripts when the instance is clear in the context.

Now we give formal definitions for the problems we consider. We first define MinCSP(Γ), and then define our central problem ImproveMaxCSP(Γ). In this paper, our main goal is to characterize the parameterized complexity of ImproveMaxCSP(Γ) when Γ=SymLang-N(r,S) for some r+ and S{0,1,,r}.

Problem: MinCSP(Γ)
Input: A CSP(Γ) instance I(V,𝒞), an integer k.
Parameter: k.
Output: An assignment α with cost(α)k if it exists, otherwise report that such an assignment does not exist.

Problem: ImproveMaxCSP(Γ)
Input: A CSP(Γ) instance I(V,𝒞), an integer k, and 𝒫𝒞
Parameter: k
Promise: There exists an assignment α0:VI{0,1} such that |𝒞I(α0)Δ𝒫|k.
Output: A good assignment α, where the word good simply means |𝒞I(α)||𝒞I(α0)|. (We do not require the output α to satisfy |𝒞I(α)Δ𝒫|k.)

From the definition, MinCSP(Γ) is a special case of ImproveMaxCSP(Γ) by setting 𝒫 to be the constraint set 𝒞.

A boolean constraint language Γ is trivial if Γ= or Γ={{0,1}r} for some r+ and nontrivial otherwise. When Γ is trivial, MinCSP(Γ) and ImproveMaxCSP(Γ) can be solved by trivial algorithms. So in the following we only consider nontrivial boolean constraint languages.

2.2 Abbreviations for Special CSPs

For simplicity, we abbreviate boolean constraint languages mentioned in the paper. Here we introduce the following simple but useful claim in identifying equivalence between boolean constraint languages.

Claim 2.

SymLang-N(r,S) and SymLang-N(r,{rxxS}) are equivalent boolean constraint languages.

Proof.

From SymRel(r,S)+(1,1,,1)=SymRel(r,{rxxS}), where (1,1,,1) is the element in 𝔽2r that has value 1 in each coordinate, we have SymRel(r,S)+b=SymRel(r,{rxxS})+(b+(1,1,,1)) for any b𝔽2r.

We will use the following abbreviations in this paper.

  • r and =SymLang-N(r,{0})=SymLang-N(r,{r}).

  • rSAT=SymLang-N(r,{1,2,,r})=SymLang-N(r,{0,1,,r1}).

  • rAE (All Equal) = SymLang-N(r,{0,r}).

  • 1-out-of-rSAT = SymLang-N(r,{0,1})=SymLang-N(r,{r1,r}).

We also use abbreviations for the corresponding MinCSP and ImproveMaxCSP problems. For example, ImproveMaxCSP(r and ) corresponds to the problem ImproveMaxCSP(SymLang-N(r,{0})).

2.3 Our Characterization

Having defined our framework, we first provide the formal version of Theorem 1:

Theorem 3 (Main Theorem (Formal)).

For any r+ and S{0,1,,r}, the problem ImproveMaxCSP(SymLang-N(r,S)) is either FPT or W[1]-hard.

As MinCSP(Γ) is a special case of ImproveMaxCSP(Γ), the W[1]-hardness of the former implies that of the latter. The recent characterization of parameterized tractability of MinCSP(Γ) [13] implies the following theorem.

Theorem 4.

For nontrivial Γ=SymLang-N(r,S) for some r+ and S{0,1,,r} that is not equivalent to r and ,rAE or 1-out-of-rSAT, ImproveMaxCSP(Γ) is W[1]-hard.

It remains to study the remaining problems.

 Remark 5.

We say that an algorithm A solves ImproveMaxCSP(Γ), if for any instance that satisfies the promise, A outputs a good assignment. However, the run time is measured on all possible instances. In other words, A runs in f(k)nO(1) time if it terminates and outputs some assignment in f(k)nO(1) time no matter whether the input instance (I,k,𝒫) satisfies the promise. Clearly, only the run time on instances satisfying the promise is critical, as we can always set a run time limit to the algorithm to rule out instances that require too much time to indicate their violation of promise.

For ImproveMaxCSP(r and ), a color-coding combined with the LP rounding for Densest Subhypergraph yields the following result proved in Section 3.

Theorem 6.

There exists an algorithm that solves ImproveMaxCSP(r and ) in 2O(klogk)nO(1) time for all r1.

For rAE, its tractability depends on r. When r=2, we use the celebrated unbreakability framework [10, 4, 5, 16] to design a parameterized algorithm in Section 4.

Theorem 7.

There exists an algorithm that solves ImproveMaxCSP(2AE) in time 2O(k2)nO(1).

However, for rAE with r3, we show nontrivial reductions from Paired Minimum st-Cut to show the following hardness.

Theorem 8.

ImproveMaxCSP(rAE) is W[1]-hard for all r3.

Finally, for 1-out-of-rSAT, we prove that even the first nontrivial case r=2, which is equivalent to 2SAT, is already W[1]-hard. Even though MinCSP(2SAT) is in FPT, this result follows from the (slightly informal) fact that Vertex Cover and Independent Set are equivalent in our model.

Theorem 9.

ImproveMaxCSP(1-out-of-rSAT) is W[1]-hard for any r2.

The hardness proofs can be found in the full version. It is easy to see that the other theorems imply Theorem 3 in a straightforward way.

3 FPT Algorithm for 𝒓AND

The main goal of this section is to prove Theorem 6. During the course of the algorithm, we create instances involving and constraints of different arities. Hence, we will show a slightly stronger result:

Theorem 10.

There is an algorithm that solves ImproveMaxCSP(rrr and ) in 2O(klogk)nO(1) time for all r1.

Since rrr and r and , Theorem 10 immediately shows that for any r1, the problem ImproveMaxCSP(r and ) is FPT.

3.1 Preliminaries

In this section we recall basic definitions about hypergraphs. A hypergraph H(V,E) is a generalization of graph where an edge can contain multiple vertices. For eE and vV, say v is incident to e and e is incident to v if e contains v. For a hypergraph H and V0V, we denote H(V0) as the induced subhypergraph of V0 in H, and denote E(H(V0)) to be the edge set of the induced subhypergraph.

In the main algorithm in this section (provided in Theorem 14), we need to solve the following problem:

Problem: Maximum Induced Subhypergraph with Vertex Weights.
Input: A hypergraph H(V,E) and a weight function w:V.
Output: A vertex subset V0V that maximizes |E(H(V0))|vV0w(v).

The problem is closely related to Densest Subgraph (See [15] for a survey) and has a polynomial-time algorithm based on similar algorithms for Densest Subgraph. One algorithm is to observe that |E(H(V0))|vV0w(v) is supermodular and run a submodular minimization algorithm.222We thank an anonymous reviewer for this observation. The below is an LP-based algorithm specific to our setting.

Lemma 11.

There exists a polynomial-time exact algorithm that solves Maximum Induced Subhypergraph with Vertex Weights.

Proof.

Consider the following LP:

maximizeeExevVw(v)yvsubject toxeyveE,vVs.t.eisincidenttovxe[0,1]eEyv[0,1]vV

Since we use xeyv to mimic the constraint that “one should select a vertex before selecting incident edges”, if the LP is integral (i.e. xe,yv{0,1}) then the set of vertices v with yv=1 in the optimal solution of the LP corresponds to the correct output to the Maximum Induced Subhypergraph with Vertex Weights problem.

The algorithm solves the LP, providing optimal fractional solution (xe,yv), and rounds the solution to an integer solution in the following way: Arbitrarily select p(0,1] and set xep=[xep],yvp=[yvp], where [P] denotes the Iverson bracket and equals to 1 if P is true otherwise 0 for some statement P. The solution is clearly an integral solution to the LP.

Now we show that any such p produces an integral solution that has the same value as that of (xe,yv), denoted as f. Define f(p) to be the objective function value of the solution (xep,yvp). Clearly we have f(p)f. We further have

01f(p)dp =01(eE[xep]vVw(v)[yvp])dp (1)
=eExevVw(v)yv=f

So the set {x(0,1]f(x)<f} has zero measure. Further from the fact that f(p) is a step function of finite number of “steps” and each “step” has nonzero length, such set must be empty, and f(p)=f.

Our FPT algorithms in Section 3 and Section 4 will use the technique of color coding and its derandomization given below.

Theorem 12 ([20]).

Given a set U of size n and integers 0a,bn, one can in time 2O(min(a,b)log(a+b))nlogn construct a family of at most 2O(min(a,b)log(a+b))logn colorings U{0,1} such that the following holds: for any sets A,BU, AB=, |A|a, |B|b, there exists a coloring χ with χ(a)=1 for all aA and χ(b)=0 for all bB.

3.2 Algorithm with Variable Solution

Given an instance (I,k,𝒫), we say that 𝒫 is satisfiable if some assignment satisfies all clauses in 𝒫. We will give an algorithm that runs in 2O(klogk)nO(1) time and solves ImproveMaxCSP(rrr and ) when the instance satisfies an additional promise that 𝒫 is satisfiable.

When this additional promise is satisfied, it is easy to find an assignment satisfying all the clauses of 𝒫 in polynomial time, so in the following we assume that the instance (I,k,𝒫) is equipped with such an assignment α. In the full version, we show how to transform any instance into instances where this additional promise is true.

Equipped with this additional assignment, we then restructure the instance in the following way: Define k:=k+|𝒫ΔCI(α)| and 𝒫:=CI(α), and replace (I,k,𝒫,α) with (I,k,𝒫,α), to keep 𝒫 to be maximal in accordance with α. In other words, we reset 𝒫 to be the set of clauses satisfied by α. If the instance satisfies the promise (that some good assignment is close to the 𝒫), the good assignment satisfies at most |𝒫|+k clauses, which implies that |𝒫ΔCI(α)|k, and k2k. If k>2k, we return an arbitrary assignment (to handle cases where the promise is not met).

Now we show that, there exists an good assignment close to 𝒫 whose Hamming distance to α is small.

Lemma 13.

For a ImproveMaxCSP(rrr and ) instance (I,k,𝒫,α), there exists a good assignment β:V{0,1} with |CI(β)Δ𝒫|k and |{vVα(v)β(v)}|rk.

Proof.

Choose a good β with |CI(β)Δ𝒫|k, and if there are multiple ones, choose the one with the smallest hamming distance to α.

For any v with α(v)β(v), consider assignment β that differs from β only on v. β has smaller Hamming distance to α than β, so either β is not good, or β is good but does not satisfy the promise. Both cases require that some clause C𝒞 is satisfied in β but violated in β. Since all clauses are AND clauses and β(v)=α(v), such clause C is violated in α. Therefore, all variables contributing to the hamming distance are incident to some clauses in CI(β)Δ𝒫, and the statement follows from the fact that |CI(β)Δ𝒫|k and that the arity of all relations in rrr and is no more than r.

Now we use the (derandomized) color coding technique along with the algorithm of Lemma 11 for Maximum Induced Subhypergraph with Vertex Weights to solve our problem ImproveMaxCSP(rrr and ).

Theorem 14.

There is an algorithm solving ImproveMaxCSP(rrr and ) in 2O(klogk)nO(1) time when the input instance satisfies an additional promise that 𝒫 is satisfiable.

Proof.

First use Theorem 12 with a=b=rk to obtain a family of at most 2O(klogk)logn colorings with binary labels for variables. The algorithm then produces an assignment for each coloring and reports the best among them. In the following we fix a particular coloring.

Let L1 be the set of variables with label 1. Construct a binary relation on L1, where uv if u=v or some clause C𝒫 is incident to both u and v. Since is reflexive and symmetric, its transitive closure is an equivalence relation. Denote L1/ as the quotient set of the equivalence relation which includes all equivalence classes of the transitive closure. The intuition is that, the algorithm will produce the answer from α by flipping several variables with label 1, and variables in one equivalence class are considered a group and would be flipped or kept at the same time.

We then construct a hypergraph H(VH,EH) with weight function w:VH as follows:

  • For each equivalence class in L1/, introduce a vertex v in VH, whose weight w(v) equals to the number of clauses in 𝒫 incident to any variable in the equivalence class. Intuitively, the weight measures that how many clauses we will lose if we flip this equivalence class.

  • For each clause C𝒞I\𝒫, if C can be satisfied by flipping L1 from α, introduce a hyperedge incident to all equivalence classes containing incident vertices of C. So the clause will be satisfied if we flip all equivalence classes incident to this hyperedge.

Finally, the algorithm uses the algorithm for Maximum Induced Subhypergraph with Vertex Weights proposed in Lemma 11 to find V0VH that maximizes |E(H(V0))|vV0w(v), and returns the assignment produced by flipping in α all variables belonging to equivalence classes in V0.

The algorithm runs in 2O(klogk)nO(1) time since the whole process can be done in polynomial time except trying all 2O(klogk)nO(1) colorings produced by Theorem 12. Now we show that the algorithm produces a good assignment for instances satisfying the promise that some good assignment is close to the 𝒫. Since we finally choose the best assignment among all colorings, it is sufficient to show that there exists some coloring that produces a good assignment.

Fix any good assignment β with |CI(β)Δ𝒫|k and |{vVα(v)β(v)}|rk, where α is an assighnment such that 𝒫=𝒞I(α0). According to Lemma 13 such β exists. Define N(CI(β)Δ𝒫) to be all variables incident to any clause in CI(β)Δ𝒫. Define V0={vN(CI(β)Δ𝒫)α(v)=β(v)} and V1=N(CI(β)Δ𝒫)\V0. Note that both |V0|,|V1|rk.

According to Theorem 12, there exists a coloring assigning V0 to 0 and V1 to 1. We consider the behavior of the algorithm when trying this coloring.

We first claim that, there exists a set of equivalence classes in L1/ whose union is exactly V1. This is equivalent to the statement that there is no uV1 and vL1\V1 such that uv. Suppose uv and uV1, then some C𝒫 is incident to both of them. Since C is incident to uV1 which satisfies α(u)β(u), C is violated by β, so C𝒞I(β)Δ𝒫. Then vN(CI(β)Δ𝒫), which finishes the proof since it implies vL1\V1.

The previous statement shows that, there exists some VVH, such that by flipping from α all variables in equivalence classes corresponding to V, one can produce β. We further show the following two claims:

  • For any VVH, suppose α is produced by flipping from α all variables in every equivalence class in V, then costI(α)costI(α)|E(H(V))|vVw(v). Notice that the latter is the objective of the Maximum Induced Subhypergraph with Vertex Weights problem. In other words, the cost of α would not be underestimated. To see this, consider clauses in CI(α)ΔCI(α). Clauses satisfied in α but unsatisfied in α are those belonging to 𝒫 and incident to V, counted exactly by vVw(v). Clauses satisfied in α but unsatisfied in α are partially counted by |E(H(V))|, since it does not include satisfied clauses in α violated by the assignment produced from flipping L1 in α. However, all hyperedges in E(H(V)) correspond to clauses satisfied in α but unsatisfied in α.

  • costI(α)costI(β)=|E(H(V))|vVw(v), i.e. the cost of β is correctly estimated by the Maximum Induced Subhypergraph with Vertex Weights objective. We only need to show that E(H(V)) contains all clauses satisfied in β but unsatisfied in α. Since the coloring colors V0 with 0 and V1 with 1, all clauses satisfied in β but unsatisfied in α have label-1 incident variables inside V1L1, so the clauses will introduce hyperedges in H whose scope is inside V, so they are all counted by |E(H(V))|.

The previous two claims imply that, V is one of the optimal solutions to the Maximum Induced Subhypergraph with Vertex Weights problem for the constructed hypergraph 5H, and any optimal solution of the Maximum Induced Subhypergraph with Vertex Weights problem corresponds to a good assignment to the CSP instance, which finishes the proof.

4 FPT Algorithms for 𝟐𝐀𝐄

In this section we prove Theorem 7.

4.1 Preliminaries

We recall useful definitions about graphs. Let G=(V,E) be a multigraph, where parallel edges and loops are allowed. For two disjoint vertex sets A,BV, we denote by E(A,B) the set of edges between A and B. When (A,B) is a partition, then E(A,B) is the set of edges in the corresponding cut. For a vertex subset VV, we denote by G(V) the subgraph of G induced by V. We write E(G(V)) for the set of edges in G(V). For a set EE, we denote by GE the multigraph (V,EE). For SV, we let N(S):={vVS:uS such that (u,v)E} be the open neighborhood of S. We say two cuts (A,B) and (X,Y) are k-close if |E(A,B)ΔE(X,Y)|k. When the graph is clear in the context, we define n=max(|V|,|E|) to be the size of the graph.

Notice that we can see clauses as edges connecting variables, assigning boolean values to variables as partitioning the variable set into two sets, and the equality and non-equality constraints correspond to uncut and cut constraints respectively. This motivates us to introduce the following graph problem. Given a graph G=(V,E), an edge type function t:E{0,1} and a partition (A,B) of V, define C(A,B)=(t1(1)E(A,B))(t1(0)(E\E(A,B)) to be the set of edges satisfied by (A,B), where edges of type 1 need to be separated, while edges of type 0 should be inside some vertex set.

Problem: ImproveMaxCut-Uncut
Input: A connected multigraph G(V,E), an integer k, 𝒫E, and an edge type function t:E{0,1}.
Parameter: k
Promise: There exists some (A,B) that maximizes |C(A,B)| and satisfies |C(A,B)Δ𝒫|k.
Output: Any partition (A,B) of vertices that maximizes |C(A,B)|. (Notice that we do not require |C(A,B)Δ𝒫|k for the output.)

Clearly, if the given graph for ImproveMaxCut-Uncut is not connected, we can solve each connected component separately, so connectivity of G does not lose any generality for the problem. The following claim is straightforward.

Claim 15.

ImproveMaxCSP(2AE) and ImproveMaxCut-Uncut are equivalent.

In the following, we present the algorithm for ImproveMaxCut-Uncut.

4.2 From Edge Solution to Vertex Solution

We first apply a pre-processing algorithm to the given ImproveMaxCut-Uncut instance, intending to make it in accordance with some partition of the vertex set.

Lemma 16.

There exists an algorithm that given a ImproveMaxCut-Uncut instance, runs in 4knO(1) time and finds a bipartition (A,B) of the vertex set V such that there exists a good partition (A,B) which satisfies |C(A,B)Δ𝒫|k and |C(A,B)ΔC(A,B)|3k.

Proof.

Fix any (A,B) satisfying |C(A,B)Δ𝒫|k. We first find the largest subset 𝒫1𝒫 that can be simutaneously satisfied by some bipartition using a 4knO(1)-time algorithm for MinCSP(2AE) [7]: Since C(A,B)𝒫 is one possible solution, this means that |𝒫1||C(A,B)𝒫|max(𝒫,|C(A,B)|)k. Let (A,B) be any bipartition satisfying 𝒫1. Consider C(A,B): It contains all edges in 𝒫1 and perhaps more. However, since the size cannot be larger than |C(A,B)|, there are at most k edges in C(A,B)𝒫1. Now we have

|C(A,B)ΔC(A,B)||𝒫ΔC(A,B)|+|𝒫𝒫1|+|C(A,B)𝒫1|3k.

This completes the proof.

From Lemma 16, we can set 𝒫 to be such C(A,B) and triple k to change the original ImproveMaxCut-Uncut instance to an equivalent ImproveMaxCut-Uncut instance, whose 𝒫 is given by some C(A,B) for a vertex partition (A,B).

4.3 Algorithms for Instances with Vertex Solution

In the rest of this section, we prove the following theorem:

Theorem 17.

There exists an algorithm that, given a ImproveMaxCut-Uncut instance (G(V,E),k,𝒫,t) where 𝒫=C(A,B) for some partition (A,B) of V, finds a partition (X,Y) that maximizes |C(X,Y)| in time 2O(k2)nO(1).

We first show how this theorem implies the main theorem.

Proof of Theorem 7.

According to Claim 15, we only need to find such algorithm for ImproveMaxCut-Uncut. For a ImproveMaxCut-Uncut instance, we first apply the algorithm stated in Lemma 16 to produce an instance equivalent to the input whose 𝒫 is given by some C(A,B) for a vertex partition. Then we apply the algorithm stated in Theorem 17 to solve the new instance. The runtime is 4knO(1)+2O(k2)nO(1)=2O(k2)nO(1).

Recall that we are given a vertex partition (A,B) as the solution, while there exists a good partition (X,Y) with |C(A,B)ΔC(X,Y)|k. Let AX:=AX and define AY,BX,BY similarly.

Our high-level approach follows the framework first introduced by Kawarabayashi and Thorup [10] for Minimum k-cut and its refinement by Chitnis et al. [4]. Let us define the following terminal version of the problem. We will fix k to be the parameter of the initial instance, which remains invariant throughout the recursive calls to the terminal version.

Problem: ImproveMaxCut-Uncut Terminal Version
Input: A connected multigraph G(V,E), an integer kk, a 𝒫E, an edge type function t:E{0,1}, a set of terminals TV with |T|2k (Notice that it is k rather than k) and a marked edge set ME.
Parameter: k
Promise:

  • 𝒫=C(A,B) for some partition (A,B);

  • M is a matching allowing parallel edges: Any two edges in M are either completely disjoint or parallel copies of each other.

  • There exists a good cut (X,Y) with |C(A,B)ΔC(X,Y)|k and ME(X,Y)E(A,B).

Requirement: For each function f:T{X,Y} and 0k′′k, output a cut (Xf,k′′,Yf,k′′) satisfying all the following or output nothing:

  1. 1.

    consistent with f: f(v)=X iff vXf,k′′ for all vT,

  2. 2.

    consistent with M: ME(A,B)E(Xf,k′′,Yf,k′′),

  3. 3.

    k′′-close to (A,B): |C(A,B)ΔC(Xf,k′′,Yf,k′′)|k′′,

For any (X,Y) which is a good cut that satisfies |C(A,B)ΔC(X,Y)|k′′ and ME(X,Y)E(A,B) for some k′′k, the output (Xf,k′′,Yf,k′′), where f is consistent to (X,Y), should additionally be a good cut (not necessarily equal to (X,Y)).

Clearly, ImproveMaxCut-Uncut is a special case with M=T= after doing the pre-processing in Lemma 16. In the following we introduce the algorithm solving ImproveMaxCut-Uncut Terminal Version.

Let q:=k222k+2. Before introducing the algorithm, we require one additional definition.

Definition 18 ((k,q)-cut).

Let G=(V,E) be a multigraph and let ME be the set of marked edges which is a matching allowing parallel edges. A cut LV is called (k,q)-balanced (more simply a (k,q)-cut) if the following conditions are met.

  • |E(L,VL)|k.

  • Both G(L) and G(VL) are connected (using both edges inside and outside M).

  • Both G(L) and G(VL) contains at least q non-marked edges (edges outside M).

Our algorithm follows a simple win-win strategy. If there is no (k,q)-cut, a simple color-coding algorithm will solve the terminal problem. If there is a (k,q)-cut, by recursively solving a smaller subproblem, one can reduce the number of unmarked edges. Combining this with the algorithm to compute a (k,q)-cut, one can solve the terminal version in FPT time.

Now we present each of the three parts. We start by directly solving the case where there is no (k,q)-cut, using the (derandomized) coloring coding technique.

Claim 19.

One can solve ImproveMaxCut-Uncut Terminal Version in 2O(klogq)nO(1) time when there is no (k,q)-cut in the instance.

Proof.

Given an ImproveMaxCut-Uncut Terminal Version instance I= (G,k,𝒫=C(A,B),t,T,M), the algorithm considers every f:T{X,Y} and 0k′′k and does the following. Assume that f and k′′ is consistent with some good cut (X,Y), because apart from running time, the requirement only concerns for the correct f and k′′.

Note that the set of edges S=C(A,B)ΔC(X,Y)=E(A,B)ΔE(X,Y)=E(AX,BX)E(AY,BY)E(AX,AY)E(BX,BY) forms a cut between L:=AXBY and R:=AYBX, no matter how t assigns type to edges. Since G is connected and |S|k′′, GS has at most k′′+1 connected components.

Assume towards a contradiction that there are two connected components L,R of GS such that LL and RR and both G(L) and G(R) have at least q non-marked edges. Then the minimum cut separating L and R in G will cut at most k′′k edges where the two resulting parts are connected and contain L and R respectively, which contradicts the fact that there is no (k,q)-cut. 333We use the fact that any minimum st-cut in a connected graph have both sides connected.

Therefore, at least one of L and R (say R) has the property that every connected component of GS contained in R has at most q non-marked edges. Since marked edges form a matching, the number of vertices in such a component can be at most 2q+2, so we have |R|=O(qk).

Let {Ri}i=1 be the connected components of G(R). Define
ai+=|C(AΔRi,BΔRi)\C(A,B)| and ai=|C(A,B)\C(AΔRi,BΔRi)|. Notice that |C(X,Y)|=|C(A,B)|+i=1(ai+ai) and |C(X,Y)ΔC(A,B)|=i=1(ai+)+(ai)k. Guessing the correct values of and ai+,ai takes at most kO(k) time.

Let N=N(R) be the open neighbor of R in G. Note that |N||E(R,VR)|=|C(A,B)ΔC(X,Y)|k′′. Use Theorem 12 with a=|R|,b=k to have a family of at most 2O(klogq)logn colorings that color each vertex using {0,1}. There exists a coloring χ that colors R with 1 and colors N with 0. For each i[], find all candidates RiV that is identical to Ri with respect to the guessed information about Ri. Formally, Ri is a connected component of G after deleting all vertices of color 0, and in line with the guessing ai+ and ai.

For the correct coloring χ, such Ri exists since Ri satisfies the condition. Also, finding all such candidates Ri is easy in polynomial time since one only needs to scan connected components after deleting color-0 vertices.

For any R1,,R that are disjoint, since Ri and N(Rj) are disjoint for any i,j[], the set of edges newly cut/uncut by updating AAΔRi and BBΔRi are disjoint for all i. Therefore, letting R:=iRi and letting AAΔR and BBΔR the resulting partition has |C(A,B)|=|C(A,B)|+i(ai+ai)=|C(X,Y)| and |C(A,B)ΔC(A,B)|=i(ai++ai)k′′, so the solution is good and k′′close to (A,B).

We finally need the solution (A,B) to be consistent with both f and M. For any vertex vT, if v has color 0, then vA if and only if vX (recall R=AYBX), otherwise by including v in R, one can change the belonging of v. So the consistency of f requires certain components to be included into or excluded from Ri. For (u,v)M, if u and v has the same color then ME(A,B)E(X,Y) if and only if ME(A,B) which is always satisfied, otherwise ME(A,B)E(X,Y) if and only if the label-1 vertex is not in R, so consistency of M requires certain components to be excluded from Ri.

The consistency constraints are all in the form of “removing a component from the candidates” or “impose certain components to be selected by Ri”, which is easy to find out and handle in polynomial time.

We finally calculate the running time of the algorithm. The algorithm first tries all possible (f,k′′) in 2O(k) time, tries all colorings in 2O(klogq)nO(1) time, and finally guesses the correct values of and ai+,ai in 2O(klogk) time. All other processes are in polynomial time. So the total running time is 2O(klogq)nO(1).

Next we show how to compute a (k,q)-cut if it exists.

Claim 20.

There exists an algorithm that runs in time 2O(klogq)nO(1) and returns a (k,q)-balanced cut for a connected graph if it exists.

Proof.

Suppose that LV is a (k,q)-cut and R=VL. We first show that there exists ELE(L) that induces a connected subgraph and has at most O(q) edges but at least q non-marked edges. Consider a procedure where we start from VL={v} for an arbitrary vertex vL, and iteratively add one arbitrary vertex uLN(VL) to VL until E(G(VL)) contains at least q non-marked edges. Since E(G(VL)) is connected and increased by at least one while marked edges form a matching, |VL|2q+2. Then we choose ELE(G(VL)) that contains at least q non-marked edges while (VL,EL) is connected and |EL|O(q). Define VR and ER similarly.

Use Theorem 12 with a=O(q) and b=k to try at most 2O(klogq)logn colorings of edges with 2 colors. One coloring χ colors E(L,R) with 0 and ELER with 1. After deleting all edges of color 0, there are two connected components VL and VR such that ELE(G(VL)) and ERE(G(VR)). Note that VLVR because L and R are separated by removing edges of color 0.

Then, trying every pair (U,V) of connected components after deleting 0-colored edges and computing the minimum cut separating U and V in the original graph will yield a cut of size at most k where each side is connected has at least q non-marked edges. We use the fact that in a connected graph, any minimum s-t cut has both of its sides connected.

Finally, we prove that the existence of a (k,q)-cut, combined with a recursion, allows us to make progress by reducing the number of unmarked edges. Let T(m) be the running time of our algorithm to solve the terminal version with m unmarked edges.

Claim 21.

Suppose there exists a (k,q)-cut, in time T()+nO(1), one can reduce the current instance to another ImproveMaxCut-Uncut Terminal Version instance with at least q/2 fewer unmarked edges for some [q,mq].

Proof.

Let (L,R) be a (k,q)-cut. Without loss of generality, suppose that L has at most k terminals from T, and let TLL be the set of vertices that have an edge to R. Letting T=(TL)TLL be the new set of terminals for L, we know that |T|2k. Let be the number of unmarked edges in L and m be the total number of unmarked edges.

Recursively solve the terminal version with input (G(L),(LA,LB),k,T,ME(G(L))). For each f:T{X,Y} and 0k′′k, it returns a partition (Xf,k′′,Yf,k′′) of L that is (1) consistent with f, (2) consistent with ME(G(L)), and (3) k′′-close to (LA,LB) (or nothing).

Let f:T{X,Y} be the correct guessing with respect to the good partition (X,Y) and k be the correct closeness parameter |C(AL,BL)ΔC(XL,YL)| in L. We update (X,Y) with X(XR)Xf,k and Y(YR)Yf,k. Note that the new (X,Y) is still a good cut since (Xf,k,Yf,k) is good within L and the interaction between L and R only depends on the terminals T, where the previous and new solutions agree. By the guarantee (2) and (3) in the above paragraph, the new (X,Y) is still k-close to (A,B) and consistent with M.

Since L has at least q=k222k+2 non-marked edges and there are at most 22k(k+1) possible values for f and k′′, we have |E(L)(f,k′′(C(AL,BL)ΔC(Xf,k′′,Yf,k′′))|q/2. These edges do not belong to C(A,B)ΔC(X,Y)=E(A,B)ΔE(X,Y) for sure. For each such edge e, perform the following operation.

  • If eE(A,B), which means that e is not cut in the current solution, this means that e is not cut in the good solution too. Contract it.

  • If eE(A,B), mark it. To ensure that the set of marked edges M is a matching, if e=(u,v),f=(v,w) are both in M with uw, then we know that u,w will be in the same side in the good solution, so we can contract them.

By doing this, the number of unmarked edges is decreased by at least q/2.

With the three main claims, we finish the proof of Theorem 17.

Proof of Theorem 17.

From the definition of the terminal version, given graph G and the current solution (A,B), running the terminal version with T=M= and k=k we can find a good cut given the promise |C(A,B)ΔC(X,Y)|k for some (possibly different) good cut (X,Y).

Let us analyze the running time. As defined previously, let T(m) be the running time of our algorithm with m unmarked edges. Since the graph is connected and marked edges form a matching, we have mn2. Our algorithm first uses Claim 20 to find a (k,q)-cut in time 2O(klogq)nO(1). If there is none, it uses Claim 19 to solve the terminal version in time 2O(klogq)nO(1). Otherwise, it uses Claim 21 to reduce the number of unmarked edges by q/2 in time T()+nO(1), for some [q,mq]. Therefore, we have the following recurrence relation:

T(m)2O(klogq)nO(1)+max[q,mq](T()+T(m(q/2))+nO(1)).

Using m[n2,n2], T(m)2O(klogq)nO(1) satisfies the above.

References

  • [1] Aditya Anand, Euiwoong Lee, and Amatya Sharma. Min-CSPs on complete instances. In Proceedings of the 2025 ACM-SIAM Symposium on Discrete Algorithms (SODA). SIAM, 2025.
  • [2] Edouard Bonnet, László Egri, and Dániel Marx. Fixed-parameter approximability of boolean mincsps. In 24th European Symposium on Algorithms (ESA 2016), page 246, 2016.
  • [3] Nicolas Bousquet, Jean Daligault, and Stéphan Thomassé. Multicut is fpt. In Proceedings of the forty-third annual ACM symposium on Theory of computing, pages 459–468, 2011. doi:10.1145/1993636.1993698.
  • [4] Rajesh Chitnis, Marek Cygan, MohammadTaghi Hajiaghayi, Marcin Pilipczuk, and Michał Pilipczuk. Designing fpt algorithms for cut problems using randomized contractions. SIAM Journal on Computing, 45(4):1171–1229, 2016. doi:10.1137/15M1032077.
  • [5] Marek Cygan, Daniel Lokshtanov, Marcin Pilipczuk, Michał Pilipczuk, and Saket Saurabh. Minimum bisection is fixed parameter tractable. In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 323–332, 2014. doi:10.1145/2591796.2591852.
  • [6] Marek Cygan, Marcin Pilipczuk, Michał Pilipczuk, and Jakub Onufry Wojtaszczyk. On multiway cut parameterized above lower bounds. ACM Transactions on Computation Theory (TOCT), 5(1):1–11, 2013. doi:10.1145/2462896.2462899.
  • [7] Konrad K Dabrowski, Peter Jonsson, Sebastian Ordyniak, George Osipov, and Magnus Wahlström. Almost consistent systems of linear equations. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 3179–3217. SIAM, 2023. doi:10.1137/1.9781611977554.CH121.
  • [8] Michael R. Fellows, Fedor V. Fomin, Daniel Lokshtanov, Frances Rosamond, Saket Saurabh, and Yngve Villanger. Local search: Is brute-force avoidable? Journal of Computer and System Sciences, 78(3):707–719, 2012. In Commemoration of Amir Pnueli. doi:10.1016/j.jcss.2011.10.003.
  • [9] Serge Gaspers, Eun Jung Kim, Sebastian Ordyniak, Saket Saurabh, and Stefan Szeider. Don’t be strict in local search! In Proceedings of the AAAI Conference on Artificial Intelligence, volume 26, pages 486–492, 2012. doi:10.1609/AAAI.V26I1.8128.
  • [10] Ken-ichi Kawarabayashi and Mikkel Thorup. The minimum k-way cut of bounded size is fixed-parameter tractable. In 2011 IEEE 52nd Annual Symposium on Foundations of Computer Science, pages 160–169. IEEE, 2011. doi:10.1109/FOCS.2011.53.
  • [11] Eun Jung Kim, Stefan Kratsch, Marcin Pilipczuk, and Magnus Wahlström. Solving hard cut problems via flow-augmentation. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 149–168. SIAM, 2021. doi:10.1137/1.9781611976465.11.
  • [12] Eun Jung Kim, Stefan Kratsch, Marcin Pilipczuk, and Magnus Wahlström. Directed flow-augmentation. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, pages 938–947, 2022. doi:10.1145/3519935.3520018.
  • [13] Eun Jung Kim, Stefan Kratsch, Marcin Pilipczuk, and Magnus Wahlström. Flow-augmentation iii: Complexity dichotomy for boolean csps parameterized by the number of unsatisfied constraints. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 3218–3228. SIAM, 2023. doi:10.1137/1.9781611977554.CH122.
  • [14] Andrei Krokhin and Dániel Marx. On the hardness of losing weight. ACM Transactions on Algorithms (TALG), 8(2):1–18, 2012. doi:10.1145/2151171.2151182.
  • [15] Tommaso Lanciano, Atsushi Miyauchi, Adriano Fazzone, and Francesco Bonchi. A survey on the densest subgraph problem and its variants. ACM Computing Surveys, 56(8):1–40, 2024. doi:10.1145/3653298.
  • [16] Daniel Lokshtanov, Saket Saurabh, and Vaishali Surianarayanan. A parameterized approximation scheme for min k-cut. SIAM Journal on Computing, (0):FOCS20–205, 2022.
  • [17] Dániel Marx. Parameterized complexity of constraint satisfaction problems. computational complexity, 14:153–183, 2005. doi:10.1007/S00037-005-0195-9.
  • [18] Dániel Marx and Igor Razgon. Fixed-parameter tractability of multicut parameterized by the size of the cutset. In Proceedings of the forty-third annual ACM symposium on Theory of computing, pages 469–478, 2011. doi:10.1145/1993636.1993699.
  • [19] Dániel Marx and Ildikó Schlotter. Stable assignment with couples: Parameterized complexity and local search. Discrete Optimization, 8(1):25–40, 2011. Parameterized Complexity of Discrete Optimization. doi:10.1016/j.disopt.2010.07.004.
  • [20] Moni Naor, Leonard J Schulman, and Aravind Srinivasan. Splitters and near-optimal derandomization. In Proceedings of IEEE 36th Annual Foundations of Computer Science, pages 182–191. IEEE, 1995. doi:10.1109/SFCS.1995.492475.
  • [21] NS Narayanaswamy, Venkatesh Raman, MS Ramanujan, and Saket Saurabh. Lp can be a cure for parameterized problems. In 29th International Symposium on Theoretical Aspects of Computer Science (STACS 2012). Schloss-Dagstuhl-Leibniz Zentrum für Informatik, 2012. doi:10.4230/LIPIcs.STACS.2012.338.
  • [22] Venkatesh Raman, MS Ramanujan, and Saket Saurabh. Paths, flowers and vertex cover. In Algorithms–ESA 2011: 19th Annual European Symposium, Saarbrücken, Germany, September 5-9, 2011. Proceedings 19, pages 382–393. Springer, 2011.
  • [23] Igor Razgon and Barry O’Sullivan. Almost 2-sat is fixed-parameter tractable. In Automata, Languages and Programming: 35th International Colloquium, ICALP 2008, Reykjavik, Iceland, July 7-11, 2008, Proceedings, Part I 35, pages 551–562. Springer, 2008.
  • [24] Neil Robertson and Paul D Seymour. Graph minors. xiii. the disjoint paths problem. Journal of combinatorial theory, Series B, 63(1):65–110, 1995. doi:10.1006/JCTB.1995.1006.
  • [25] Stefan Szeider. The parameterized complexity of k-flip local search for sat and max sat. Discrete Optimization, 8(1):139–145, 2011. doi:10.1016/J.DISOPT.2010.07.003.