Maximum Matchings in Geometric Intersection Graphs

Let G be an intersection graph of n geometric objects in the plane. We show that a maximum matching in G can be found in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O\hspace{0.33325pt}(\rho ^{3\omega /2}n^{\omega /2})$$\end{document}O(ρ3ω/2nω/2) time with high probability, where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\rho $$\end{document}ρ is the density of the geometric objects and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\omega >2$$\end{document}ω>2 is a constant such that \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$n\times n$$\end{document}n×n matrices can be multiplied in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(n^\omega )$$\end{document}O(nω) time. The same result holds for any subgraph of G, as long as a geometric representation is at hand. For this, we combine algebraic methods, namely computing the rank of a matrix via Gaussian elimination, with the fact that geometric intersection graphs have small separators. We also show that in many interesting cases, the maximum matching problem in a general geometric intersection graph can be reduced to the case of bounded density. In particular, a maximum matching in the intersection graph of any family of translates of a convex object in the plane can be found in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(n^{\omega /2})$$\end{document}O(nω/2) time with high probability, and a maximum matching in the intersection graph of a family of planar disks with radii in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$[1, \Psi ]$$\end{document}[1,Ψ] can be found in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O\hspace{0.33325pt}(\Psi ^6\log ^{11}\hspace{-0.55542pt}n + \Psi ^{12 \omega } n^{\omega /2})$$\end{document}O(Ψ6log11n+Ψ12ωnω/2) time with high probability.


Introduction
Let be a family of (connected and compact) objects in2 .The intersection graph G of is the undirected graph with vertex set and edge set If the objects in are partitioned into two sets, one can also define the bipartite intersection graph, a subgraph of G , in the obvious way.Consider the particular case when is a set of disks.Then, we call G a disk graph, and if all disks in have the same radius, a unit-disk graph.Unit disk graphs are often used to model ad-hoc wireless communication networks and sensor networks [GG11,ZG04,HS95].Disks of varying sizes and other shapes become relevant when different sensors cover different areas.Moreover, general disk graphs serve as a tool to approach other problems, like the barrier resilience problem [KLA07].
We consider a classic optimization problem, maximum matching, in the setting of geometric intersection graphs, and introduce two new techniques, each interesting in its own.First, we provide an efficient algorithm to compute a maximum matching in any subgraph of the intersection graph of geometric objects of low density.Second, we provide a sparsification technique to reduce the maximum matching problem in a geometric intersection graph to the case of low density.The sparsification works for convex shapes of similar sizes for which certain range searching operations can be done efficiently.
In this paper, we use ω to denote a constant such that ω > 2 and any two n × n matrices can be multiplied in time O(n ω ).1 Maximum matching in intersection graphs of geometric objects of low density.We first introduce some geometric concepts.The diameter of a set X ⊂ 2 , denoted by diam(X ), is the supremum of the distances between any two points of X .The density ρ( ) of a family of objects is One can also define the density by considering for X only disks.Since an object of diameter d can be covered by O(1) disks of diameter d, this changes the resulting parameter by only a constant.(See, for example, the book by de Berg et al. [dBCvKO08, Section 12.5] for such a definition.)The depth (ply) of is the largest number of objects that cover a single point: For disk graphs and square graphs, the depth and the density are linearly related; see for example Har-Peled and Quanrud [HQ17, Lemma 2.7].More generally, bounded depth and bounded density are equivalent whenever we consider homothets of a constant number of shapes.Density and depth are usually considered in the context of realistic input models; see de Berg et al. [dBvdSVK02] for a general discussion.Let ρ be the family of subgraphs of intersection graphs of geometric objects in the plane with density at most ρ. 2 Our goal is to compute a maximum matching in graphs of ρ , assuming the availability of a geometric representation of the graph and a few basic geometric primitives on the geometric objects.For this, we consider the density ρ as an additional parameter.Naturally, the case ρ = O(1) of bounded density is of particular interest.
In a general graph G = (V, E) with n vertices and m edges, the best running time for computing a maximum matching in G depends on the ratio m/n.The classic algorithm of Micali and Vazirani [MV80,Vaz12] is based on augmenting paths, and it finds a maximum matching in O( nm) time.Mucha and Sankowski [MS04] use algebraic tools to achieve running time O(n ω ).As we shall see, for G ∈ ρ , we have m = O(ρn), and this bound is asymptotically tight.Thus, for G ∈ ρ , the running times of these two algorithms become O(ρn3/2 ) and O(n ω ), respectively.
In general bipartite graphs, a recent algorithm by M ądry [M ąd13] achieves running time roughly O(m 10/7 ). 3 Efrat, Itai, and Katz [EIK01] show how to compute the maximum matching in bipartite unit disk graphs in O(n 3/2 log n) time.Having bounded density does not help in this algorithm; it has O( n) rounds, each of which needs Ω(n) time.The same approach can be used for other geometric shapes if a certain semi-dynamic data structure is available.In particular, using the data structure of Kaplan et al. [KMR + 20] for additively-weighted nearest neighbors, finding a maximum matching in a bipartite intersection graph of disks takes O(n 3/2 polylog n) time.We are not aware of any similar results for non-bipartite geometric intersection graphs.
We show that a maximum matching in a graph of ρ with n vertices can be computed in O(ρ 3ω/2 n ω/2 ) = O(ρ 3.56 n 1.19 ) time.The algorithm is randomized and succeeds with high probability.It uses the algebraic approach by Mucha and Sankowski [MS06] for planar graphs with an extension by Yuster and Zwick [YZ07] for H-minor-free graphs.As noted by Alon and Yuster [AY13], this approach works for hereditary4 graph families with bounded average degree and small separators.We note that the algorithm can be used for graphs of ρ , because we have average degree O(ρ) and balanced separators of size O( ρn) [HQ17,SW98].However, finding the actual dependency on ρ is difficult because it plays a role in the average degree, in the size of the separators, and because the algorithm has a complex structure with several subroutines that must be distilled.
There are several noteworthy features in our approach.For one, we solve a geometric problem using linear algebra, namely Gaussian elimination.The use of geometry is limited to finding separators, bounding the degree, and constructing the graph explicitly.Note that the role of subgraphs in the definition of ρ is a key feature in our algorithm.On the one hand, we need a hereditary family of graphs, as needed to apply the algorithm.On the other hand, it brings more generality; for example, it includes the case of bipartite graphs defined by colored geometric objects.
Compared to the work of Efrat, Itai, and Katz [EIK01], our algorithm is for arbitrary subgraphs of geometric intersection graphs, not only bipartite ones; it works for any objects, as it does not use advanced data structures that may depend on the shapes.On the other hand, it needs the assumption of low density.Compared to previous algorithms for arbitrary graphs and ignoring polylogarithmic factors, our algorithm is faster when ρ = o(n (20−7ω)/(21ω−20) ).Using the current bound ω < 2.373, this means that our new algorithm is faster for ρ = O(n 0.113 ).
Our matching algorithm also applies for intersection graphs of objects in 3-dimensional space.However, in this case there is no algorithmic gain with the current bounds on ω: one gets a running time of O(n 2ω/3 ) when ρ = O(1), which is worse than constructing the graph explicitly and using the algorithm of Micali and Vazirani.
Sparsification -Reducing to bounded depth.Consider a family of convex geometric objects in the plane where each object contains a square of side length 1 and is contained in a square of side length Ψ ≥ 1.Our objective is to compute a maximum matching in the intersection graph G . 5ur goal is to transform this problem to finding a maximum matching in the intersection graph of a subfamily ′ ⊂ with bounded depth.We describe a method that is fairly general and works under comparatively mild assumptions and also in higher dimensions.However, for an efficient implementation, we require that the objects under consideration support certain range searching operations efficiently.We discuss how this can be done for disks of arbitrary sizes, translates of a fixed convex shape in the plane, axis-parallel objects in constant dimension, and (unit) balls in constant dimension.In all these cases, we obtain a subquadratic time algorithm for finding a maximum matching, assuming that Ψ is small.We mostly focus on the planar case, mentioning higher dimensions as appropriate.
As particular results to highlight, we show that a maximum matching in the intersection graph of any family of translates of a convex object in the plane can be found in O(n ω/2 ) time with high probability, and a maximum matching in the intersection graph of a family of planar disks with radii in [1, Ψ] can be found in O(Ψ 6 log 11 n + Ψ 12ω n ω/2 ) time with high probability.See Table 1 for a summary of the results in this context.
Organization.We begin with some general definitions and basic properties of geometric intersection graphs (Section 2).Then, in the first part of the paper, we present the new algorithm for finding a maximum matching in geometric intersection graphs of low density (Section 3).In the second part, we present our sparsification method.This is done in two steps.First, we describe a generic algorithm that works for general families of shapes that have roughly the same size, assuming that certain geometric operations can be performed quickly.(Section 4).Second, we explain how to implement these operations for several specific shape families, e.g., translates of a given convex objects and disks of bounded radius ratio (Section 5).The two parts are basically independent, where the second part uses the result from the first part as a black box, to state the desired running times.

Basics of (geometric intersection) graphs
Geometric objects and Computational Model.Several of our algorithms work under fairly weak assumptions on the geometric input: we assume that the objects in have constant description complexity.This means that the boundary of each object is a continuous closed curve whose graph is a semialgebraic set, defined by a constant number of polynomial equalities and inequalities of constant maximum degree.For later algorithms we restrict attention to some particular geometric objects, like disks or squares.
To operate on , we require that our computational model supports primitive operations that involve a constant number of objects of in constant time, e.g., finding the intersection points of two boundary curves; finding the intersection points between a boundary curve and a disk or a vertical line; testing whether a point lies inside, outside, or on the boundary of an object; decomposing a boundary curve into x-monotone pieces, etc. See, e.g., [KMR + 20] for a further discussion and justification of these assumptions.
We emphasize that in addition to the primitives on the input objects, we do not require any special constant-time operations.In particular, even though our algorithms use algebraic techniques such as fast matrix multiplication or Gaussian elimination, we rely only on algebraic operations over p , where p = Θ(n 4 ) is a prime.Thus, we work only with numbers of O(log n)-bits, and assuming a standard unit-cost model for such word-sizes, as in, e.g., the word-RAM model of computation, we simply need to bound the number of arithmetic operations in our algorithms.

Geometric intersection graphs.
form an edge in E(G ), then either (i) their boundaries intersect; or (ii) one is contained inside the other.To find the edges of type (i), we perform a plane sweep [BO79,dBCvKO08]. 6For this, we split the boundary of each object into a constant number of x-monotone pieces.We sweep a vertical line ℓ across the plane, and we maintain the intersection of ℓ with the pieces of the boundary curves.The events are the start and end points of the pieces of the boundary curves, as well as their pairwise intersections.There are O(n + k) events.When we detect a boundary-boundary intersection, we add the corresponding edge to the output.An edge can be added O(1) times, so we sort the output to remove duplicates.Thus, it takes O((n + k) log n) time to find all edges of type (i).
To find the edges of type (ii), we perform a second plane sweep to compute the trapezoidal decomposition of the planar arrangement defined by the objects in [dBCvKO08].The trapezoidal decomposition is obtained by shooting upward and downward vertical rays from each x-extremal point on a boundary curve and from each intersection between two boundary curves.The rays end once they encounter a boundary curve, or they go into infinity.This results in a subdivision of the plane into O(n + k) (possibly unbounded) pseudo-trapezoids.The subdivision can be computed in O((n + k) log n) time.We construct the dual graph of the trapezoidal decomposition, in which the vertices are the pseudo-trapezoids, and two pseudo-trapezoids are adjacent if and only if their boundaries intersect in more than one point.We perform a DFS in the resulting dual graph, keeping track of the objects in that contain the current pseudo-trapezoid.Whenever we enter an object U ∈ for the first time, we generate all edges between the objects that contain the current pseudotrapezoid and U.This takes O(n + k) time.We generate all edges of type (ii), and we possibly rediscover some edges of type (i).Thus, we sort the output once more to remove duplicates.The total running time is We remark that using more sophisticated methods, such as randomized incremental construction [Mul94], it may be possible to improve the running time to O(ρn + n log n).However, this will not help us, because later parts of the algorithm will dominate the running time.

Separators in geometric intersection graphs. The classic planar separator theorem by Lipton and
Tarjan [LT80,DV97] shows that any planar graph can be decomposed in a balanced way by removing a small number of vertices.Even though geometric intersection graphs can be far from planar, similar results are also available for them.These results are usually parameterized by the depth of the arrangement or by the area of the separator and the components [AF04, EMT95, MTTV97].The following recent result provides a small separator for general intersection graphs of bounded density.
Theorem 2 (Lemma 2.21 in [HQ17]).Let be a set of n objects in 2 with density ρ.In O(n) expected time, we can find a circle such that intersects at most c ρn objects of , the exterior of contains at most αn elements of , and the interior of contains at most αn elements of .Here 0 < c and 0 < α < 1 are universal constants, independent of ρ and n.
The proof of Theorem 2 goes roughly as follows: Pick a point in each object of , compute the smallest circle ′ (or an approximation thereof) that contains, say, n/20 points, and then take a concentric scaled copy of ′ , with scale factor uniformly at random in [1, 2].With constant probability, the circle ′ has the desired property.This can be checked easily in linear time by determining which objects of are inside, outside, or intersected by .In expectation, a constant number of repetitions is needed to obtain the desired circle.
A family of graphs is hereditary if for every G ∈ , it holds that all subgraphs H of G are also in .By definition, our family ρ of subgraphs of geometric intersection graphs with density ρ is hereditary.A graph G is δ-sparse if every subgraph H of G has at most δ|V (H)| edges.Lemma 1 implies that all graphs in ρ are ρ-sparse.
Consider a graph G and a vertex v of G.A vertex split at v consists of adding a pendant 2-path v v ′ v ′′ , where v ′ and v ′′ are new vertices, and possibly replacing some edges uv incident to v by new edges uv ′′ ; see Figure 1 for a sequence of splits.We note that a vertex split may not replace any edges.In this case, we are just adding a pendant path of length 2.
Let G ′ be a graph obtained from G by a sequence of k vertex splits.Then, the size of a maximum matching in G ′ is the size of a maximum matching in G plus k.Furthermore, from a maximum matching in G ′ , we can easily obtain a maximum matching in G in O(|V (G)| + |E(G)| + k) time.We will use vertex splits to ensure that the resulting graphs have bounded degree and a vertex set of a certain cardinality.Note that if we perform a vertex split at v in a graph of ρ , in general we obtain a graph of ρ+2 because we can represent it by making two new copies of the object corresponding to v. Nevertheless, this increase in the density will not be problematic in our algorithm.

Separators and separator trees
and such that there is no edge with one endpoint in X and one endpoint in Y .We say that Z separates X and Y .At the cost of making the constant α larger, we can restrict our attention to graphs of a certain minimum size.
Theorem 2 gives a (c ρn, α ′ )-separation for every graph of ρ , for some constant α ′ < 1. (A separator in G is a separator in every subgraph of G that is obtained by omitting edges from G .) Furthermore, such a separation can be computed in expected linear time, if the objects defining the graph are available.
A recursive application of separations can be represented as a binary rooted tree.We will use so-called (weak) separator trees, where the separator does not go into the subproblems.In such a tree, we store the separator at the root and recurse on each side to obtain the subtrees.We want to have small separators and balanced partitions at each level of the recursion, and we finish the recursion when we get to problems of a certain size.This leads to the following definition.Let γ > 0, 0 < β < 1, and 0 < α < 1 be constants.We say that a graph G has a (γ, β, α)-separator tree if there is a rooted binary full tree T with the following properties: • (iii) For each node t ∈ T , let V t = s Z s , where s ranges over the descendants of t (including t).Note that if t is an internal node with children u and v, then V t is the disjoint union of Z t , V u , and V v .If t is a leaf, then V t = Z t .
• (iv) For each internal node t ∈ T with children u and v, ).We have chosen the size so that V t is a Yuster and Zwick [YZ07] provide an algorithm that computes a separator tree of some split graph for a given graph from an H-minor-free family.As Alon and Yuster [AY13, Lemma 2.13] point out, this algorithm actually works for any δ-sparse hereditary graph family, as long as δ is constant.Thus, the result applies to ρ .We revise the construction to make the dependency on ρ explicit.

Lemma 3. Given a graph G of ρ with n vertices, we can compute in O(ρn log n) expected time a vertex-split graph G
′ of G and a separator tree T ′ for G ′ with the following properties: Proof.We adapt the construction of Yuster and Zwick [YZ07, Lemma 2.1], with three main changes: First, Yuster and Zwick assume (•, α = 2/3)-separations, but this specific value of α is not needed.Second, we make "dummy additions" of vertices to obtain a more balanced separation, which we later use as a black box.(Otherwise, we would get a (•, •, O(1/ρ))-separator tree, and we would have to analyze the tree more carefully to obtain the same final result.)Third, we work out the constants in the analysis to understand the dependency on the density ρ.We proceed recursively.Consider an m-vertex graph G ∈ ρ that appears during the recursion.If m ≤ Cρ, where C is a sufficiently large constant, we make a sequence of vertex splits to reduce the maximum degree to three.This may increase the number of vertices.To ensure that this number is uniform, we add a (possibly empty) pendant path of even length until we get the maximum possible number of Θ(ρ 2 ) vertices.The resulting separator tree T ′ consists of a single node.Now suppose that m > Cρ.Using Theorem 2, we get a (c ρm, α)-separation (X , Y, Z) of G. Thus, |Z| ≤ c ρm. Yuster and Zwick [YZ07, Lemma 2.1] explain how to make vertex splits at the vertices of Z and how to redefine the separation so that the vertices of the separator have maximum degree three.See Figure 1 for how to split a vertex v ∈ Z.After making the vertex splits of Figure 1 in all vertices of Z, we get a split graph G * of G and a separation (X * , Y * , Z * ) with We recurse on G[X * ] and G[Y * ], each of which lies in ρ , as it is (isomorphic to) a subgraph of G.In particular, the density of the graphs encountered during the recursion does not increase.The recursive call on G * [X * ] yields a graph G ′ X and a tree T ′ X , and the recursive call on G * [Y * ] yields a graph G ′ Y and a tree T ′ Y , both with the properties given in the theorem.Let G ′ be the graph obtained by putting together G * [Z * ], G ′ X , and G ′ Y .If some vertex degree gets larger than four, we can make a vertex split there.There are at most |Z * | such vertex splits.A separator tree T ′ for G ′ is constructed by making a root for Z * and making the roots of T ′ X and T ′ Y its two children.Adding a pendant path of even length to G * [Z * ], if needed, we ensure that |Z * | = Θ(ρ|Z|), the maximum number of possible vertices after the splits (we again denote the resulting vertex set by Z * ).
For a graph G with m vertices considered during the recursion, by Theorem 2, we spend Θ(m) expected time to find the separation (X , Y, Z).Then, we construct the induced graph Finally, when we may add vertices to |Z * |, we spend Θ(ρm) time.Standard tools to analyze recursions imply that the expected running time is distributed evenly over the O(log n) levels of the tree.Thus, the expected total running time is O(ρn log n).
It is easy to see that the number of vertices of Note that the split graph G ′ in Lemma 3 is not necessarily in ρ .It is a subgraph of an intersection graph, but since we introduce copies of geometric objects when we split vertices, the density increases.In any case, this does not matter because G ′ will be accessed through the separator tree T ′ .

Nested dissection
We will need to compute with matrices.The arithmetic operations take place in p , where p = Θ(n 4 ) is prime.Thus, we work with numbers of O(log n)-bits, and assuming a standard unit-cost model, we simply need to bound the number of arithmetic operations.
Let A be an n × n matrix.A Gaussian elimination step on row i is the following operation: for j = i + 1, . . ., n, add an appropriate multiple of row i to row j so that the element at position ( j, i) becomes 0. Elimination on row i can be performed if the entry at position (i, i) is nonzero.Gaussian elimination on A consists of performing Gaussian elimination steps on rows i = 1, . . ., n − 1.This is equivalent to computing an LU decomposition of A, where L is a lower triangular matrix with units along the diagonal, and U is an upper triangular matrix.Gaussian elimination is performed without pivoting if, for all i, when we are about to do a Gaussian elimination step on row i, the entry at position (i, i) is non-zero.If Gaussian elimination is performed without pivoting, then the matrix is non-singular.(Pivoting is permuting the rows to ensure that the entry at position (i, i) is non-zero.) Let T be a separator tree for G(A).The row order of A is consistent with T if, whenever t ′ is an ancestor of t, all the rows of Z t are before any row of Z t ′ .We may assume that all the rows of Z t are consecutive.In particular, if the rows are ordered according to a post-order traversal of T , then the row order of A is consistent with T .A careful but simple revision of the nested dissection algorithm by Gilbert and Tarjan [GT86] leads to the following theorem.
Theorem 4. Let A be an n × n matrix such that the representing graph G(A) has bounded degree and assume that we are given a (γ, β, α)-separator tree T for G(A), were γ > 0, 0 < α < 1, and 1/2 ≤ β < 1 are constants.Furthermore, assume that the row order of A is consistent with T and that Gaussian elimination on A is done without pivoting.We can perform Gaussian elimination (without pivoting) on A and find a factorization A = LU of A in O(γ ω n βω ) time, where L is a lower triangular matrix with units along the diagonal and U is an upper triangular matrix.
For the proof of Theorem 4, we will need the following folklore lemma, whose proof we include for completeness.

Lemma 5. Let A be an n × n matrix, and k ≤ n. Suppose that Gaussian elimination on the first k rows of A needs no pivoting. Then, we can perform Gaussian elimination on the first k rows of A with O(n
Proof.Computing the inverse or performing Gaussian elimination for a k × k matrix takes O(k ω ) time (even if pivoting is needed), see, e.g., Bunch and Hopcroft [BH74], and Ibarra, Moran, and Hui [IMH82].Assume that We want to perform Gaussian elimination without pivoting for the first k rows.First, we perform Gaussian elimination on the k × k matrix A 1,1 .This takes O(k ω ) time, and we obtain two k × k matrices L and U such that A 1,1 = LU, the matrix L is lower triangular with units along the diagonal, and the matrix U is upper triangular.Since we use no pivoting, L and U are non-singular.We also compute in O(k ω ) time the inverses (A 1,1 ) −1 , L −1 , and U −1 .Then, we have , which means that the second matrix on the right side is the result of making Gaussian elimination for the first k rows of A.
Proof of Theorem 4. We assume that the reader is familiar with some of the previous work on nested dissection to compute elimination orders for Gaussian elimination [GT86,LRT79].Set G = G(A).For each edge i j of G, if i ∈ Z t and j ∈ Z t ′ , then either t = t ′ or t and t ′ have an ancestor-descendant relation in T .
For each node t of T , we eliminate all rows in Z t together, using block Gaussian eliminations.Since the row order is consistent with T , we have already eliminated all the rows of V t \ Z t , and we have not yet eliminated any row of Z t ′ , for any ancestor t ′ of t.
For each node t of T , let B t be the set of vertices j that belong to some Z t ′ , where t ′ is an ancestor of t in T , such that there is an edge from j to some vertex of V t .A vertex j of G(A) is affected by the elimination steps on the rows of Z t only if j belongs to Z t or to B t .Thus, performing Gaussian elimination steps on the rows of Z t affects at most |Z t | + |B t | rows and columns.Eliminating the rows of Z t affects the rows of B t .However, when processing node t, we do not yet perform any elimination steps on the rows of B t .Thus, we consider the submatrix with indices in Z t ∪ B t , and we perform the elimination steps only on the rows of Z t .By Lemma 5, this takes O( (2) , the first sum is bounded as follows: where in the last step we have used the assumption βω > 1.
To bound the second sum, we first analyze Σ = t∈T |B t | 2 .For this, we follow Gilbert and Tarjan [GT86] almost verbatim.Let L ℓ be the nodes of T at level ℓ and define Σ ℓ = t∈L ℓ |B t | 2 .(The root is at level 0.) Fix a level ℓ > 0. The sum Σ ℓ is maximized if for each node t ′ at level ℓ ′ < ℓ, all the edges with an endpoint in t ′ and an endpoint at level at least ℓ are incident to the same subgraph G[V t ] of t ∈ L ℓ .That is, to bound Σ ℓ , we can assume that all the edges incident to Z t ′ contribute to the same B t , t ∈ L ℓ .For each t ∈ L ℓ , let s(t) be the highest node of T with an edge going to V t .Because of the assumption we made, the mapping t → s(t) Using that each vertex of each Z t i has bounded degree, we get Since the map t → s(t) is an injection (when t ∈ L ℓ ), we have where in the last step we have used that the sets V s , s ∈ L ℓ ′ , are pairwise disjoint subsets of [n] for each level ℓ ′ , and 2β ≥ 1.For each ℓ and each t ∈ L ℓ , we have Combining it with (3), we get from (2) that the total running time is The theorem follows (in the statement of our theorem, we hide α in the O-notation, to avoid clutter and since the precise dependency is not important in our applications).
Remark 1: Mucha and Sankowski [MS06] noted that the result holds when G(A) is planar or, more generally, has recursive separators, using the approach by Lipton, Rose, and Tarjan [LRT79] for nested dissection.This approach is based on the strong separator tree.Alon, Yuster, and Zwick [AY13, YZ07] showed that a similar result holds for graphs of bounded degree with recursive separators if one instead uses the nested dissection given by Gilbert and Tarjan [GT86].In this case, we need bounded degree, but a weak separator tree suffices.Again, since we want to make the dependency on ρ explicit and since the analysis in terms of matrix multiplication time does not seem to be written down in detail anywhere, we revise the method carefully.Remark 2: Usually, the result is stated for symmetric positive definite matrices.Reindexing a symmetric positive definite matrix gives another symmetric positive definite matrix, and Gaussian elimination on such matrices can always be performed without pivoting.Thus, for positive semidefinite matrices, we do not need to assume that the row order is consistent with T because we can reorder the rows to make it consistent with T .However, Mucha and Sankowski [MS06] do need the general statement in their Section 4.2, and they mention this general case after their Theorem 13.Actually, they need it over p , where the concept of positive definiteness is not even defined!

The algorithm
Assume we have a graph G of ρ with n vertices and a geometric representation, i.e., geometric objects of density at most ρ such that G is a subgraph of G .We want to compute a maximum matching for G.For this, we adapt the algorithm of Mucha and Sankowski [MS06].We provide an overview of the approach, explain the necessary modifications, and emphasize the dependency on ρ in the different parts of the algorithm.
Using Lemma 3, we get in O(ρn log n) expected time a vertex-split graph G ′ of G and a separator tree T ′ for G ′ such that • (i) the graph G ′ has Θ(ρn) vertices and edges; • (ii) the maximum degree of G ′ is at most 4; Since G ′ is obtained from G by vertex splits, it suffices to find a maximum matching in G ′ .We set m = |V (G ′ )| = Θ(ρn), and we label the vertices of G ′ from 1 to m.We consider the variables X = (x i j ) i j∈E(G ′ ) ; i.e., each edge i j of G defines a variable x i j .Consider the m × m symbolic matrix ), defined as follows: The symbolic matrix A[X ] is usually called the Tutte matrix of G ′ .It is known [RV89] that the rank of A[X ] is twice the size of the maximum matching in G ′ .In particular, G ′ has a perfect matching if and only if det(A[X ]) is not identically zero.Take a prime p = Θ(n 4 ), and substitute each variable in A[X ] with a value from p , each chosen independently uniformly at random.Let A be the resulting matrix.Then, with high probability, rank(A) = rank(A[X ]), where on both sides we consider the rank over the field p [RV89].
From maximum matching to perfect matching.Let B = AA T .Then, B is symmetric, and the rank of B equals the rank of A. Note that (B) i, j is nonzero only if i and j share a neighbor in G ′ .Since G ′ has bounded degree, from the separator tree T ′ for G ′ , we can obtain a separator tree T B for the representing graph G(B).Since T ′ was a , where the constant hidden in O(ρ) is increased by the maximum degree in G ′ .Using Theorem 4, we obtain that Gaussian elimination can be done in ) time, assuming that pivoting is not needed.Mucha and Sankowski [MS06, Section 5] show how Gaussian elimination without pivoting can be used in B to find a collection of indices W ⊆ [m] such that the centered matrix (B) W,W , defined by rows and columns of B with indices in W , has the same rank as B. It follows that rank(A W,W ) = rank(B W,W ) and therefore G ′ [W ] contains a maximum matching of G ′ that is a perfect matching in G ′ [W ] (with high probability).The key insight to find such W is that, if during Gaussian elimination in B we run into a 0 along the diagonal, then the whole row and column are 0, which means that they can be removed from the matrix without affecting the rank.We summarize.Lemma 6.In time O(ρ 3ω/2 n ω/2 ) we can find a subset W of vertices of G ′ such that, with high probability, G ′ [W ] has a perfect matching that is a maximum matching in G ′ .
From now on, we can assume that G ′ has a perfect matching.We keep denoting by T ′ its separator tree, by A the matrix after substituting values of p into A[X ], and by B the matrix AA T .(We can compute the tree T ′ anew or we can reuse the same separator tree restricted to the subset of vertices.)Let Z r denote the set stored at the root r of T ′ .Thus, Z r is the first separator on G ′ .Let N r be the set Z r together with its neighbors in G ′ .Because G ′ has bounded degree, we have Mucha and Sankowski show how to compute with O(1) Gaussian eliminations a matching M ′ in G ′ that covers all the vertices of Z r and is contained in some perfect matching of G ′ .There are two ingredients for this.The first ingredient is to use Gaussian elimination on the matrix B = AA T to obtain a decomposition AA T = L D L T , and then use (partial) Gaussian elimination on a matrix Computing the latter is simpler, while computing the former is a major insight by Mucha and Sankowski [MS06, Section 4.2].)Interestingly, T ′ is also a separator tree for the representing graph of this matrix C, and Gaussian elimination can be performed without pivoting.Thus, we can obtain in O(ρ ω m ω/2 ) = O(ρ 3ω/2 n ω/2 ) time the matrix (A −1 ) N r ,N r .The second ingredient is that, once we have (A −1 ) N r ,N r , we can compute for any matching M ′ contained in G ′ [N r ] a maximal (with respect to inclusion) submatching M ′ that is contained in a perfect matching of G ′ .This is based on an observation by Rabin and Vazirani [RV89] that shows how to find edges that belong to some perfect matching using the inverse matrix, and Gaussian elimination on the matrix (A −1 ) N ,N to identify subsets of edges that together belong to some perfect matching.The matrix (A −1 ) N r ,N r is not necessarily represented by a graph with nice separators, but it is of size |N r | × |N r |.

Thus, Gaussian elimination in (A
Since the graph G ′ has bounded maximum degree, making O(1) iterations of finding a maximal matching M ′ in G ′ [N r ], followed by finding a maximal subset M ′′ of M ′ contained in a perfect matching of G ′ , and removing the vertices contained in M ′ plus the edges of M ′ \ M ′′ , gives a matching M * that covers Z r and is contained in a perfect matching of G ′ ; see [MS06, Section 4.3].The vertices of M * can be removed, and we recurse on both sides of G ′ − V (M * ) ⊂ G ′ − Z r using the corresponding subtrees of T ′ .The running time is T (n) = O(ρ 3ω/2 n ω/2 ) + T (n 1 ) + T (n 2 ), where n 1 , n 2 ≤ αn.This solves to T (n) = O(ρ 3ω/2 n ω/2 ) because ω/2 > 1.We summarize in the following result.If only the family is given, first we use Lemma 1 to construct G .
Theorem 7. Given a graph G of ρ with n vertices together with a family of geometric objects with density ρ such that G is a subgraph of G , we can find in O(ρ 3ω/2 n ω/2 ) time a matching in G that, with high probability, is maximum.In particular, for a family of n geometric objects with density ρ, a maximum matching in G can be found in O(ρ 3ω/2 n ω/2 ) time.The same holds for the bipartite or k-partite version of G .

Sparsification
Let be a family of convex geometric objects in the plane such that each object of contains a square of side length 1 and is contained in a square of side length Ψ ≥ 1.Through the discussion we will treat Ψ as a parameter.Our objective is to reduce the problem of computing a maximum matching in the intersection graph G to the problem of computing a maximum matching in G for some ⊆ of small depth.Let P = 2 be the points in the plane with integer coordinates.Each square of unit side length contains at least one point of P and each square of side length Ψ contains at most (1 + Ψ) 2 = O(Ψ 2 ) points of P. In particular, each object U ∈ contains at least one and at most O(Ψ 2 ) points from P. First we provide an overview of the idea.The objects intersected by a point p ∈ P define a clique, and thus any even number of them defines a perfect matching.We show that, for each p ∈ P, it suffices to keep a few objects pierced by p, and we show how to obtain such a suitable subfamily.The actual number of objects to keep depends on Ψ, and whether the actual computation can be done efficiently depends on the geometric shape of the objects.
For each object U ∈ , we find the lexicographically smallest point in P ∩ U. We assume that we have a primitive operation to compute P ∩ U for each object U ∈ in O(1 + |P ∩ U|) = O(Ψ 2 ) time.A simple manipulation of these incidences allows us to obtain the clusters p = {U ∈ | p lexicographically minimum in P ∩ U}, for all p ∈ P.
Note that the clusters p , for p ∈ P, form a partition of .This will be useful later.Clearly, the subgraph of G induced by p is a clique, for each p ∈ P.
We will use the usual notation The pattern graph H = H(P, Ψ) has vertex set P and set of edges The use of the pattern graph is encoded in the following property: if U ∈ p , V ∈ q and U ∩ V ̸ = , then pq ∈ E(H).Indeed, if U and V intersect, then the union U ∪ V is contained in a square of side length 2Ψ, and thus the L ∞ -distance between each p ∈ P ∩ U and q ∈ P ∩ V is at most 2Ψ.The definition of H(P, Ψ) implies that the edge set of G is the disjoint union of E( p , q ), over all pq ∈ E(H), and the edge sets of the cliques G p , over all p ∈ P. Thus, whenever pq / ∈ E(H), there are no edges in E( p , q ).
Let λ be the maximum degree of H.Note that λ = O(Ψ 2 ).The value of λ is an upper bound on how many clusters q may interact with a single cluster p .We will use λ as a parameter to decide how many objects from each p are kept.We start with a simple observation.

Lemma 8. There exists a maximum matching in G that, for all pq ∈ E(H), contains at most one edge of E( p , q ).
Proof.Let M be a maximum matching in G such that pq∈E(H) |M ∩ E( p , q )| is minimum.Suppose there is an edge p 0 q 0 ∈ E(H) with |M ∩ E( p 0 , q 0 )| ≥ 2. Then we have two edges U V and U ′ V ′ in M ∩ E( p 0 , q 0 ), where U, U ′ ∈ p 0 and V, V ′ ∈ q 0 .Since U U ′ and V V ′ are also edges in G , we see that In this last statement, it is important that p , p ∈ P, is a partition of , as otherwise U U ′ could belong to some E( p , q ) or even E( p 0 , q 0 ).Hence, pq∈E(H) |M ′ ∩ E( p , q )| is strictly smaller than pq∈E(H) |M ∩ E( p , q )|, a contradiction to our choice of M .The result follows.
Of course we do not know which object from the cluster p will interact with another cluster q .We will explain how to get a large enough subset of cluster p .
For each pq ∈ E(H), we construct a set (p, q) ⊆ p ∪ q as follows.First, we construct a matching M = M (p, q) in E( p , q ) such that M has 2λ + 1 edges or M has fewer than 2λ + 1 edges and is maximal in E( p , q ).For example, such a matching can be constructed incrementally.If M has 2λ + 1 edges, we take (p, q) to be the endpoints of M .Otherwise, for each endpoint U ∈ p (resp.V ∈ q ) of M , we place U (resp.V ) and λ of its neighbors from q (resp.p ) into (p, q).When U (resp.V ) has fewer than λ neighbors, we place all its neighbors in (p, q).This finishes the description of (p, q); refer to Algorithm Sparsify-one-edge in Figure 2 for pseudo-code.Algorithm Sparsify-one-edge Input: p, q, p and q Output: (p, q) 1.
U ← an arbitrary object of p 7.
if U intersects some V ∈ q then 8.
Since z was arbitrary, the lemma follows.
Theorem 11.Let be a family of n geometric objects in the plane such that each object of contains a square of side length 1 and is contained in a square of side length Ψ. Suppose that, for any m ∈ and for any p, q ∈ 2 with | p | + | q | ≤ m, we can compute the sparsification (p, q) as described above in time T spars (m), where T spars (m) = Ω(m) is convex.In O(Ψ 2 • T spars (n)) time we can reduce the problem of finding a maximum matching in G to the problem of finding a maximum matching in G for some ⊆ with maximum depth O(Ψ 8 ).
Proof.For each pq ∈ E(H), we find the sparsification (p, q).Note that pq∈E(H) (| p |+| q |) ≤ λn, as each p contributes λ summands.Hence, the computation of (p, q), for all pq ∈ E(H), takes time Consider the family = ∪ pq∈E(H) (p, q).By Lemma 10, the family has depth O(Ψ 8 ).By Lemma 9, it suffices to find a maximum matching in Since each G p is a clique and the vertices of p \ are not adjacent to any vertex outside p (in the graph (4)), we can just take maximum matchings within each ′ p = p \ .Here, we have to take care of the parity, as one vertex of ′ p may be left unmatched in G ′ p , but may be matched to some vertex of p ∩ .To handle this, for each p ∈ P such that | ′ p | is odd, we move one element of ′ p to .Thus, we can assume that | ′ p | is even, for all p ∈ P. The additional elements in may increase the depth of by O(Ψ 2 ), which is negligible.Now, a maximum matching (4) is obtained by joining a maximum matching in G with maximum matchings in G ′ p , p ∈ P. The maximum matchings in G ′ p , p ∈ P, are trivial, because it is a clique on an even number of vertices.The result follows.
Our use of properties in the plane is very mild, and similar results hold in any space with constant dimension.
Theorem 12. Let d ≥ 3 be a constant.Let be a family of n geometric objects in d such that each object of contains a cube of side length 1 and is contained in a cube of side length Ψ. Suppose that, for any m ∈ and for any p, q ∈ d with | p | + | q | ≤ m, we can compute the sparsification (p, q) as described above in time T spars (m), where T spars (m) = Ω(m) is convex.In O(Ψ d • T spars (n)) time we can reduce the problem of finding a maximum matching in G to the problem of finding a maximum matching in G for some ⊆ with maximum depth (1 + Ψ) O(d) .
Proof.The pattern graph H can be defined for d also using the L ∞ -metric.Such pattern graph has maximum degree O((1 Lemmas 8 and 9 hold equally in this setting.Lemma 10 holds with an upper bound of (1 + Ψ) O(d) .The proof of Theorem 11 then applies.
As we mentioned in the introduction, for fat objects, bounded depth implies bounded density; see Har-Peled and Quanrud [HQ17, Lemma 2.7].If a convex object contains a cube of unit side length and is contained in a cube of side length Ψ, then it is O(1/Ψ)-fat; see van der Stappen et al. [vdSHO93], where the parameter 1/Ψ goes under the name of thickness.Combining both results, one obtains that the relation between depth and density differs by a factor of Ψ.For fixed shapes, the depth and density differ by a constant factor.

Efficient sparsification
Now, we implement Algorithm Sparsify-one-edge (Figure 2) efficiently.In particular, we must perform the test in line 7 and find the neighbors in line 19 (and the symmetric case in line 21).The shape of the geometric objects becomes relevant for this.First, we note that it suffices to obtain an efficient semi-dynamic data structure for intersection queries.
Lemma 13.Suppose there is a data structure with the following properties: for any m ∈ and for any p, q ∈ 2 with | p | + | q | ≤ m, we can maintain a set q ⊆ q under deletions so that, for any query U ∈ p , we either find some V ∈ q with U ∩ V ̸ = or correctly report that no such V exists.Let T con (m) be the time to construct the data structure, T que (m) an upper bound on the amortized query time, and T del (m) be an upper bound on the amortized deletion time.Then, the running time of Algorithm Sparsify-one-edge (Figure 2) for the input (p, q, p , q ) is T sparse (m) = O(T con (m) + mT que (m) + λ 2 T del (m)).
Proof.First, we discuss the operations in lines 5-10 in Algorithm Sparsify-one-edge (Figure 2).We maintain p as a linked list and q in the data structure from the lemma.This takes O(T con (m)) time.Initially, p = p and q = q .In each iteration of the while-loop, we query with U to either obtain some V ∈ q intersected by U, or correctly report that no object of q intersects U.If we get some V intersected by U, we remove V from q in O(T del (m)) time.(Note that we have removed at most 2λ elements of q to obtain the current q .)In either case, we remove U from p , in O(1) time.The running time for this part is O(mT que (m) + λT del (m)).
Next, we discuss how to do line 19 in Algorithm Sparsify-one-edge (Figure 2).We store q = q in the data structure from the lemma.For each W ∈ ∩ p , we repeatedly query the data structure to find some V ∈ q that intersects W , and we remove this V from q .We repeat this query-delete pattern in q with W , until we collect λ neighbors of W or until we run out of neighbors.Thus, the query-deletion pattern happens at most λ times, for each W . Having collected the data for W , we reverse all the deletions in q , to obtain the original data structure for q = q , and we proceed to the next object of ∩ p .(We do not need insertions, as it suffices to undo the modifications that were made in the data structure.)In total, we repeat O(| ∩ p |) = O(λ) times a pattern of O(λ) queries and deletions followed by a reversal of all the operations.Thus, the running time is T con (m) to construct the data and O(λ 2 T que (m) + λ 2 T del (m)) to handle the operations on the data structure.We can assume that λ 2 ≤ m, as otherwise we do not need to run the sparsification and can take directly the whole set of objects.
Line 21 in Algorithm Sparsify-one-edge (Figure 2) can be done in a similar way.The rest of the algorithms are elementary steps and bookkeeping.This data structure can be used to dynamically maintain a set = {D 1 , . . ., D n } of disks so that, for a query disk D, we can either report one disk of intersected by D or correctly report that no disk of intersects D. Indeed, we store as a set A of weighted points.Each disk D i is represented by its center a i with weight equal to its negated radius.If x is a point in the plane that lies outside the union of , the closest weighted point of A gives the first disk boundary that is touched by a growing disk centered at x.If x lies inside the union of , the closest weighted point gives the last boundary of a disk in that contains x and that is touched by growing a disk around x. Thus, to answer a query for a disk D, we query for the weighted point a i ∈ A closest to the center of D, and then check whether D intersects D i .Updates and queries take O(log 4 n) amortized expected time.

Disks in the plane
Using Lemma 13, we conclude that T sparse (m) = O((m + λ 2 ) log 4 m) expected time.Recall that λ 2 = O(Ψ 4 ).Because of Theorem 11, we conclude that the reduction takes time Possibly, the method can be extended to homothets of a single object.For this one should consider the surfaces defined by weighted distances in the approach of Kaplan et al.
Since the depth and the density of a family of disks are linearly related, Proposition 14 and Theorem 7 with ρ = O(Ψ 8 ) imply the following.
Theorem 15.Consider a family of n disks in the plane with radii in the interval [1, Ψ].In O(Ψ 6 n log 4 n + Ψ 12ω n ω/2 ) expected time, we can compute a matching in G that, with high probability, is maximum.

Translates of a fixed convex shape in the plane
Now, suppose consists of translates of a single convex object with non-empty interior in the plane.With an affine transformation, we ensure that the object is fat: the radii of the minimum enclosing disk and of the maximum enclosed disk are within a constant factor.Such a transformation is standard; e.g., [AHV04, Lemma 3.2].Thus, we may assume that Ψ = O(1).We start with a standard lemma.
Lemma 16.Let be a family of n translates of a convex object in the plane that are pierced by a given point q.The union of can be computed in O(n log n) time.
Proof.The boundary of two translates of the same convex object intersect at most twice.This means that is a family of pseudodisks.Let q be the given point that pierces all U ∈ .We assume that q belongs to the interior; otherwise it is necessary to make groups of objects and use O(1) points that intersect all the U ∈ .
Each U ∈ defines a function δ U : [0, 2π] → , where δ U (θ ) is the length of the longest segment inside U with origin q and angle θ with some fixed axis.Since q is in the interior of U, the function δ U (•) is continuous.We can extend each function δ U to the whole by taking δ U (θ ) = δ(0), for θ / ∈ [0, 2π].The family {δ U | U ∈ } of totally defined functions is a family of pseudoparabolas: the graphs of any two of them intersect at most twice.
The upper envelope of a family of n pseudoparabolas can be computed in O(n log n) time with a divide-and-conquer approach.First, we note that the upper envelope of n totally defined pseudoparabolas has at most 2n − 1 pieces.This is a standard property from the study of Davenport-Schinzel sequences.For the algorithm, we split the family into two subfamilies 1 and 2 of roughly the same size, recursively compute the upper envelopes g 1 of 1 and g 2 of 2 , and then compute the upper envelope of g 1 and g 2 .If the upper envelopes are given as x-monotone curves, then the upper envelope of g 1 and g 2 , which is the upper envelope of , is obtained in additional linear time.Since the merging step takes linear time, the whole algorithm takes O(n log n) time.
The maps δ U do not need to be computed explicitly and the whole algorithm can actually be carried out with a rotational sweep around q.The transformation to consider the functions δ U helps to bring it to familiar ground in computational geometry.
We will use the following lemma to "simulate" deletions.For this, we will keep a half-infinite interval of indices that contains the elements that are "deleted".

Lemma 17. Let
= {U 1 , . . .U n } be a family of n translates of a convex object in the plane that are pierced by a given point q.In O(n log 2 n) time, we can construct a data structure for the following queries: given x ∈ 2 and a value a ∈ {1, . . ., n}, find the smallest i ≥ a such that U i contains x, or correctly report that x does not belong to U a ∪ Proof.We follow the standard approach for adding range capabilities to data structures [WL85]: we make a balanced binary search tree T whose leaves are 1, . . ., n, from left to right.For each node ν of T , we define C(ν) as the set of indices stored at the leaves of the subtree rooted at ν.The set C(ν) is a canonical subset of {1, . . ., n}.
For each node ν ∈ T , we compute the region R(ν) = i∈C(ν) U i .This can be done in O(n log n) time for all nodes ν of T .Indeed, the divide-and-conquer approach from the proof of Lemma 16 can be applied here.If a node ν has children ν ℓ and ν r , then For each node ν of T , we preprocess the region R(ν) for point location queries.This takes O(|C(ν)|) time, because we just need the description of the boundary of R(ν) in a table.To decide whether a given point x ∈ 2 lies in R(ν), we make a binary search along the boundary of R(ν) for the arc of R(ν) that is intersected by the ray from q through x.This takes O(log n) time.This finalizes the preprocessing and the construction of the data structure.
Consider a query consisting of a point x ∈ 2 and an index a.We may assume that a ∈ {1, . . ., n}.The set {a, a + 1, . . ., n} can be expressed as the disjoint union of canonical subsets C(ν 1 ), . . ., C(ν k ), where k = O(log n), indexed so that each element of ν t is smaller than each element of ν t+1 , for t = 1, . . ., k − 1. Making point location queries in R(ν 1 ), R(ν 2 ), . . .we find the first index j such that x ∈ R(ν j ).This takes O(log 2 n), as we make O(log n) point location queries.
Then, we search the subtree of T rooted at ν j for the leftmost leaf i with x ∈ i .This is easy: if we are at some internal node ν with left child ν ℓ and right child ν r , we query the point location data structure at ν ℓ to determine whether x ∈ R(ν ℓ ).If x ∈ R(ν ℓ ), we continue to ν ℓ .Otherwise, x must be in R(ν r ), as x ∈ R(ν), and we go to ν r .This search makes O(log n) queries to the point location structures, and thus takes O(log 2 n) time.
Lemma 18.Let q = {V 1 , . . .V n } be a family of n translates of a convex object in the plane that are pierced by a given point q.Let U 0 be a convex object.In O(n log 2 n) time, we can construct a data structure for the following type of queries: given a translate U of U 0 and a value a, find the smallest i ≥ a such that U intersects V i , or correctly report that U does not intersect V a ∪ • • • ∪ V n .Each query can be answered in O(log 2 n) time.
Proof.Applying a translation, we may assume that U 0 contains the origin.For each be the Minkowski sum of V i and −U 0 .For each translation τ, we have that τ(U 0 ) intersects V i if and only if τ ∈ W i .
All the sets W 1 , . . ., W n contain q because the origin belongs to U 0 .Thus, we can construct the data structure of Lemma 17 for {W 1 , . . ., W n }.For a query U and a, we find the translation τ such that U = τ(U 0 ), and then find the smallest i ≥ a such that τ ∈ W i , which also tells the smallest i ≥ a such that U intersects V i .
Lemma 18 can be used to make queries and simulate deletions.

Proposition 19. Consider a family of n translates of a convex object with non-empty interior in the plane. In O(n log 2 n) time, we can reduce the problem of finding a maximum matching in G to the problem of finding a maximum matching in G for some subfamily
⊆ with maximum depth O(1).
Proof.As mentioned above, we may make an affine transformation, so that, after the transformation, we have Ψ = O(1) [AHV04, Lemma 3.2].Consider an edge pq of the pattern graph.We use the algorithm described in Lemma 13, but with a slight modification.We order the objects of q as {V 1 , . . ., V m } and use the data structure of Lemma 18 to store them.At the start we set a = 1.Whenever we want to query q with U, we query the data structure with U and the current a.If the data structure returns V i , we set a = i+1 for future queries to the data structure.In this way, each time we query the data structure, we find a new element of q that has not been reported before.Thus, we obtain the same running time as in Lemma Combining Proposition 19 and Theorem 7 we obtain the following.
Theorem 20.Consider a family of translates of a convex object with non-empty interior in the plane.In O(n ω/2 ) time we can find a matching in G that, with high probability, is maximum.

If
consists of unit disks, the sparsification can be done slightly faster using a semi-dynamic data structure by Efrat, Itai, and Katz [EIK01], which has T con (m) = O(m log m), T del (m) = O(log m) and T que (m) = O(log m).However the current bottleneck is the computation of the maximum matching after the sparsification.Thus, improving the sparsification in the particular case of unit disks does not lead to an improved final algorithm.
Proposition 19 and Theorem 20 also holds if we have translations of O(1) different convex objects (with nonempty interiors).Indeed, the data structure of Lemma 18 can be made for each pair of different convex shapes.In this case, the constant Ψ depends on the shapes, namely the size of the largest square that we can place inside each of the convex shapes and the size of the smallest square that can be used to cover each of the convex shapes.Also, the relation between the depth and the density depends on the shapes.However, for a fixed set of O(1) shapes, both values are constants that depend on the shapes.
Theorem 21.Suppose we are given a set of O(1) different convex objects in the plane with non-empty interiors.Let be a family that contains n translates of objects from .Then, we can find in O(n ω/2 ) time a matching in G that is maximum with high probability.Here, the constant in the O-notation depends on .In fact, better results can be obtained with more advanced techniques, but we feel that discussing them is not relevant here.(Also, we only need deletions, which makes it simpler, as in the relevant trees we can just mark some vertices as deleted.)Using Lemma 13 and Theorem 12, we obtain the result.

Axis-parallel objects
For d = 2, we can combine Theorem 7 and Proposition 22. Since we have assumed ω > 2, the O(n log O(d) n) term is asymptotically smaller than O(n ω/2 ), and we obtain the following.
Theorem 23.Given a family of n boxes in 2 such that each object of contains a square of side length 1 and is contained in a square of side length Ψ, we can compute in (1 + Ψ) O(1) n ω/2 time a matching in G that, with high probability, is a maximum matching.For the resulting set with depth O(1), it is better to use the algorithm of Micali and Vazirani [MV80,Vaz12].Note that G is sparse, and thus has O(n) edges.Therefore, a maximum matching in G can be computed in O(n 3/2 ) time.In summary, we spend O(n 4/3+ϵ ) for the sparsification and O(n 3/2 ) for computing the matching in the sparsified setting.9

Conclusion
We have proposed the density of a geometric intersection graph as a parameter for the maximum matching problem, and we showed that it can be fruitful in obtaining efficient matching algorithms.Then, we presented a sparsification method that lets us reduce the general problem to the case of bounded density for several interesting classes of geometric intersection graphs.In our sparsification method, we did not attempt to optimize the dependency on the radius ratio Ψ.It may well be that this can be improved by using more advanced grid-based techniques.Furthermore, our sparsification needs the complete intersection graph and does not apply to the bipartite setting.Here, we do not know of a method to reduce the general case to bounded density.In general, the complexity of the matching problem is wide open.To the best of our knowledge, there are no (even weak) superlinear lower bounds for the (static) matching problem in general graphs.

A
box is the Cartesian product of intervals.Combining standard data structures for orthogonal range searching [dBCvKO08, Sections 5.4 and 10.3] one obtains the following results.Proposition 22.Let d ≥ 2 be an integral constant.Consider a family of n boxes in d such that each box of contains a cube of side length 1 and is contained in a cube of side length Ψ.In O(Ψ d •n log O(d) n) time we can reduce the problem of finding a maximum matching in G to the problem of finding a maximum matching in G , for some ⊆ with maximum depth (1 + Ψ) O(d) .Proof.Edelsbrunner and Maurer [EM81] show a general approach to provide a data structure to dynamically maintain a set of boxes and handle the following queries: given a box b, report all the boxes in the data structure that intersect b.The construction time is O(n log d n), each update (deletion/insertion) takes O(log d ) time, and each query takes O(k + log d n), where k is the size of the output.The data structure is a combination of segment and range trees.Such a data structure can easily be modified to report a single element intersecting the query box b in O(log d n) time.
Consider now the case d ≥ 3. The set that we obtain from Proposition 22 has depth and density ρ = (1+Ψ)O(d) , and therefore the graph G has O(ρn) edges; see Lemma 1.We can thus use the algorithm ofMicali and Vazirani [MV80,Vaz12], which takesO( n|E(G )|) = (1 + Ψ) O(d) n 3/2 time.We summarize. 8orollary 24.Let d ≥ 3 be an integral constant.Given a family of n boxes in d such that each object of contains a cube of side length 1 and is contained in a cube of side length Ψ, we can compute in (1 + Ψ) O(d) n 3/2 time a maximum matching in G .5.4 Congruent balls in d ≥ 3 dimensionsConsider now the case of congruent balls in d , for constant d ≥ 3. Note that λ = O(1) in this case.We use the dynamic data structure by Agarwal and Matoušek [AM93] for the sparsification.For each m with n ≤ m ≤ n ⌈d/2⌉ , the data structure maintains n points in d , answers O(n) queries for closest point and supports O(λ 2 ) updates inO m 1+ϵ + λ 2 m 1+ϵ n + n • n log 3 n m 1/⌈d/2⌉time.Here ϵ > 0, is an arbitrary constant whose choice affects to the constants hidden in the O-notation.For d ∈ {3, 4}, this running time isO m 1+ϵ + λ 2 m 1+ϵ n + n • n log 3 n m 1/2 .Setting m = n 4/3 ,we get a running time of O(n 4/3+ϵ + λ 2 n 1/3+ϵ ) = O(n 4/3+ϵ ) to handle O(n) queries and O(λ 2 ) = O(1) updates.Using this in Lemma 13 and Theorem 12, we get the following result Proposition 25.Consider a family of n unit balls objects in d , for d ∈ {3, 4}.In O(n 4/3+ϵ ) time, we can reduce the problem of finding a maximum matching in G to the problem of finding a maximum matching in G for some ⊆ with maximum depth O(1).

For d > 4 ,
we set m = n 2⌈d/2⌉ 1+⌈d/2⌉ .The running time for the sparsification is then O(n 2⌈d/2⌉ 1+⌈d/2⌉ +ϵ ).For each constant d, the resulting instance G has O(n) edges.For d = 5, 6, the running time of the sparsification is O(n 3/2+ϵ ).However, after the sparsification, we have a graph with O(n) edges, and we can use the algorithm of Micali and Vazirani [MV80, Vaz12], which takes O(n 3/2 ) time.Thus, for d ≥ 5, the running time is dominated by the sparsification.Theorem 26.Let d ≥ 3 be a constant.Consider a family of congruent balls in d .For d = 3, 4, we can find in O(n 3/2 ) time a maximum matching in G .For d ≥ 5, we can find in O(n 2⌈d/2⌉ 1+⌈d/2⌉ +ϵ ) time a maximum matching in G , for each ϵ > 0.

Table 1 :
Then we can employ our result from above for G ′ or, more generally, any algorithm for maximum matching (taking advantage of the sparsity of the new Time complexity to compute the maximum matching in an intersection graph.In some cases, the result is correct with high probability. instance).
The following well-known lemma bounds |G | in terms of ρ, and the time to construct G .We include a proof for completeness.≥diam(X ) that intersect X , with X being one of them.Next, we describe the construction of G in the planar case; see [KKM + 19] for a similar algorithm in the context of disk graphs.Set k It follows that z can only be contained in objects of p for O(Ψ 2 ) points p ∈ P, so the depth of z in is at most ′ min{λ, |E({W }, q )|} elements of q intersecting W 20. else ( * W ∈ p * ) 21. add to ′ min{λ, |E( p , {W })|} elements of p intersecting W 22. return ′ Figure 2: Algorithm Sparsify-one-edge 1 + Ψ from z.
Whenconsists of disks in the plane, we can use the data structure of Kaplan et al. [KMR + 20], with a recent improvement byLiu [Liu22], to sparsify an edge of the pattern graph.This leads to the following.Proof.Kaplan et al.[KMR + 20] describe a data structure for additively weighted nearest-neighbor queries: maintain points A = {a 1 , . .., a n } ⊆ 2 in the plane, where each point a i has a weight ω i ∈ associated to it.The data structure can handle insertions, deletions, and closest point queries (for a given x ∈ 2 , return a point in arg min a i ∈A ω i + |x − a i |) in O(log 4 n) amortized expected time.7