Cliques, Independent Sets and Vertex Covers

Mohammed Islam Hadjoudj

Expert Operations Research Engineer

1. Cliques, independent sets and vertex covers

Three of the most studied questions in graph theory ask about sets of vertices, and each can be stated in one line.

• A clique is a set of vertices in which every two are adjacent. A clique on k vertices is a copy of the complete graph Kk inside the graph. The size of the largest clique is the clique number, written ω(G).
• An independent set, also called a stable set, is a set of vertices in which no two are adjacent. The size of the largest one is the independence number, α(G).
• A vertex cover is a set of vertices that touches every edge: each edge has at least one end in the set. The size of the smallest one is the vertex cover number, τ(G).

A clique and an independent set are opposites: one asks for all possible edges among the chosen vertices, the other for none. In a friendship network a clique is a group where everyone knows everyone, and an independent set is a group of mutual strangers. The word "clique" entered the subject from sociology, where Luce and Perry used it in 1949 for exactly such groups. The guide to vertices and edges covers the vocabulary these definitions rest on.

Each question comes with a trap in the wording. A set is maximal when nothing can be added to it, or for a cover, nothing removed, without breaking the property. It is maximum when no larger set with the property exists, or for a cover, no smaller one. Every maximum set is maximal, but not the other way round, and the difference between the two is where most algorithms go wrong.

2. One graph, three answers, one identity

The running example has 8 vertices and 12 edges. Vertices A, B, C and D are all joined to each other, D, E and F form a triangle, and a 5-cycle C, D, F, G, H runs round the bottom:

E = {AB, AC, AD, BC, BD, CD, CH, DE, DF, EF, FG, GH}      8 vertices, 12 edges

deg:   A 3   B 3   C 4   D 5   E 2   F 3   G 2   H 2

The largest clique is {A, B, C, D}, so ω = 4, and it is the only clique of that size. The largest independent sets have 3 vertices, for example {A, E, G}, so α = 3; there are seven of them. The smallest vertex covers have 5 vertices, for example {B, C, D, F, H}, so τ = 5, and again there are seven. The two sevens are not a coincidence.

Two short arguments tie the three numbers together. First, the complement of a graph has an edge exactly where the graph has none, so a clique in G is an independent set in the complement and the other way round: ω(G) equals α of the complement. Second, a set S is independent exactly when the remaining vertices form a vertex cover. If some edge missed the remaining vertices, both of its ends would lie in S, so S would not be independent, and the argument runs the same way backwards. Taking the largest S gives the smallest cover:

α(G) + τ(G) = n, for every graph with n vertices.

This identity is usually credited to Gallai, who published it in 1959. In the example, 3 + 5 = 8, and the seven largest independent sets are exactly the complements of the seven smallest covers. The practical consequence is that the three problems are one problem in three costumes: an algorithm for any of them, run on the graph or on its complement, solves the other two exactly.

3. Maximal is not maximum

The triangle {D, E, F} is a clique, and no vertex can be added to it, because no other vertex is adjacent to all three of D, E and F. It is a maximal clique of size 3, while the maximum is 4. The edges CH, FG and GH are maximal cliques too, of size 2: none of them lies in a triangle. Altogether the example has five maximal cliques, and only one of them is maximum.

Independent sets fall into the same trap more easily. The natural greedy method walks through the vertices and takes each one whose neighbours have not been taken yet. The result is always maximal, but its size depends on the order. Start with D, the vertex of highest degree, and D blocks five vertices at once; after G is taken, every remaining vertex is adjacent to one of the two, and the method stops at {D, G}, one short of the optimum. The example has ten maximal independent sets, three of size 2 and seven of size 3. Starting with low-degree vertices, which block few others, is a better habit, but no greedy order is right for every graph.

The lesson carries over to software. A routine that "finds a clique" or "finds an independent set" usually returns a maximal one, quickly. Finding a maximum one is a different and much harder task, and the rest of this article is about doing it, approximating it, and bounding it.

4. Listing every maximal clique: Bron–Kerbosch

The classic way to find all maximal cliques is the algorithm Bron and Kerbosch published in 1973. It grows a clique R one vertex at a time and keeps two more sets: P, the vertices that could still be added because they are adjacent to everything in R, and X, the vertices that could be added but were already explored, so any clique using them has been reported. When P and X are both empty, R cannot grow and nothing was skipped, so R is a maximal clique.

def graph(edges):
    adj = {}
    for u, v in edges:
        adj.setdefault(u, set()).add(v)
        adj.setdefault(v, set()).add(u)
    return adj

def bron_kerbosch(R, P, X, adj, out):
    """Report every maximal clique that contains R, uses only P and avoids X."""
    if not P and not X:
        out.append(sorted(R))                 # nothing can be added: R is maximal
        return
    pivot = max(P | X, key=lambda u: len(P & adj[u]))
    for v in sorted(P - adj[pivot]):          # neighbours of the pivot are tried later
        bron_kerbosch(R | {v}, P & adj[v], X & adj[v], adj, out)
        P.remove(v)
        X.add(v)                              # every clique with v has now been reported

def maximal_cliques(adj):
    out = []
    bron_kerbosch(set(), set(adj), set(), adj, out)
    return sorted(out, key=lambda c: (-len(c), c))

def complement(adj):
    return {v: set(adj) - adj[v] - {v} for v in adj}

G = graph(['AB', 'AC', 'AD', 'BC', 'BD', 'CD', 'CH', 'DE', 'DF', 'EF', 'FG', 'GH'])

print(maximal_cliques(G))
# [['A', 'B', 'C', 'D'], ['D', 'E', 'F'], ['C', 'H'], ['F', 'G'], ['G', 'H']]
print(maximal_cliques(complement(G)))   # the maximal independent sets of G
# [['A', 'E', 'G'], ['A', 'E', 'H'], ['A', 'F', 'H'], ['B', 'E', 'G'], ['B', 'E', 'H'], ['B', 'F', 'H'], ['C', 'E', 'G'], ['C', 'F'], ['D', 'G'], ['D', 'H']]

The pivot is what makes it fast. Any maximal clique must contain the pivot or a vertex that is not adjacent to it, so the loop only needs to branch on the non-neighbours of the pivot; choosing as pivot the vertex of P or X with the most neighbours in P skips the most work. Tomita, Tanaka and Takahashi proved in 2006 that with this rule the running time is O(3n/3), and that bound cannot be improved, because Moon and Moser showed in 1965 that a graph on n vertices can have 3n/3 maximal cliques when n is a multiple of 3. The extreme graph is the complement of n/3 disjoint triangles: on 9 vertices it has 27 maximal cliques, and on 30 vertices it has 59,049.

The first line of output lists the five maximal cliques from section 3, largest first. The second line runs the same function on the complement and so lists the ten maximal independent sets. The function was checked against the clique finder in networkx, which uses the same algorithm, on 3,000 random graphs with up to 10 vertices.

5. Finding the largest independent set exactly

Listing every maximal set is often more than needed, and the answer can be found with a direct search instead. Two rules are enough for a correct method. A vertex of degree 0 can always be taken. A vertex v of degree 1 can also always be taken: if a largest independent set contains its single neighbour u, swapping u for v keeps it independent and the same size. When neither rule applies, pick a vertex and try both possibilities: take it and delete its neighbours, or leave it out.

def graph(edges):
    adj = {}
    for u, v in edges:
        adj.setdefault(u, set()).add(v)
        adj.setdefault(v, set()).add(u)
    return adj

def remove(adj, gone):
    return {u: adj[u] - gone for u in adj if u not in gone}

def greedy_independent_set(adj, order):
    """Take each vertex in turn unless a neighbour is already taken. Always maximal."""
    chosen = set()
    for v in order:
        if not adj[v] & chosen:
            chosen.add(v)
    return chosen

def max_independent_set(adj):
    """Exact: a vertex of degree 0 or 1 is always safe to take; otherwise branch."""
    if not adj:
        return set()
    v = min(adj, key=lambda u: len(adj[u]))
    if len(adj[v]) <= 1:
        return {v} | max_independent_set(remove(adj, {v} | adj[v]))
    v = max(adj, key=lambda u: len(adj[u]))
    take = {v} | max_independent_set(remove(adj, {v} | adj[v]))   # v in, neighbours out
    skip = max_independent_set(remove(adj, {v}))                  # v out
    return take if len(take) >= len(skip) else skip

G = graph(['AB', 'AC', 'AD', 'BC', 'BD', 'CD', 'CH', 'DE', 'DF', 'EF', 'FG', 'GH'])

print(sorted(greedy_independent_set(G, 'DGABCEFH')))   # start with the busiest vertex
# ['D', 'G']
best = max_independent_set(G)
print(sorted(best), sorted(set(G) - best))             # largest independent set, smallest cover
# ['A', 'E', 'G'] ['B', 'C', 'D', 'F', 'H']

The first line repeats the greedy dead end from section 3. The second line gives a largest independent set, {A, E, G}, and by the identity in section 2, the vertices it leaves out form a smallest vertex cover, {B, C, D, F, H}. The function was checked against networkx on the same 3,000 random graphs, and every set it returned was independent and of the right size.

Branching on a vertex of maximum degree is deliberate: taking it deletes the most vertices, so that branch shrinks the graph fastest. The degree rules also mean that the search never branches at all on a forest, since every forest has a vertex of degree 0 or 1, and deleting vertices keeps it a forest. On general graphs the search is still exponential, but far smaller than the 2n subsets: Tarjan and Trojanowski refined rules of this kind in 1977 to an O(2n/3) algorithm, and later work has lowered the base further.

6. Vertex cover: a 2-approximation and a fast exact test

Vertex cover has two properties that its partners lack, and both come from looking at edges. The first is a simple approximation. Walk through the edges, and whenever an edge has neither end in the cover yet, add both ends. The edges chosen this way share no vertex, so they form a matching, and no further edge could join them, so it is a maximal matching. Any cover at all must contain at least one end of each matching edge, and those ends are all different, so τ is at least the number of matching edges. The method takes exactly two vertices per matching edge, so its cover is never more than twice the optimum. This argument is usually credited to Gavril and to Yannakakis, and Garey and Johnson's 1979 book made it widely known.

def matching_cover(edges):
    """2-approximation: take both ends of every edge that is still uncovered."""
    cover = set()
    for u, v in edges:
        if u not in cover and v not in cover:
            cover |= {u, v}                   # these edges form a maximal matching
    return cover

def cover_of_size(edges, k):
    """A vertex cover with at most k vertices, or None. At most 2^k branches."""
    if not edges:
        return set()
    if k == 0:
        return None
    u, v = edges[0]                           # one of u and v must be in any cover
    for w in (u, v):
        rest = [e for e in edges if w not in e]
        found = cover_of_size(rest, k - 1)
        if found is not None:
            return found | {w}
    return None

E = ['AB', 'AC', 'AD', 'BC', 'BD', 'CD', 'CH', 'DE', 'DF', 'EF', 'FG', 'GH']

print(sorted(matching_cover(E)))
# ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
print(cover_of_size(E, 4))
# None
print(sorted(cover_of_size(E, 5)))
# ['A', 'B', 'D', 'F', 'H']

On the example the matching is AB, CD, EF and GH, and the method takes all eight vertices. That is a poor cover, but the matching also proves that no cover has fewer than four vertices, so the method knows its own answer is within a factor of 2 without knowing the optimum. A tempting alternative, repeatedly taking the vertex of highest degree, has no such guarantee: on carefully built graphs its cover can be worse than the optimum by a factor that grows with the size of the graph.

The second property is that small covers are easy to find exactly. Any edge uv must have u or v in the cover, so the function cover_of_size tries both and continues with a budget of k − 1. The search tree has depth at most k and at most 2k leaves, whatever the number of vertices. On the example it reports that no cover of 4 vertices exists and finds one of 5. With k = 20, the tree has at most about a million leaves, however large the graph is: the size of the search depends on the size of the cover, not on the number of vertices. Problems with this behaviour are called fixed-parameter tractable.

A preprocessing rule from Buss and Goldsmith's 1993 paper shrinks the input first. A vertex with more than k neighbours must be in every cover of size k, because otherwise all of its neighbours would be needed. After taking such vertices, every remaining vertex covers at most k edges, so if more than k2 edges remain, the answer is no. The best known exact algorithm, by Chen, Kanj and Xia in 2010, runs in O(1.2738k + kn) time.

7. How hard are these problems?

Deciding whether a graph has a clique of size k is NP-complete, and so is deciding whether it has a vertex cover of size k. Both were on Karp's 1972 list of 21 NP-complete problems, and independent set follows from either through the identities in section 2. No polynomial-time algorithm is known for any of them, and finding one would prove P = NP.

The identities preserve exact answers but not approximate ones, and here the three problems split apart. Vertex cover can be approximated within a factor of 2, as section 6 showed. Clique and independent set essentially cannot be approximated at all: Håstad proved in 1999 that, for every ε > 0, no polynomial-time algorithm approximates the largest clique within a factor of n1−ε unless NP = ZPP, and Zuckerman showed in 2007 that the same holds assuming only P ≠ NP. A small calculation shows why the identity does not transfer the guarantee: in a graph with 1,000 vertices and τ = 500, a cover of 1,000 vertices is within a factor of 2, yet the independent set it leaves behind is empty.

Even the factor of 2 for vertex cover may be the end of the road. Dinur and Safra proved in 2005 that approximating it within a factor of 1.36 is NP-hard, and Khot and Regev proved in 2008 that a factor of 2 − ε is hard if the Unique Games Conjecture is true. The parameterized picture differs too. Vertex cover is fixed-parameter tractable, as section 6 showed, while finding a clique of size k is complete for the class W[1], as Downey and Fellows proved in 1995, which is strong evidence that no algorithm with running time f(k) · nc exists for it.

8. Bounds you can check by hand

Because the exact numbers are hard to compute, simple bounds are valuable, and several connect these problems to colouring and degrees.

• Cliques force colours. The vertices of a clique are pairwise adjacent, so each needs its own colour: χ(G) ≥ ω(G), where χ is the chromatic number from the guide to graph colouring. In the example the clique {A, B, C, D} forces 4 colours, and 4 are enough.
• Colours give independent sets. Each colour class of a proper colouring is an independent set, so the n vertices split into χ independent sets and the largest has at least n / χ vertices: α(G) ≥ n / χ(G). In the example that gives α ≥ 2.
• Low degrees give independent sets. The Caro–Wei bound, found independently by Caro in 1979 and Wei in 1981, states α(G) ≥ ∑ 1 / (d(v) + 1). Put the vertices in a random order and keep each vertex that comes before all of its neighbours: the kept set is independent, and each vertex is kept with probability 1 / (d(v) + 1). For the example the sum is 127/60 ≈ 2.12, and since α is a whole number, α ≥ 3, which is exact here. The guide to vertex degree explains why such degree sums are so useful.
• Many edges force cliques. Turán's theorem of 1941 says that a graph on n vertices with no clique of size r + 1 has at most (1 − 1/r) n2 / 2 edges, and the maximum is reached by splitting the vertices into r nearly equal groups and joining every pair from different groups. For r = 2 this is Mantel's theorem of 1907: a triangle-free graph has at most n2 / 4 edges. With 8 vertices, any graph with more than 16 edges contains a triangle and any graph with more than 21 edges contains K4.

9. Ramsey theory: order is unavoidable

Turán's theorem says that dense graphs contain large cliques. Ramsey theory says something stronger: every large graph contains a large clique or a large independent set, whatever its density. The Ramsey number R(s, t) is the smallest n such that every graph on n vertices has a clique of size s or an independent set of size t. Ramsey proved in 1930 that these numbers exist.

The smallest case is the party problem: among any six people there are three mutual friends or three mutual strangers, so R(3, 3) = 6. The proof fits in a few lines. Pick any person v. Of the other five, at least three are friends of v or at least three are strangers to v; say three friends x, y and z. If any two of them are friends, they form a trio of friends with v. If none are, x, y and z are three mutual strangers. Five people are not enough: arrange them in a pentagon, make neighbours friends and everyone else strangers, and no trio of either kind appears. A brute-force check of all 32,768 ways to mark 15 pairs of six people as friends or strangers confirms the result.

Beyond the smallest cases, Ramsey numbers are notoriously hard. Greenwood and Gleason found R(4, 4) = 18 in 1955. For R(5, 5), Exoo showed in 1989 that it is at least 43, and Angeltveit and McKay proved in 2024 that it is at most 46, after decades of computation; the exact value is still unknown. For general k, Erdős and Szekeres proved in 1935 that R(k, k) is less than 4k, and Erdős proved in 1947 that it is more than 2k/2 by showing that a random graph usually has neither a large clique nor a large independent set, one of the first uses of the probabilistic method. Later work trimmed the upper bound, but the base 4 stood until Campos, Griffiths, Morris and Sahasrabudhe lowered it to (4 − ε)k in a paper first posted in 2023.

10. Special graphs where the problems become easy

NP-hardness is a statement about all graphs. Many graph classes that appear in practice have structure that makes these problems tractable.

• Bipartite graphs. Kőnig's theorem of 1931 says that in a bipartite graph the smallest vertex cover has exactly as many vertices as the largest matching, and largest matchings can be found in polynomial time with the flow methods in the guide to maximum flow. The largest independent set then follows from α = n − τ. The guide to bipartite graphs works through an example.
• Trees and forests. The degree rules in section 5 solve any forest without branching, which gives a linear-time algorithm with the right data structures.
• Chordal graphs. Gavril showed in 1972 that the largest clique, the largest independent set and an optimal colouring of a chordal graph can all be found in polynomial time from a perfect elimination ordering, as the guide to chordal graphs describes.
• Perfect graphs. In a perfect graph the chromatic number equals the clique number in every induced subgraph. Grötschel, Lovász and Schrijver showed in 1981 that the clique number and the independence number of a perfect graph can be computed in polynomial time, using the ellipsoid method.
• Planar graphs. A planar graph contains no K5, so its largest clique has at most 4 vertices and can be found by checking every set of at most 4 vertices. Independent set and vertex cover stay NP-complete, however: Garey, Johnson and Stockmeyer showed this for planar graphs in 1976, and Garey and Johnson extended it in 1977 to planar graphs with maximum degree 3.

11. Where cliques, independent sets and covers are used

• Scheduling and conflicts. In a conflict graph, where tasks that cannot share a time slot are joined, an independent set is a group of tasks that can run together, and a clique is a group that needs as many slots as it has members. The clique number is therefore a lower bound on the number of slots.
• Social and biological networks. Cliques model tightly knit groups of people and protein complexes. Real data is noisy, so analysts often use relaxed versions such as the k-cores from the guide to vertex degree, and Bron–Kerbosch remains the standard tool for listing exact cliques in sparse networks.
• Monitoring. Placing sensors at the fewest nodes so that every link of a network is watched is a vertex cover problem, as is choosing the fewest guards at street corners so that every street is in view of one.
• Coding theory. A set of code words with minimum distance d is an independent set in the graph that joins every two words at distance less than d, so the best codes of a given length are largest independent sets.
• Matching structures. Barrow and Burstall observed in 1976 that the largest common substructure of two graphs, used for comparing molecules, corresponds to the largest clique in a product graph built from the pair. The guide to graph isomorphism covers the related problem of deciding whether two graphs are the same.

12. Common mistakes

13. Glossary

15. References

The definitions, theorems and attributions above come from these sources, listed in chronological order.

1. Mantel, W. (1907). "Problem 28 (Solution by H. Gouwentak, W. Mantel, J. Teixeira de Mattes, F. Schuh and W. A. Wythoff)." Wiskundige Opgaven 10, 60 to 61.
2. Ramsey, F. P. (1930). "On a Problem of Formal Logic." Proceedings of the London Mathematical Society s2-30, 264 to 286.
3. Kőnig, D. (1931). "Gráfok és mátrixok." Matematikai és Fizikai Lapok 38, 116 to 119.
4. Erdős, P. and Szekeres, G. (1935). "A Combinatorial Problem in Geometry." Compositio Mathematica 2, 463 to 470.
5. Turán, P. (1941). "Egy gráfelméleti szélsőértékfeladatról." Matematikai és Fizikai Lapok 48, 436 to 452.
6. Erdős, P. (1947). "Some Remarks on the Theory of Graphs." Bulletin of the American Mathematical Society 53, 292 to 294.
7. Luce, R. D. and Perry, A. D. (1949). "A Method of Matrix Analysis of Group Structure." Psychometrika 14(2), 95 to 116.
8. Greenwood, R. E. and Gleason, A. M. (1955). "Combinatorial Relations and Chromatic Graphs." Canadian Journal of Mathematics 7, 1 to 7.
9. Gallai, T. (1959). "Über extreme Punkt- und Kantenmengen." Annales Universitatis Scientiarum Budapestinensis de Rolando Eötvös Nominatae, Sectio Mathematica 2, 133 to 138.
10. Moon, J. W. and Moser, L. (1965). "On Cliques in Graphs." Israel Journal of Mathematics 3, 23 to 28.
11. Gavril, F. (1972). "Algorithms for Minimum Coloring, Maximum Clique, Minimum Covering by Cliques, and Maximum Independent Set of a Chordal Graph." SIAM Journal on Computing 1(2), 180 to 187.
12. Karp, R. M. (1972). "Reducibility Among Combinatorial Problems." In Complexity of Computer Computations, edited by R. E. Miller and J. W. Thatcher, 85 to 103. New York: Plenum.
13. Bron, C. and Kerbosch, J. (1973). "Algorithm 457: Finding All Cliques of an Undirected Graph." Communications of the ACM 16(9), 575 to 577.
14. Barrow, H. G. and Burstall, R. M. (1976). "Subgraph Isomorphism, Matching Relational Structures and Maximal Cliques." Information Processing Letters 4(4), 83 to 84.
15. Garey, M. R., Johnson, D. S. and Stockmeyer, L. (1976). "Some Simplified NP-Complete Graph Problems." Theoretical Computer Science 1(3), 237 to 267.
16. Garey, M. R. and Johnson, D. S. (1977). "The Rectilinear Steiner Tree Problem is NP-Complete." SIAM Journal on Applied Mathematics 32(4), 826 to 834. Vertex cover on planar graphs of maximum degree 3.
17. Tarjan, R. E. and Trojanowski, A. E. (1977). "Finding a Maximum Independent Set." SIAM Journal on Computing 6(3), 537 to 546.
18. Caro, Y. (1979). "New Results on the Independence Number." Technical report, Tel Aviv University.
19. Garey, M. R. and Johnson, D. S. (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. San Francisco: W. H. Freeman. The 2-approximation for vertex cover.
20. Wei, V. K. (1981). "A Lower Bound on the Stability Number of a Simple Graph." Bell Laboratories Technical Memorandum 81-11217-9.
21. Grötschel, M., Lovász, L. and Schrijver, A. (1981). "The Ellipsoid Method and Its Consequences in Combinatorial Optimization." Combinatorica 1(2), 169 to 197.
22. Exoo, G. (1989). "A Lower Bound for R(5, 5)." Journal of Graph Theory 13(1), 97 to 98.
23. Buss, J. F. and Goldsmith, J. (1993). "Nondeterminism within P." SIAM Journal on Computing 22(3), 560 to 572.
24. Downey, R. G. and Fellows, M. R. (1995). "Fixed-Parameter Tractability and Completeness II: On Completeness for W[1]." Theoretical Computer Science 141, 109 to 131.
25. Håstad, J. (1999). "Clique is Hard to Approximate within n^1−ε." Acta Mathematica 182(1), 105 to 142.
26. Dinur, I. and Safra, S. (2005). "On the Hardness of Approximating Minimum Vertex Cover." Annals of Mathematics 162(1), 439 to 485.
27. Tomita, E., Tanaka, A. and Takahashi, H. (2006). "The Worst-Case Time Complexity for Generating All Maximal Cliques and Computational Experiments." Theoretical Computer Science 363(1), 28 to 42.
28. Zuckerman, D. (2007). "Linear Degree Extractors and the Inapproximability of Max Clique and Chromatic Number." Theory of Computing 3, 103 to 128.
29. Khot, S. and Regev, O. (2008). "Vertex Cover Might Be Hard to Approximate to within 2 − ε." Journal of Computer and System Sciences 74(3), 335 to 349.
30. Chen, J., Kanj, I. A. and Xia, G. (2010). "Improved Upper Bounds for Vertex Cover." Theoretical Computer Science 411(40–42), 3736 to 3756.
31. Diestel, R. (2017). Graph Theory, 5th edition. Graduate Texts in Mathematics 173. Berlin: Springer.
32. Angeltveit, V. and McKay, B. D. (2024). "R(5, 5) ≤ 46." arXiv:2409.15709.
33. Campos, M., Griffiths, S., Morris, R. and Sahasrabudhe, J. (2026). "An Exponential Improvement for Diagonal Ramsey." Annals of Mathematics 203(3), 869 to 932. First posted in 2023 as arXiv:2303.09521.