Dynamic Data Structures for Interval Coloring

TL;DR

This paper introduces efficient online and dynamic algorithms for interval graph coloring, achieving near-optimal color usage and update times, with theoretical bounds and practical implications for dynamic graph management.

Contribution

The paper presents a novel incremental coloring algorithm with bounded colors and efficient amortized update time, and a fully dynamic algorithm with improved worst-case update bounds for interval graphs.

Findings

Incremental algorithm uses at most 3ω - 2 colors.

Amortized update time is O(log n + Δ).

Fully dynamic updates support insertion in O(log n + Δ log ω) and deletion in O(Δ^2 log n).

Abstract

We consider the dynamic graph coloring problem restricted to the class of interval graphs. At each update step the algorithm is presented with an interval to be colored, or a previously colored interval to delete. The goal of the algorithm is to efficiently maintain a proper coloring of the intervals with as few colors as possible by an online algorithm. In the incremental model, each update step presents the algorithm with an interval to be colored. The problem is closely connected to the online vertex coloring problem of interval graphs for which the Kierstead-Trotter (KT) algorithm achieves the best possible competitive ratio. We first show that a sub-quadratic time direct implementation of the KT-algorithm is unlikely to exist conditioned on the correctness of the Online Boolean Matrix Vector multiplication conjecture due to Henzinger et al. \cite{DBLP:conf/stoc/HenzingerKNS15}. We then design an incremental algorithm that is subtly different from the KT-algorithm and uses at most $3 \omega - 2$ colors, where $\omega$ is the maximum clique in the interval graph associated with the set of intervals. Our incremental data structure maintains a proper coloring in amortized $O(\log n + \Delta)$ update time where $n$ is the total number of intervals inserted and $\Delta$ is the maximum degree of a vertex in the interval graph. We then consider the fully dynamic framework involving insertions and deletions. On each update, our aim is to maintain a $3 \omega - 2$ coloring of the remaining set of intervals, where $\omega$ is the maximum clique in the interval graph associated with the remaining set of intervals. Our fully dynamic algorithm supports insertion of an interval in $O(\log n + \Delta \log \omega)$ worst case update time and deletion of an interval in $O(\Delta^2 \log n)$ worst case update time.

Tables

Table 1. Table 1: Comparison of Procedures in Incremental and Fully Dynamic cases

Procedure	Incremental	Fully Dynamic
$\mathrm{𝖼𝗈𝗆𝗉𝗎𝗍𝖾}\text{-}\mathrm{𝖲𝖫𝖲}$$(ℐ,t)$:Maintains the SLS for endpoint $t$	Worst case	Worst case
(i) in the Incremental case: as a dynamic array $A_t$	$O\left(\log \left(n\right)+\omega \right)$	$O\left(\log \left(n\right)+\omega \log \omega \right)$
and doubly linked list $Q_t$.	(Lemma 9)	(Lemma 17)
(ii) in the Fully Dynamic case: Red Black Tree $Z_t$ and $N{Z}_t$.	Return value $A_t,Q_t$	Return value $Z_t,N{Z}_t$
$\mathrm{𝖼𝗈𝗆𝗉𝗎𝗍𝖾}\text{-}\mathrm{𝗆𝖺𝗑}\text{-}\mathrm{𝖲𝖫𝖲}$$(ℰ,I_i)$: From the interval tree $ℰ$,	Worst case	Worst case
computes the set of endpoints $S$ contained in the interval $I_i$	$O\left(\log \left(n\right)+\Delta \right)$	$O\left(\log \left(n\right)+\Delta \log \omega \right)$
and returns $h$ = $\max \left\{h_t|t\in S\right\}$	(Lemma 10)	(Lemma 18)
	Return value $S,h$	Return value $S,h$
$\mathrm{𝗎𝗉𝖽𝖺𝗍𝖾}\text{-}\mathrm{𝖤𝗇𝖽𝗉𝗈𝗂𝗇𝗍𝗌}$$(S,L\left(I_i\right))$: Updates the endpoints in $S$	Amortized	Worst case
on addition of interval $I_i$ at level $L\left(I_i\right)$. For each $t\in S$	$O\left(\Delta \right)$	$O\left(\Delta \log \omega \right)$
(i) Incremental case: updates $A_t$ and $Q_t$	(Lemma 11)	(Lemma 19)
(ii) Fully Dynamic case: updates $Z_t$ and $N{Z}_t$
$\mathrm{𝖼𝗈𝗆𝗉𝗎𝗍𝖾}\text{-}\mathrm{𝖮𝖿𝖿𝗌𝖾𝗍}$$\left(I_i\right)$: Assigns an offset value to $I_i$ from $\{1,2,3\}$	Worst case	Worst case
by considering the offset of the intervals	$O\left(\log \left(n\right)\right)$	$O\left(\log \left(n\right)\right)$
intersecting it in $T\left[L\left(I_i\right)\right]$	(Lemma 8)	(Lemma 8)

Table 2. Table 2: Data Structures used in dynamic setting

Interval Tree $ℐ$ [16]
Method	Description	Running Time	Return
			Value
$ℐ$.insert($I$)	Inserts interval $I$ into $ℐ$	$O\left(\log \left(\left|ℐ\right|\right)\right)$ worst case	-
$ℐ$.delete($I$)	Deletes interval $I$ from $ℐ$	$O\left(\log \left(\left|ℐ\right|\right)\right)$ worst case	-
$ℐ$.intersection($I$)	Returns a set of intervals $S_I$ in $ℐ$	$O\left(\log \left(\left|ℐ\right|\right)+\left|S_I\right|\right)$	$S_I$
	that intersect with $I$	worst case
Doubly linked list $Q$ [17]
$Q$.insert($x$)	Inserts element $x$ into list $Q$	$O\left(1\right)$ worst case	-
$Q$.delete($x$)	Deletes element $x$ from list $Q$	$O\left(1\right)$ worst case	-
$Q$.begin()	Returns the first element $x$ of list $Q$	$O\left(1\right)$ worst case	$x$
Set $U$ [18]
$U$.insert($x$)	Inserts a new element $x$ into $U$	$O\left(1\right)$ amortized	-
$U$.begin()	Iterator to the first element of the set	$O\left(1\right)$ worst case	-
$U$.end()	Iterator to the last element of the set	$O\left(1\right)$ worst case	-
Dynamic Array $A$ [19]
$A$.at($i$)	Inserts at $i$-th position of array $A$.	$O\left(1\right)$ amortized	-
	Doubles the array size after initialization
	if array is full
$A$.size()	Returns the size of array $A$	$O\left(1\right)$ worst case	size
Red-Black Tree $R$ [20]
$R$.insert($x$)	Inserts element $x$ into $R$	$O\left(\log \left(\left|R\right|\right)\right)$ worst case	-
$R$.delete($x$)	Deletes element $x$ from $R$	$O\left(\log \left(\left|R\right|\right)\right)$ worst case	-
$R$.max()	Returns the maximum element $x$ in $R$	$O\left(\log \left(\left|R\right|\right)\right)$ worst case	$x$
$R$.min()	Returns the minimum element $x$ in $R$	$O\left(\log \left(\left|R\right|\right)\right)$ worst case	$x$
$R$.empty()	Checks if the tree $R$ is empty	$O\left(1\right)$ worst case	0/1

Full text

Any direct implementation of the KT-algorithm requires $\Omega(\Delta^{2})$ time per interval in the worst case.

There exists an incremental algorithm which supports insertion of an interval in amortized $O(\log n+\Delta)$ time per update and maintains a proper coloring using at most $3\omega-2$ colors.

There exists a fully dynamic algorithm which supports insertion of an interval in $O(\log n+\Delta\log\omega)$ update time and deletion of an interval in $O(\Delta^{2}\log n)$ update time in the worst case and maintains a proper coloring using at most $3\omega-2$ colors.

The KT-algorithm crucially uses the maximum clique size in an induced subgraph in the neighborhood of a given vertex. We show that the problem of computing the induced subgraph among the neighbors of a given vertex has the same hardness as the online boolean matrix vector multiplication problem [2]. We show that

Any algorithm that computes the induced subgraph among the neighbors of a given vertex requires at least quadratic time unless the OMv conjecture [2] is false.

Finally, we obtain the following result on the OMv conjecture.

If the matrix and the vectors in the online sequence have the consecutive ones property, then the OMv conjecture [2] is false.

††journal: Theoretical Computer Science

1 Introduction

Maintenance of data structures for graphs in the dynamic setting has been extensively studied. In the dynamic setting, a graph has a fixed set of vertices whereas the edge set keeps evolving by means of edge updates. An edge update consists of either insertion of a new edge or deletion of an existing edge. A dynamic graph is thus a sequence of graphs, $\mathcal{G}=\{G_{0},G_{1},......,G_{t}\}$, where $t$ is the total number of edge updates, initial graph $G_{0}=(V,\phi)$ is an empty graph and graph $G_{i}$ is obtained from $G_{i-1}$ by a single edge update. In our work, $G_{i}$ is an interval graph and an update consists of an interval to be inserted or deleted. Therefore, in our dynamic setting, a single update may insert or delete many edges in the underlying interval graph. This is different from the commonly studied case in the area of dynamic graph algorithms where on each edge update a single edge is inserted or deleted.

The graph coloring problem is one of the most extensively studied problems. In the dynamic setting, graph coloring problem is as follows: there is an online sequence of edge updates and the goal is to maintain proper coloring after every update. Several works ([3],[4],[5] and [6]) propose heuristic and experimental results on the dynamic graph coloring problem. To the best of our knowledge, the formal analysis of data structures for dynamic graph coloring have been done in [7], [8], [9], [10], [11], and [12]. We continue the study of dynamic data structures for graph coloring. We focus on interval graphs in the incremental as well as in the fully dynamic setting. The online update sequence consists of intervals and our goal is to maintain a proper coloring of the intervals with as few colors as possible while maintaining a small update time. In the incremental setting, each update in the online update sequence consists of an interval to be colored. In the fully dynamic setting, each update in the online update sequence consists of either an interval to be colored or a previously colored interval to be deleted.

In the incremental setting, intervals in the update sequence are inserted one after the other and we aim to efficiently maintain a proper coloring of the intervals using as few colors as possible after every update. Our approach is to consider efficient implementations of well-studied online algorithms for interval coloring. Online algorithms for interval coloring and variants is a rich area with many results [13]. Note that an online algorithm is not allowed to re-color a vertex during the execution of the algorithm. On the other hand, an incremental algorithm is not restricted in anyway during an update step except that we desire that the updates be done as efficiently as possible. Naturally, an online interval coloring algorithm which is efficiently implementable is a good candidate for an incremental interval coloring algorithm as it only assigns a color to the current interval, and does not change the color of any of the other intervals. For the online interval coloring problem, Kierstead and Trotter presented a $3$ competitive algorithm (KT-algorithm) and they also proved that their result is tight [1]. The tightness is proved by showing the existence of an adaptive adversary that forces an online algorithm to use $3\omega-2$ colors where $\omega$ is the maximum clique size in the interval graph formed by the given set of intervals. On the other hand, the KT-algorithm uses at most $3\omega-2$ colors.

1.1 Our Results

Our goal is to design incremental and fully-dynamic algorithms for interval coloring. Towards this, we study efficient implementations of the KT-algorithm. The KT-algorithm computes a coloring in which each color is a 2-tuple $(p(v),o(v))$, where $p(v)$ is the level value of $v$ and $o(v)$ is the offset of $v$. In the incremental and fully-dynamic setting, we design efficient 3-approximation algorithms for interval coloring. In the incremental case our results leave open the possibility of improving the number of colors used by sacrificing the constraint in online algorithms that an interval cannot be re-colored. We start by considering the efficiency of a direct implementation of the KT-algorithm. A direct implementation uses a data structure that only maintains the intervals and responds to intersection queries by reporting the intervals which intersect a queried interval. We show the following result in Section 2.2.

Any direct implementation of the KT-algorithm requires $\Omega(\Delta^{2})$ time per interval in the worst case, where $\Delta$ is the maximum degree of a vertex in the associated interval graph. (Theorem 2)

We then show that a comparison based data structure which supports the insertion of a new interval or computes the number of intervals intersecting a given interval requires $\Omega(\log n)$ comparisons for at least one of the operations (Lemma 3). In Section 2.3, our next result is a different approach to compute the level value for an interval. This approach avoids the lower bound for a direct implementation by maintaining additional information associated with the intervals that have been colored. While our approach, called Algorithm $\sf KT\mbox{-}SLS$, uses the same number of colors as the KT-algorithm, we show that the level value for each interval computed by our approach is at most the level value computed by the KT-algorithm ( Lemma 5). We show an example where for an interval the level value computed by Algorithm $\sf KT\mbox{-}SLS$ is smaller than the level value computed by the KT-algorithm. We design an incremental interval coloring algorithm which implements Algorithm $\sf KT\mbox{-}SLS$ in Section 3 and show that it uses at most $3\omega-2$ colors.

There exists an incremental algorithm which supports insertion of an interval in amortized $O(\log n+\Delta)$ time per update, where $n$ is the total number of intervals in the update sequence and $\Delta$ is the maximum degree of a vertex in the interval graph formed by those intervals. (Theorem 7)

In Section 4, in the fully dynamic setting, an interval that has already been colored can be deleted, apart from the insertions. At the end of each update, our aim is to maintain a $3\omega-2$ coloring of the remaining set of intervals, where $\omega$ is the maximum clique in the interval graph associated with the remaining set of intervals. In order to bound the number of colors to $3\omega-2$, deletion of an interval may trigger a change in the colors of some of the remaining intervals creating a set of dirty intervals. Cleaning up of those dirty intervals may in turn create more dirty intervals resulting in a cascading effect. We design an approach to efficiently compute the set of such dirty intervals after a deletion. Thus, we present a fully dynamic algorithm for $3\omega-2$ interval coloring in the fully dynamic setting.

There exists a fully dynamic algorithm which supports insertion of an interval in $O(\log n+\Delta\log\omega)$ update time and deletion of an interval in $O(\Delta^{2}\log n)$ update time in the worst case, where $n$ is the total number of intervals inserted and $\Delta$ is the maximum degree of a vertex in the interval graph formed by those intervals. (Theorem 16)

Our final contribution is motivated by the fact that the KT-algorithm computes the maximum clique size in an induced subgraph of the neighbors of the current interval. In our attempt to design efficient data structures to report the neighborhood of a vertex we encountered a connection to the online boolean matrix vector multiplication problem and the related OMv conjecture, which is due to Henzinger et. al [2]. We present a reduction in Section 5 where we show the following result.

Any algorithm that needs to compute induced subgraph among the neighbors of a given vertex requires at least quadratic time unless online boolean matrix vector multiplication conjecture is false.(Theorem 20)

Finally, we use the well-known interval tree data structure to obtain the following result on online boolean matrix vector multiplication conjecture.

In the online boolean matrix vector multiplication problem, if the boolean matrix and the vectors in the online sequence have consecutive ones property then the OMv conjecture is false. (Theorem 21)

2 Kierstead-Trotter algorithm and Supporting Line Segment

Let the set $\mathcal{I}=\{I_{1},I_{2},\dots,I_{n}\}$ denote a sequence of $n$ intervals, and let $G(\mathcal{I})$ denote the associated interval graph. For $1\leq j\leq n$, let $I_{j}=[l_{j},r_{j}]$ where $l_{j}$ and $r_{j}$ represent the left and right endpoint of $I_{j}$, respectively. Let $\sigma=v_{1},v_{2},v_{3},\dots,v_{n}$ be the ordering of vertices of interval graph $G=G(\mathcal{I})$ where vertex $v_{j}$ is the $j$-th vertex in $\sigma$ and it corresponds to the interval $I_{j}$ in $\mathcal{I}$. Let $\omega(G)$, $\Delta(G)$, and $\chi(G)$ denote the size of the maximum cardinality clique in G, the maximum degree of a vertex in $G$, and the chromatic number of $G$, respectively. It is well-known that for interval graphs $\omega(G)=\chi(G)$. When the graph $G$ is clear, refer to these numbers as $\omega$, $\Delta$, and $\chi$.

2.1 Kierstead-Trotter algorithm - overview

The intervals in the sequence $\mathcal{I}$ are presented to the online KT-algorithm. For $i\geq 0$, let $I_{i}$ be the interval presented and let $v_{i}$ be the corresponding vertex in $\sigma$. The KT-algorithm computes a color based on the color given to the vertices $v_{1},\ldots,v_{i-1}$. The color assigned to a vertex $v$ is a tuple of two values and is denoted as $(p(v),o(v))$. $p(v)$ is called the level value, $o(v)\in\{1,2,3\}$ is called the offset, and $v$ is said to be in level $p(v)$. $p(v)$ is computed in Step I and in Step II $o(v)$ is computed. The key property is that for each edge $\{u,v\}$, the tuple $(p(u),o(u))$ is different from $(p(v),o(v))$.

**Step I: ** For $r\geq 0$, let $G_{r}(v_{i})$ denote the induced subgraph of $G$ on the vertex set $\{v_{j}|v_{j}\in V(G),j<i,p(v_{j})\leq r,(v_{i},v_{j})\in E(G)\}$. Define $p(v_{i})$ = $\min\{r|\omega(G_{r}(v_{i}))\leq r\}$.

**Key Properties maintained by Step I [1]: **

For each vertex $v_{i}$, $p(v_{i})\leq\omega-1$.

• 2.

Property P : The set $\{v|p(v)=0\}$ is an independent set. For each $i$, $1\leq l\leq\omega-1$, the subgraph of $G$ induced on $\{v\mid p(v)=l\}$ has maximum degree at most 2.

**Step II: ** $o(v_{i})$ is chosen to be the smallest value from the set $\{1,2,3\}$ which is different from the offset of each of the at most two neighbors whose level is $p(v_{i})$.

Analysis: Since the vertices with level value [math] form an independent set, the offset for all these vertices is $1$. Therefore, the color for all the vertices in level [math] is $(0,1)$. By Property P, for each level $1\leq l\leq\omega-1$, the maximum degree in the graph induced by vertices in the level $l$ is $2$. Therefore, the algorithm uses at most $3$ colors, $(l,1)$, $(l,2)$, and $(l,3)$, to color the vertices in level $l$. Hence, total number of colors used by the algorithm is at most $1+3(\omega-1)$ = $3\omega-2$.

2.2 Quadratic lower bound for computing the $\omega$ in the graph induced by a subset of neighbors of a vertex

We start by considering implementations of the KT-algorithm in which the data structures are designed only to store the input intervals and support only intersection queries among intervals. We refer to such an implementation as a direct implementation and prove a lower bound on the running time of a direct implementation. This lower bound motivates the additional data structures that are necessary to obtain an implementation of the KT-algorithm with a better running time. We start by observing a lower bound on the time to identify the size of a maximum clique in a given set of intervals.

Lemma 1**.**

A deterministic algorithm which computes the maximum clique size in the interval graph formed by a given set of $n$ intervals has running time $\Omega(n)$.

Proof.

The proof is by contradiction. Let $\mathcal{B}$ be a deterministic algorithm such that on each input consisting of a set of $n$ intervals, it reports the maximum clique size in the corresponding interval graph in $o(n)$ time. Due to this assumption, it follows that algorithm $\mathcal{B}$ does read the entire input on $n$ intervals. Let us consider the execution of $\mathcal{B}$ on interval sequence $\mathcal{I}_{1}=\{[0,x_{1}],[0,x_{2}],\dots,[0,x_{j}],\dots,[0,x_{n}]\}$. Let $1\leq j\leq n$ be the index such that during the execution, $\mathcal{B}$ does not read the $j$-th interval. Consider $\mathcal{I}_{2}$ obtained from $\mathcal{I}_{1}$ by replacing the $j$-th interval by an interval disjoint from all the other $n-1$ intervals. Since the execution of $\mathcal{B}$ does not read the $j$-th interval, the output on both $\mathcal{I}_{1}$ and $\mathcal{I}_{2}$ will both be the same. However, both the outputs cannot be correct since the maximum clique size for $\mathcal{I}_{1}$ is $n$ and for $\mathcal{I}_{2}$ is $n-1$. Therefore, for a deterministic algorithm $\mathcal{B}$ to compute the maximum clique size on all inputs, it must read all the intervals in the input, and thus its running time is $\Omega(n)$. Hence the Lemma. ∎

Using Lemma 1 we prove that a direct implementation of the KT-algorithm will have a $\Omega(\Delta^{2})$ running time.

Theorem 2**.**

A direct implementation of the KT-algorithm has $\Omega(\Delta^{2})$ running time where $\Delta$ is the maximum degree of a vertex in the associated interval graph.

Proof.

For each $i\geq 1$ and $r\geq 0$, to check if $p(v_{i})=r$, the KT-algorithm computes the maximum clique size in the interval graph formed by the intervals with level value at most $r$ and intersecting with the input interval $I_{i}$. From Lemma 1, computing the size of the maximum clique takes $\Omega(\Delta)$ time. The KT-algorithm repeats this computation for the values of $r$ starting from [math] until the value for which $\omega(G_{r}(v_{i}))\leq r$ is true. The worst case is reached for the input sequence $\mathcal{I}_{1}$ in Lemma 1 for which the clique will be computed in the graphs $G_{0}(v_{i}),G_{1}(v_{i}),\ldots,G_{i}(v_{i})$. The running time of a direct implementation on $\mathcal{I}_{1}$ is $\Omega(\omega^{2})$ which is $\Omega(\Delta^{2})$. Therefore, a direct implementation of the KT-algorithm takes $\Omega(\Delta^{2})$ time in the worst case. Hence the Theorem. ∎

While our subsequent results show that we can maintain additional information to circumvent the lower bound faced by a direct implementation, we observe that any comparison based data structure to maintain the given set of intervals and respond to intersection queries uses $\Omega(\log n)$ comparisons.

Lemma 3**.**

Let D be a comparison based data structure which supports the following operations on an interval $[l,r]$:

D.Insert([l, r]): Inserts interval [l, r] into D.

• 2.

D.Query([l, r]): Returns the total number of intervals in D which are intersecting with [l, r].

Let $c_{u}$ be the number of comparisons performed during D.Insert([l, r]) before inserting [l, r]. Let $c_{q}$ be the number of comparisons performed during D.Query([l, r]) before responding to the query. Then either $c_{u}$ or $c_{q}$ is $\Omega(\log n)$.

Proof.

It is possible to use data structure D to design a comparison based sorting algorithm which is defined as follows: Let $x_{1},x_{2},\dots,x_{n}$ be $n$ distinct numbers given as input for comparison sorting. For every $1\leq i\leq n$, perform ${\sf D.Insert([x_{i},x_{i}])}$. A linear search is performed on $x_{1},x_{2},\dots,x_{n}$ to find the minimum denoted by min. Finally, to compute the sorted order, for each $1\leq i\leq n$, perform ${\sf D.Query([min,x_{i}])}$. If query ${\sf D.Query([min,x_{i}])}$ returns $j$, then $x_{i}$ is the $j$-th element in the sorted order. Thus, the total number of comparisons required to find the sorted order is $n\cdot c_{u}$ + $n$ + $n\cdot c_{q}$. It is well-known that any comparison sorting of $n$ numbers performs $\Omega(n\log n)$ comparisons [14]. Therefore, $n\cdot c_{u}$ + $n$ + $n\cdot c_{q}$ is $\Omega(n\log n)$. This implies that either $c_{u}$ = $\Omega(\log n)$ or $c_{q}=\Omega(\log n)$. Hence the Lemma. ∎

The result in Lemma 3 shows that any interval tree based approach which maintains the input intervals and computes intersecting intervals will use $\Omega(\log n)$ comparisons. On the other hand, in Section  2.3 we overcome the lower bound presented in Theorem 2 by maintaining additional information about the coloring computed by the KT-algorithm. This additional information plays a crucial role in an efficient data structure for the KT-algorithm.

2.3 Supporting Line Segment (SLS)-a geometric handle

To overcome the limitation of computing a maximum clique in an induced subgraph, we maintain the size of some cliques, and use the structure of interval graphs to conclude that these cliques indeed represent a maximum clique in the neighborhood of each interval. The algorithm can be seen as an efficient version of the KT-algorithm and we refer to it as $\sf KT\mbox{-}SLS$ (KT-algorithm using supporting line segment).

For each $i\geq 1$, $L(I_{i})\in\{0,1,\dots,\omega-1\}$ and $p(v_{i})$ denote the level value computed by $\sf KT\mbox{-}SLS$ and the KT-algorithm, respectively. Further, for each $i\geq 1$, $o(I_{i})$ and $o(v_{i})$ denote the offset computed by $\sf KT\mbox{-}SLS$ and the KT-algorithm, respectively. Let $t$ be a non-negative real number and $\mathcal{I}_{t}$ be the set of all intervals in $\mathcal{I}$ which contain the point $t$. For the set $\mathcal{I}_{t}$, define the set $levels(\mathcal{I}_{t})=\displaystyle\bigcup_{I\in\mathcal{I}_{t}}\{L(I)\}$ to be the set of levels assigned to intervals in $\mathcal{I}_{t}$. Define $h_{t}$ = $\min(\{y\in\{0,1,\dots,\omega-1\}|y\notin levels(\mathcal{I}_{t})\})$. In other words, $h_{t}$ is the smallest non-negative integer which is not the level value for an interval containing $t$. For $h_{t}\geq 1$, the Supporting Line Segment(SLS) at $t$ is defined to be the set $e_{t}$ = $\{(t,0)\dots(t,h_{t}-1)\}$, and $h_{t}$ is called the height of the SLS $e_{t}$. Note that the set $\mathcal{I}_{t}$ is of size at least $h_{t}$, and there are $h_{t}$ intervals in $\mathcal{I}_{t}$ for which the level values are [math] to $h_{t}-1$.

Algorithm $\sf KT\mbox{-}SLS$: For $i\geq 1$, the color $(L(I_{i}),o(I_{i}))$ for $I_{i}$ is computed as follows:

Step I: For each $t\in I_{i}$, compute the height, $h_{t}$, of the SLS $e_{t}$. Define $L(I_{i})=\displaystyle\max_{t\in I_{i}}h_{t}$.

Key Properties maintained by Step I

• (a)

For each interval $I_{i}$, $L(I_{i})\leq p(v_{i})\leq\omega-1$(Lemma 5).

• (b)

Property P : The set $\{I|L(I)=0\}$ is an independent set. For each $i$, $1\leq i\leq\omega-1$, the subgraph of $G$ induced on $\{I\mid L(I)=i\}$ has maximum degree at most 2 (Lemma 6). 2. 2.

Step II: : Compute $o(I_{i})$ to be the smallest value from the set $\{1,2,3\}$ that is different from the offset of the neighbours of $I_{i}$ which have the level $L(I_{i})$.

Remark: We show an example in Figure LABEL:fig:example, where for interval $I_{6}$, the level value computed by $\sf KT\mbox{-}SLS$ is strictly less than the level value computed by the KT-algorithm. The intervals arrive in the following order : $I_{1}=[1,2],I_{2}=[8,9],I_{3}=[1,7],I_{4}=[3,9],I_{5}=[4,6]$, and $I_{6}=[4,6]$. Intervals $I_{1}$, $I_{2}$, and $I_{5}$ get level value [math]. KT-algorithm computes $p(v_{6})=3$ and $\sf KT\mbox{-}SLS$ computes $L(I_{6})=2$. The portion colored as gray is the overlapping portion between interval $I_{3}$ and interval $I_{4}$.

Correctness of Algorithm $\sf KT\mbox{-}SLS$. We start by proving that the level value computed by Algorithm $\sf KT\mbox{-}SLS$ depends only on the set of endpoints of the intervals. This finite set is denoted by $\mathcal{E}$ and we refer to the points in the set as endpoints.

Lemma 4**.**

For each real number $t$, $\mathcal{E}\cap\displaystyle\bigcap_{I\in\mathcal{I}_{t}}I\neq\emptyset$. Further, there is an endpoint $p\in\mathcal{E}$ such that $h_{p}\geq h_{t}$.

Proof.

If $t$ is an endpoint of an interval, then $t\in\mathcal{E}$ and hence the Lemma is proved. Suppose $t$ is not an endpoint. Let $l_{t}$ denote the largest left endpoint among all the intervals in $\mathcal{I}_{t}$ and $r_{t}$ denote the smallest right endpoint among all the intervals in $\mathcal{I}_{t}$. By definition, $l_{t}\in\mathcal{E}$ and $r_{t}\in\mathcal{E}$. Since $\mathcal{I}_{t}$ is a set of intervals, it follows that $l_{t}$ and $r_{t}$ are present in all the intervals in $\mathcal{I}_{t}$. Further, since both $l_{t}$ and $r_{t}$ are present in each interval in $\mathcal{I}_{t}$, it follows that the set of intervals that contain them is a superset of $\mathcal{I}_{t}$. Therefore, the height of the SLS at $l_{t}$ and $r_{t}$ is at least the height of the SLS at $t$. Hence the Lemma. ∎

From the description in Section 2.1, we know that the level value of $I_{i}$ computed by the KT-algorithm is given by $p(v_{i})$ = $\min\{r|\omega(G_{r}(v_{i}))\leq r\}$. Further in Algorithm $\sf KT\mbox{-}SLS$, $L(I_{i})$ is defined to be the maximum height of the SLS at the endpoints contained in $I_{i}$. We next prove that $L(I_{i})\leq p(v_{i})\leq\omega-1$.

Lemma 5**.**

For each $i\geq 1$, $p(v_{i})$ is at least the maximum height of the SLS at any endpoint contained in the interval $I_{i}$.

Proof.

By definition, $L(I_{i})$ is the maximum height of SLS at any endpoint contained in $I_{i}$. By the definition of the height of an SLS at an endpoint $t$, we know that for each $0\leq r\leq h_{t}-1$ there is an interval $I\in\mathcal{I}_{t}$ such that $L(I)=r$, and all these intervals form a clique of size $h_{t}$. Therefore, it follows that $G_{L(I_{i})}(v_{i})$ has a clique of size at least $L(I_{i})$. Therefore, it follows that $p(v_{i})\geq L(I_{i})$. Hence the Lemma. ∎

We prove in Lemma 6 that the level values computed by Algorithm $\sf KT\mbox{-}SLS$ satisfy Property P.

Lemma 6**.**

Algorithm $\sf KT\mbox{-}SLS$ satisfies Property P and thus uses at most $3\omega-2$ colors.

Proof.

We first prove that the set $\{I|L(I)=0\}$ is an independent set. To show this, we prove that for a pair of intersecting intervals $I$ and $J$, at least one of $L(I)$ or $L(J)$ is more than 0. Without loss of generality, let us assume that the interval $I$ appeared before $J$. If $L(I)>0$, then our claim is correct. We now consider the case when $L(I)=0$. Since $I$ and $J$ intersect, it follows that an endpoint of one of them is contained in the other. Therefore, after $J$ is presented to Algorithm $\sf KT\mbox{-}SLS$, the SLS of one of the endpoints in $I\cup J$ is more than 0. By the definition of $L(J)$ in Algorithm $\sf KT\mbox{-}SLS$, it follows that $L(J)>0$. Therefore, $\{I|L(I)=0\}$ is an independent set. The same argument also shows that if $L(I)=L(J)$, then $I\not\subseteq J$ and $J\not\subseteq I$.

We now prove that the level value computed by Algorithm $\sf KT\mbox{-}SLS$ satisfies Property P. Let $I$ be the first interval during the execution of the algorithm which has at least 3 intersecting intervals in level $l=L(I)$. Let these intervals be $J_{1},J_{2},J_{3}$. Since there cannot be a containment relationship between two intersecting intervals with the same level value, it follows that two intervals contain a common endpoint with $L(I)$. Without loss of generality, let $J_{1}$ and $J_{2}$ contain a common endpoint of $I$. Further, we know by the Helly property for intervals that one of the intervals is contained in the union of the other two [15]. Consequently, one of the 3 intervals contains a point $t$ for which the SLS has height $l+1$. This contradicts the hypothesis that $L(I)=l$. Therefore, our assumption that an interval $I$ has at least 3 neighbours in $L(I)$ is wrong. Consequently, all the intervals with the same level value are assigned an offset from $\{1,2,3\}$. Further, if two intervals with the same level value intersect, then they get different offsets as described in Step II. From Lemma 5, we know that for any interval $I_{i}$, we have $L(I_{i})\leq p(v_{i})$. Therefore, maximum level value of any interval is $\omega-1$. For level [math] we use one color and for every other level we use at most $3$ colors. Therefore, the number of colors used by ALgorithm $\sf KT\mbox{-}SLS$ is $3(\omega-1)+1$ = $3\omega-2$. Hence the Lemma. ∎

In the rest of the paper we design data structures that are useful in an efficient implementation of Algorithm $\sf KT\mbox{-}SLS$ in both the incremental and fully dynamic settings. Apart from data structures to maintain intervals, we also use data structures to maintain supporting line segments. The data structures to maintain the supporting line segments are crucial in overcoming the limitations of a direct implementation of the KT-algorithm. The necessary data structures are described in Section 2.4.

2.4 Dynamic Data Structures for Algorithm $\sf KT\mbox{-}SLS$

In this section, we present the various data structures used to implement $\sf KT\mbox{-}SLS$ in the incremental and fully dynamic setting. For this purpose, we come up with the procedures listed in Table 1. The procedures in the incremental setting differ from their counterparts in the fully dynamic setting on the data structures used to store SLS. The running time of the incremental and the fully dynamic algorithms are governed by the running times of these procedures. Detailed descriptions of the procedures are given in Section 3.1 for incremental setting and in Section 4.4 for fully dynamic setting. Next, we describe the different data structures which are used to implement the procedures in Table 1. Running time of different operations on these data structures are listed in Table 2.

Interval Trees to store intervals and endpoints:

Set of intervals $\mathcal{I}$. The set of intervals $\mathcal{I}$ is maintained as an interval tree. Therefore, $\mathcal{I}$ is an interval tree such that for each $i\geq 1$, interval $I_{i}$ is maintained as its left and right endpoints $l_{i}$ and $r_{i}$. Further, the level value and offset $L(I_{i})$ and $o(I_{i})$ are computed at the time of insertion, and updated as necessary in the fully dynamic case. The index of the update when $I_{i}$ is inserted is also stored and referred as time of insertion whenever necessary. 2. 2.

Set of endpoints $\mathcal{E}$. The set of endpoints of the intervals in $\mathcal{I}$ is stored as an interval tree denoted by $\mathcal{E}$. For every interval $I_{i}$=$[l_{i},r_{i}]$, we maintain the left endpoint and the right endpoint as intervals $[l_{i},l_{i}]$ and $[r_{i},r_{i}]$ respectively in $\mathcal{E}$. 3. 3.

Hash table $T$ points to set of intervals with same level value. For a non-negative integer $h$, $T[h]$ points to the interval tree which maintains the set of intervals with level value $h$.

Data Structures to store supporting line segments: At every endpoint $t\in\mathcal{E}$, the SLS $e_{t}$ and the height, $h_{t}$, of $e_{t}$ is maintained. In the incremental setting, the height of an SLS is non-decreasing with the updates and this need not be true in the fully dynamic case. Thus we have different data structures to represent SLS in the incremental setting and the fully dynamic setting.

**Incremental setting: ** In the incremental setting, the SLS $e_{t}$ is maintained using a dynamic array $A_{t}$. For a level value $l$, $A_{t}[l]$ is defined to be $1$ if there is an interval containing $t$ whose level value is $t$. Otherwise, $A_{t}[l]$ is defined to be [math]. Clearly, the height $h_{t}$ of the supporting line segment $e_{t}$ is the smallest index $l$ such that $A_{t}[l]=0$. To respond to queries for $h_{t}$ efficiently, a doubly linked list $Q_{t}$ and a dynamic array $A^{\prime}_{t}$ are used as follows. The head of the doubly linked list $Q_{t}$ contains the value of $h_{t}$, and following it, the set $\{l\mid A_{t}[l]=0\}$ as a doubly linked list in increasing order of the value of $l$. To maintain $h_{t}$, we define a doubly linked list $Q_{t}$ which stores every index $i$ in $A_{t}$ where $A_{t}[i]$ is [math] in the increasing order of the value of $i$. Note that the value stored at the head node of $Q_{t}$ is $h_{t}$. The dynamic array $A^{\prime}_{t}$ is defined as follows: for each $l\geq 0$, if $A_{t}[l]=1$, then $A^{\prime}_{t}[l]$ stores a pointer to the node in $Q_{t}$ which stores the index $l$; otherwise, $A^{\prime}_{t}[l]=NULL$. Using the dynamic array $A^{\prime}_{t}$, insert, delete, and search operations in $Q_{t}$ can be performed in constant time. Insertion into a dynamic array takes amortized constant time [19]. A query for the value of $h_{t}$ can be answered in constant time by returning the value stored in the head node of $Q_{t}$. 2. 2.

**Fully dynamic setting: ** SLS $e_{t}$ is maintained using two Red-Black trees, $Z_{t}$ and ${NZ}_{t}$. A level value $l$ is stored in ${NZ}_{t}$ if there is an interval in $\mathcal{I}$ which contains $t$ and whose level value is $l$. Otherwise, a level value $l$ is stored in $Z_{t}$. To compute the height $h_{t}$, we do the following: if $Z_{t}$ is non-empty, then the minimum value in $Z_{t}$ is the required height $h_{t}$. If $Z_{t}$ is empty, then $h_{t}$ is one more than the maximum value in ${NZ}_{t}$. The number of nodes in the trees $Z_{t}$ and ${NZ}_{t}$ is at most $\omega$. Therefore, the time required to compute $h_{t}$ is $O(\log\omega)$.

3 Incremental Interval Coloring using Algorithm $\sf KT\mbox{-}SLS$

We present the incremental algorithm $\sf handle\mbox{-}Insert$ which is an implementation of Algorithm $\sf KT\mbox{-}SLS$. The pseudo code of $\sf handle\mbox{-}Insert$ is presented in Algorithm 1 along with the corresponding steps. The procedures used in $\sf handle\mbox{-}Insert$ described in Section 3.1. The amortized update time of $\sf handle\mbox{-}Insert$ is given by the Theorem 7.

**Computing $L(I_{i})$:

Step 1**: Insert $I_{i}$ into the set of intervals $\mathcal{I}$ (Line 1 in Algorithm 1). Check if the endpoint $l_{i}$ is already present in the set of endpoints $\mathcal{E}$ (Line 4 in Algorithm 1). If not, then compute the SLS at endpoint $l_{i}$ (Line 5 in Algorithm 1) and insert $l_{i}$ into the set $\mathcal{E}$ (Line 6 in Algorithm 1). Repeat for endpoint $r_{i}$ (Line 8-11 in Algorithm 1).

Step 2: Compute the set $S=\mathcal{E}\cap I_{i}$. For each $t\in S$, compute $h_{t}$, the height of the SLS $e_{t}$ at $t$. Assign $L(v_{i})=\displaystyle\max_{t\in S}h_{t}$ (Line 12-13 in Algorithm 1).

Step 3: Update the SLS $e_{t}$ for each point $t\in S$ (Line 14 in Algorithm 1).

Computing $o(I_{i})$: Compute $o(I_{i})$ to be the smallest value from the set $\{1,2,3\}$ which is different from the offset of the neighbours of $I_{i}$ which have the level $L(I_{i})$ (Line 15 in Algorithm 1).

      

Algorithm 1 $\sf handle\mbox{-}Insert$($I_{i}=[l_{i},r_{i}]$) is used to handle insertion of interval $I_{i}$

1:$\mathcal{I}$.insert($I_{i}$)

2:$I_{i}^{l}\leftarrow$ $[l_{i},l_{i}]$

3:$I_{i}^{r}\leftarrow$ $[r_{i},r_{i}]$

4:if ($\mid\mathcal{E}$.intersection($I_{i}^{l})\mid$ = [math]) then

5:     $A_{l_{i}},Q_{l_{i}}\leftarrow$ $\sf compute\mbox{-}SLS$($\mathcal{I}$,$l_{i}$)

6:     $\mathcal{E}$.insert($I_{i}^{l}$)

7:end if

8:if ($\mid\mathcal{E}$.intersection($I_{i}^{r})\mid$ = [math]) then

9:     $A_{r_{i}},Q_{r_{i}}\leftarrow$ $\sf compute\mbox{-}SLS$($\mathcal{I}$,$r_{i}$)

10:     $\mathcal{E}$.insert($I_{i}^{r}$)

11:end if

12:$S,h\leftarrow$ $\sf compute\mbox{-}max\mbox{-}SLS$($\mathcal{E}$,$I_{i}$)

13:$L(I_{i})\leftarrow h$

14:$\sf update\mbox{-}Endpoints$($S,L(I_{i})$)

15:$\sf compute\mbox{-}Offset$($I_{i}$)

Theorem 7**.**

$\sf handle\mbox{-}Insert$* is an incremental algorithm which supports insertion of a sequence of $n$ intervals in amortized $O(\log n+\Delta)$ time per update.*

Proof.

We analyze the running time for computing $L(I_{i})$ and $o(I_{i})$.

Analysis for computing $L(I_{i})$: Computing $L(I_{i})$ involves $3$ steps.

Step 1 in computing $L(I_{i})$ takes $O(\log n+\omega)$ time: Insertion of $I_{i}$ = $[l_{i},r_{i}]$ into $\mathcal{I}$ takes $O(\log n)$ time. Let $I_{i}^{l}$ = $[l_{i},l_{i}]$. Checking if $I_{i}^{l}$ is present in $\mathcal{E}$ by an intersection query takes $O(\log n)$ time in the worst case. If $I_{i}^{l}$ is in $\mathcal{E}$, then no further processing is done. On the other hand, if $I_{i}^{l}$ is not in $\mathcal{E}$ then procedure $\sf compute\mbox{-}SLS$($\mathcal{I},l_{i}$) is invoked. From Lemma 9, procedure $\sf compute\mbox{-}SLS$ takes $O(\log n+\omega)$ time. The same steps are repeated for $I_{i}^{r}$ = $[r_{i},r_{i}]$. Hence Step 1 in computing $L(I_{i})$ for interval $I_{i}$ takes $O(\log n+\omega)$ time. 2. 2.

Step 2 in computing $L(I_{i})$ takes $O(\log n+\Delta)$ time: Procedure \sf compute\mbox{-}max\mbox{-}SLS$$(\mathcal{E},I_{i}) is invoked to perform this step. From Lemma 10, procedure $\sf compute\mbox{-}max\mbox{-}SLS$(Algorithm 4) takes $O(\log n+\Delta)$ time. Hence Step 2 in computing $L(I_{i})$ for interval $I_{i}$ takes $O(\log n+\Delta)$ time. 3. 3.

Step $3$ in computing $L(I_{i})$ takes amortized $O(\Delta)$ time: Procedure \sf update\mbox{-}Endpoints$$(S,L(I_{i})) is invoked to perform this step. From Lemma 11, procedure $\sf update\mbox{-}Endpoints$(Algorithm 5) takes amortized $O(\Delta)$ time. Hence Step $3$ in computing $L(I_{i})$ for interval $I_{i}$ takes amortized $O(\Delta)$ time.

Analysis for computing $o(I_{i})$: To compute the offset value of interval $I_{i}$ with level value $L(I_{i})$, procedure \sf compute\mbox{-}Offset$$(I_{i}) is invoked. From Lemma 8, procedure \sf compute\mbox{-}Offset$$(I_{i}) takes $O(\log n)$ time.

Therefore, total time taken by $\sf handle\mbox{-}Insert$ for insertion of $n$ intervals is the total time taken for Step 1, Step 2, Step 3, and the total time spent in computing the offset. For interval graphs, it is well known that $\omega=\chi\leq\Delta+1$. Thus the running time is $O(n\log n+n\Delta)$. Therefore, the amortized update time over a sequence of $n$ interval insertions is $O(\log n+\Delta)$. Hence the Theorem. ∎

3.1 Procedures used in $\sf handle\mbox{-}Insert$

The data structures used in designing these procedures are listed in Table 2.

Lemma 8**.**

Procedure $\sf compute\mbox{-}Offset$ takes as input interval $I$, computes the offset value for interval $I$ and takes $O(\log n)$ time in the worst case.

Proof.

Hash table $T$ is used to access the interval tree $T[L(I)]$. If $T[L(I)]$ is NULL, then an interval tree $T[L(I)]$ is created with $I$ as the first interval (Line 2-3 in Algorithm 2). Otherwise, $T[L(I)]$ is the interval tree which stores all the intervals with level value same as $L(I)$. An intersection query is performed on $T[L(I)]$ with $I$ to obtain all the intervals that intersect with $I$ (Line 5 in Algorithm 2). From Property P, the maximum number of intervals returned by the above query is $2$. The offset value of interval $I$, $o(I)$, is set to be the smallest value from $\{1,2,3\}$ not assigned to any of the at most two neighbors of $I$ in level $L(I)$ (Line 6 in Algorithm 2). Interval $I$ is inserted to $T[L(I)]$ (Line 7 in Algorithm 2).

Running time of $\sf compute\mbox{-}Offset$ is dominated by intersection query in Line 5 and insertion of interval $I$ in Line 7. Since $|\mathcal{I}|\leq n$, worst case running time of $\sf compute\mbox{-}Offset$ is $O(\log n)$. Hence the Lemma. ∎

Lemma 9**.**

Procedure $\sf compute\mbox{-}SLS$ takes set of intervals $\mathcal{I}$ and endpoint $t$ as input, maintains SLS at $t$ using dynamic array $A_{t}$ and doubly linked list $Q_{t}$, and takes $O(\log n+\omega)$ time in the worst case.

Proof.

$\sf compute\mbox{-}SLS$ performs an intersection query on $\mathcal{I}$ with interval $[t,t]$ (Line 2 in Algorithm 3). Let $\mathcal{I}_{t}$ denote the set returned by the intersection query. Maximum height $h_{t}$ = $\max(levels(\mathcal{I}_{t}))$ and the set $U$ = $levels(\mathcal{I}_{t})$ are computed (Line 7-9 in Algorithm 3). For every $i$ in the range $[0,h_{t}]$, $A_{t}[i]$ is set to [math] and $i$ is inserted to $Q_{t}$ (Line 11-13 in Algorithm 3). For every $i$ in the range $[0,h_{t}]$, $A_{t}[i]$ is reset to $1$ if $i\in levels(\mathcal{I}_{t})$ and $i$ is deleted from $Q_{t}$ (Line 15-17 in Algorithm 3). It returns $A_{t}$ and $Q_{t}$.

Running time of $\sf compute\mbox{-}SLS$ is dominated by the intersection query in Line 2, loop in Line 7-9, loop in Line 11-13, and loop in Line 15-17. At any level, SLS ${e_{t}}$ intersects with at most $2$ intervals and we have $\omega$ many levels. Hence, $|\mathcal{I}_{t}|$ = $O(\omega)$, $h_{t}\leq\omega+1$, and $|U|\leq\omega$. Again, $|\mathcal{I}|\leq n$. Therefore, time taken by procedure $\sf compute\mbox{-}SLS$ in the worst case is $O(\log n+\omega)$. Hence the Lemma. ∎

Lemma 10**.**

Procedure $\sf compute\mbox{-}max\mbox{-}SLS$ takes set of endpoints $\mathcal{E}$ and interval $I$ as input, computes the set of endpoints $S$ contained in $I$ and maximum among the height of the SLS at the endpoints in $S$, and takes $O(\log n+\Delta)$ time in the worst case.

Proof.

Procedure $\sf compute\mbox{-}max\mbox{-}SLS$ performs an intersection query of $I$ on $\mathcal{E}$ (Line 2 in Algorithm 4). This query returns the set $S$ of all the endpoints which intersect with $I$. It computes the maximum among the height of the SLS at endpoints in $S$, denoted by $h$ (Line 4-11). The procedure returns $h$ and the set $S$.

Running time of $\sf compute\mbox{-}max\mbox{-}SLS$ is dominated by intersection query in Line 2 and loop from Line 4-11. Since $\Delta$ is the maximum degree in the associated interval graph, interval $I$ can intersect with at most $\Delta$ intervals. Therefore, $|S|$ = $O(\Delta)$. Further, $|\mathcal{E}|\leq 2n$. Thus the worst case time taken by $\sf compute\mbox{-}max\mbox{-}SLS$ is $O(\log n+\Delta)$. Hence the Lemma. ∎

The different procedures used in $\sf handle\mbox{-}Insert$ are described and analyzed below.

**Procedure \sf update\mbox{-}Endpoints$$(S,L(I)): ** This procedure, described in Algorithm 5, is used to update the SLS at the endpoints contained in set $S$: let $l=L(I)$. For every endpoint $t\in S$, size of $A_{t}$ is checked.

Case A: If $l<{A_{t}}$.size(). In this case, $A_{t}[l]$ is set to $1$. The pointer stored in $A^{\prime}_{t}[l]$ is used to delete the node in $Q_{t}$ which stores the value $l$ and $A^{\prime}_{t}[l]$ is set to NULL subsequently. If the deleted node in $Q_{t}$ was the head node, then the head node is updated to the next node in $Q_{t}$ and thus the value of $h_{t}$ also gets updated. 2. 2.

Case B: If $l\geq{A_{t}}$.size(). In this case, the standard doubling technique for expansion of dynamic arrays [19] is used to increase the size of $A_{t}$ until ${A_{t}}$.size() becomes strictly greater than $l$. $A^{\prime}_{t}$ is also expanded along with $A_{t}$ and appropriate nodes are inserted to $Q_{t}$. Once ${A_{t}}$.size() $>l$, the remaining operations are same as in the case A.

Lemma 11**.**

Procedure $\sf update\mbox{-}Endpoints$ takes $O(\Delta)$ amortized time.

Proof.

For every endpoint $t\in S$, size of $A_{t}$ is checked in constant time. To analyze the time required in $\sf update\mbox{-}Endpoints$, we observe that every update must perform the operations as described in case A. We refer to these operations as task M(M stands for mandatory). Some updates have to perform additional operations as described in case B. We refer to these operations as task A(A stands for additional). The time taken by each update to perform task M is $|S|\times O(1)=O(|S|)$. Since $\Delta$ is the maximum degree, it follows that $|S|\leq\Delta$. Therefore, every update takes $O(\Delta)$ time to perform task M in the worst case. To analyze the time required to perform task A, we crucially use the fact that our algorithm is incremental and hence only expansions of the dynamic arrays take place. Since $\omega$ is the size of the maximum clique, it follows that the maximum size of a dynamic array throughout the entire execution of the algorithm is upper bounded by $2\omega$. Over a sequence of $n$ insertions, the total number of endpoints is upper bounded by $2n$. Therefore, we maintain at most $4n$ dynamic arrays. For every such array, total number of inserts in the array and the associated doubly linked list is at most $2\omega$ in the entire run of the algorithm. An insertion into the dynamic array takes constant amortized time and insertion into doubly linked list takes constant worst case time. Therefore, during the entire run of the algorithm total time required to perform task A on one dynamic array and its associated doubly linked list is $O(\omega)$. This implies that during the entire run of the algorithm total time spent on task A over all the updates is $\leq 4n\times O(\omega)$. Let ${\sf T}$ be the total time spent on $\sf update\mbox{-}Endpoints$ at the end of $n$ insertions. This is the sum of the total time for task A and the total time for task M. Further, since $\omega\leq\Delta+1$, it follows that ${\sf T}=O(n\Delta)$. Hence the Lemma. ∎

4 Fully dynamic interval coloring

An update in the update sequence in the fully dynamic setting consists of an interval to be colored or a previously colored interval to be deleted. The $i$-th update is Insert$(I_{i})$ where $I_{i}$ is the interval presented to the algorithm. The update Delete$(I_{i})$ is to delete the interval $I_{i}$ that was inserted during the $i$-th update. At the end of each update, the invariants are maintained such that it follows that the intervals are colored with at most $3\omega-2$ colors, where $\omega$ is the size of the maximum clique in the interval graph just after the update. For an insert update, we use $\sf handle\mbox{-}Insert$ (Algorithm 1) to ensure that the invariants are maintained at the end of the update. However, to get a good bound on the update time, we use a different set of data structures to maintain SLS (see Section 2.4). Therefore, the major result in this section is to handle the delete of a previously colored interval. There are two aspects in the algorithm: the first one is to ensure that the invariants are maintained after a delete, and the second one is to ensure that the update is efficient.

4.1 Algorithm $\sf handle\mbox{-}Delete$ for Delete$(I_{i})$

Let $(L(I_{i}),o(I_{i}))$ be the color of $I_{i}$ at the beginning of the update. The pseudo code and steps of Algorithm $\sf handle\mbox{-}Delete$ are presented in Algorithm 6.

Step 1: Remove interval $I_{i}$ from the set of intervals $\mathcal{I}$ and hash table $T[L(I_{i})]$.(Line 1 and Line 2 in Algorithm 6)

Step 2: Compute the set of endpoints contained in $I_{i}$. Let $\mathcal{E}_{i}$ = $\mathcal{E}\cap I_{i}$. (Line 3 in Algorithm 6)

Step 3: For each endpoint $t\in\mathcal{E}_{i}$, update SLS $e_{t}$ to reflect the deletion of interval $I_{i}$. (Line 4 to 8 in Algorithm 6)

Step 4: Compute the set of intervals intersecting with $I_{i}$ and with level value strictly greater than $L(I_{i})$. Let $\sf DIRTY$ = $\{I|L(I)>L(I_{i}),I_{i}\cap I\neq\phi\}$ (Line 10 in Algorithm 6). Sort $\sf DIRTY$ in the increasing order of level value and break the ties in the increasing order of time of insertion. For every interval $I$ in $\sf DIRTY$, repeat the following steps:

Compute the set of endpoints intersecting with $I$. Let $S$ = $\mathcal{E}\cap I$. For every endpoint $t\in S$ compute the height $h_{t}$ of the SLS $e_{t}$. Compute $h$ = $\max\{h_{t}|t\in S\}$ (Line 11 in Algorithm 6).

If $h\geq L(I)$ then no further processing is required for interval $I$.

If $h<L(I)$ then following steps are executed (Line 17 to 25 in Algorithm 6):

(a)

Change level value of $I$ from $L(I)$ to $h$.

(b)

Recompute the offset value $o(I)$ for $I$ with the new level value $h$.

(c)

Update SLS $e_{t}$ for every point $t\in S$ to reflect the change in level value of $I$.

      

Algorithm 6 $\sf handle\mbox{-}Delete$($I_{i}=[l_{i},r_{i}]$) is used to handle deletion of interval $I_{i}$

1:$T[L(I_{i})].$delete$(I_{i})$

2:$\mathcal{I}$.delete($I_{i}$)

3:$\mathcal{E}_{i}\leftarrow\mathcal{E}$.intersection($I_{i}$)

4:for $t$ in $\mathcal{E}_{i}$ do

5:     if $\mid T[L(I_{i})]$.intersection($t)\mid$ $=0$ then

6:         ${NZ}_{t}$.delete($L(I_{i})$

7:         $Z_{t}$.insert($L(I_{i})$)

8:     end if

9:end for

10:Compute $\sf DIRTY\leftarrow\{I|L(I)>L(I_{i}),I_{i}\cap I\neq\phi\}$. Sort $\sf DIRTY$ in the increasing order of level value and break the ties in the increasing order of time of insertion.

11:for $I$ in $\sf DIRTY$ do

12:     $S,h\leftarrow$ $\sf compute\mbox{-}max\mbox{-}SLS$($\mathcal{E}$,$I$)

13:     if $h\geq L(I)$ then

14:         continue

15:     end if

16:     $T[L(I)].$delete($I$)

17:     $T[h].$insert($I$)

18:     for $t$ in $S$ do

19:         if $\mid T[L(I)]$.intersection($t)\mid$ $=0$ then

20:              ${NZ}_{t}$.delete($L(I)$

21:              $Z_{t}$.insert($L(I)$)

22:         end if

23:         ${NZ}_{t}$.insert($h$)

24:         $Z_{t}$.delete($h$)

25:     end for

26:     $L(I)\leftarrow h$

27:     $\sf compute\mbox{-}Offset$($I$)

28:end for

4.2 Correctness of $\sf handle\mbox{-}Delete$

The first crucial property maintained by Algorithm $\sf handle\mbox{-}Delete$ is that at the end of the update, for each interval $I$, there exists a point $t$ in $I$ such that the height of the SLS at $t$ is at least $L(I)$. We refer to this property as Invariant C. The second crucial property maintained is property P. The following lemma proves a bound on the number of colors used.

Lemma 12**.**

At the end of each update, the number of colors used is at most $3\omega-2$, where $\omega$ is the size of the maximum clique in the interval graph just after the update.

Proof.

We start by assuming that prior to the update the invariant C and Property P is satisfied by the coloring. We show that after the update they continue to be satisfied. For update Insert$(I_{i})$ invariant C and Property P are satisfied by the coloring at the end of the update. This follows from Lemma 5 which shows that invariant C is maintained by Algorithm $\sf handle\mbox{-}Insert$ and Lemma 6 which proves that Algorithm $\sf handle\mbox{-}Insert$ maintains Property P.

For update Delete$(I_{i})$ we know from Lemma 13 that the set $\sf DIRTY$ consists of those intervals whose level values are changed by Algorithm $\sf handle\mbox{-}Delete$ to ensure that invariant C is maintained. Algorithm $\sf handle\mbox{-}Delete$ iterates over each interval $I$ in $\sf DIRTY$ and ensures, by modifying $L(I)$ if necessary, that there is a point $t\in I$ such that $h_{t}\geq L(I)$. Whenever $L(I)$ is modified, it is modified to be the maximum $h_{t}$, over all $t\in I$. This choice of $L(I)$ also ensures that $I$ has at most two neighbors in the level $L(I)$ and none of the neighbors with level number $L(I)$ has a containment relationship with $I$. The proof uses the same argument in Lemma 6. Thus Property P is maintained by Algorithm $\sf handle\mbox{-}Delete$.

Therefore, it follows that after the update, Property ${\bf P}$ is satisfied by the level values of the intervals and from invariant C it follows that the largest level value of any interval is at most $\omega-1$. Further, the intervals whose level values are [math] form an independent set. Therefore, the number of colors used by the algorithm at the end of an update is $3\omega-2$. Consequently, the algorithm uses at most $3\omega-2$ colors after each update step. Hence the Lemma. ∎

We now prove that on the update Delete$(I_{i})$, it is sufficient for Algorithm $\sf handle\mbox{-}Delete$ to consider the set $\sf DIRTY$ which is defined to be $\sf DIRTY$ = $\{I|L(I)>L(I_{i}),I_{i}\cap I\neq\phi\}$. On update Delete$(I_{i})$, an interval is called dirty if during execution of Algorithm $\sf handle\mbox{-}Delete$ invariant C is violated for that interval. An interval which is not dirty during the execution of Algorithm $\sf handle\mbox{-}Delete$ is called clean. In Lemma 13, we show that $\sf DIRTY$ is a super set of all such intervals which become dirty.

Lemma 13**.**

During the execution of Algorithm $\sf handle\mbox{-}Delete$ on the update Delete$(I_{i})$, if an interval $I$ becomes dirty, then $I\in\sf DIRTY$.

Proof.

On deletion of $I_{i}$, the supporting line segments are naturally classified into two sets: those whose height reduces and those whose height does not reduce. Let $t$ be a point for which the height does not reduce. First we consider an interval $I$ which contains $t$, $h_{t}\geq L(I)$, and $L(I)\leq L(I_{i})$, and show that $I$ does not become dirty during the execution of Algorithm $\sf handle\mbox{-}Delete$. This is because, during the execution of the algorithm, only intervals with level value greater than $L(I_{i})$ are considered for a reduction in level value. Therefore, the height of $t$ will remain at least $L(I)$ throughout the execution of the algorithm. Therefore, $I$ does not become dirty during the execution of Algorithm $\sf handle\mbox{-}Delete$.

Next, let us consider an interval $I$ which contains $t$, $h_{t}\geq L(I)$, and $L(I)>L(I_{i})$. The algorithm considers the intervals $I^{\prime}\in\sf DIRTY$ in increasing order of level number. Thus, it follows that the level value of an interval $I^{\prime}$ which contains $t$ and for which $L(I^{\prime})\leq L(I)$ will not reduce during the execution of Algorithm $\sf handle\mbox{-}Delete$. Therefore, the height of the SLS at $t$ does not change throughout the execution of Algorithm $\sf handle\mbox{-}Delete$, and thus $I$ does not become dirty during the execution of Algorithm $\sf handle\mbox{-}Delete$. Therefore, an interval $I$ which becomes dirty during the execution of Algorithm $\sf handle\mbox{-}Delete$ must contain a $t$ whose height reduces on the deletion of $I_{i}$. Thus, $I$ intersects with $I_{i}$ at $t$, and as we have proved above, $I$ must have level value more than $L(I_{i})$. In other words it must be an element of $\sf DIRTY$. Hence the Lemma. ∎

4.3 Worst-case analysis of runtime of $\sf handle\mbox{-}Delete$ and $\sf handle\mbox{-}Insert$

Lemma 14**.**

Algorithm 6 implements $\sf handle\mbox{-}Delete$ in $O(\Delta^{2}\log n)$ time.

Proof.

It is clear from the description that Algorithm 6 implements each of the steps of $\sf handle\mbox{-}Delete$. The most expensive steps in Algorihtm 6 are the computation and sorting of $\sf DIRTY$, and updating the level values of the intervals in $\sf DIRTY$, if necessary, in lines 11-28. $\sf DIRTY$ is computed by an intersection query to the interval tree $\mathcal{E}$ and the worst-case running time is $O(\log n+\Delta)$, where $\Delta$ is the number of endpoints in $\mathcal{E}$ which is the number of intervals intersecting with $I_{i}$. Subsequently, sorting $\sf DIRTY$ takes time $O(\Delta\log\Delta)$ time. Each iteration in lines 11-28 is for an interval $I\in\sf DIRTY$, and the running time of an iteration is dominated by the iteration in lines 18-25. The number of times lines 18-25 is executed is $O(\Delta)$ which the number of endpoints in $S$, where $S$ is $\mathcal{E}\cap I$. In each of these iterations, the Red-Black trees are updated to reflect the height of the corresponding supporting line segment, and this takes $O(\log n)$ time, using the fact that the number of values in each Red-Black tree is at most $\omega$. Thus the running time of Algorithm 6 is $O(\Delta^{2}\log n)$. Hence the Lemma. ∎

We next analyze $\sf handle\mbox{-}Insert$ which is implemented by Algorithm  1 in the fully-dynamic setting by representing supporting line segments as Red-Black trees. Recall that in the incremental case they were represented by dynamic arrays and a doubly linked list.

Lemma 15**.**

Algorithm 1 with supporting line segments represented as Red-Black trees implement $\sf handle\mbox{-}Insert$ in the fully-dynamic setting. Algorithm 1 inserts an interval in worst case $O(\log n+\Delta\log\omega)$ time.

Proof.

In Lemma 17, Lemma 18, and Lemma 19, respectively, we prove that in the fully-dynamic setting, with SLS represented as Red-Black trees, $\sf compute\mbox{-}SLS$, $\sf compute\mbox{-}max\mbox{-}SLS$, and $\sf update\mbox{-}Endpoints$ correctly implement Step 1, Step 2, and Step 3, of $\sf handle\mbox{-}Insert$ correctly. Therefore, it follows that $\sf handle\mbox{-}Insert$ is implemented by Algorithm  1 correctly. Further, these Lemmas also show that the worst-case running times of these functions is $O(\log n+\omega\log\omega)$, $O(\log n+\Delta\log\omega)$, $O(\Delta\log\omega)$, respectively. Therefore, the worst-case running time, of $\sf handle\mbox{-}Insert$ implemented by Algorithm 1, with SLS represented as Red-Black trees, is $O(\log n+\Delta\log\omega)$. Hence the Lemma. ∎

Our fully-dynamic algorithm for interval coloring follows by combining Lemma 14 and Lemma 15.

Theorem 16**.**

There exists a fully dynamic algorithm which supports insertion of an interval in $O(\log n+\Delta\log\omega)$ and deletion of an interval in $O(\Delta^{2}\log n)$ worst case time.

4.4 Procedures used in $\sf handle\mbox{-}Delete$ and $\sf handle\mbox{-}Insert$

The procedures $\sf compute\mbox{-}SLS$, $\sf compute\mbox{-}max\mbox{-}SLS$, and $\sf update\mbox{-}Endpoints$ which are defined in Section 3.1 are defined in this section with Red-Black trees used to represent supporting line segments. The worst-case running time of these procedures differ from their running times in Section 3.1. The data structures used in designing these procedures are listed in Table 2.

Lemma 17**.**

Procedure $\sf compute\mbox{-}SLS$ takes as input the set of intervals $\mathcal{I}$ and endpoint $t$, maintains SLS at $t$ as Red-Black trees $Z_{t}$ and ${NZ}_{t}$, and takes $O(\log n+\omega\log\omega)$ time in the worst case.

Proof.

$\sf compute\mbox{-}SLS$ performs an intersection query on $\mathcal{I}$ with $[t,t]$ (Line 2 in Algorithm 7). The query returns all the intervals in $\mathcal{I}$ which contain endpoint $t$. Let $\mathcal{I}_{t}$ denote the set returned by the intersection query. Set $U$ = $levels(\mathcal{I}_{t})$ and height $h_{t}$ = $\max(levels(\mathcal{I}_{t}))$ are computed (Line 5-8 in Algorithm 7). For every $i$ in the range $[0,h_{t}]$, $i$ is inserted to $Z_{t}$ (Line 11-13 in Algorithm 7). For every $i$ in the set $U$, $i$ is deleted from $Z_{t}$ and inserted to ${NZ}_{t}$ (Line 14-17 in Algorithm 7). $\sf compute\mbox{-}SLS$ returns $Z_{t}$ and ${NZ}_{t}$.

Running time of $\sf compute\mbox{-}SLS$ is dominated by the intersection query in Line 2, and loops in Line 11-13 and Line 14-17. At any level, SLS ${e_{t}}$ intersects with at most $2$ intervals and we have $\omega$ many levels. Hence, $|\mathcal{I}_{t}|$ = $O(\omega)$. Again, $|\mathcal{I}|\leq n$. Therefore, intersection query takes $O(\log n+\omega)$. Further, a single insertion in $Z_{t}$ and ${NZ}_{t}$ takes $O(\log\omega)$ time. Therefore, total time taken by the loops is $O(\omega\log\omega)$. This implies that the worst case time taken by $\sf compute\mbox{-}SLS$ is $O(\log n+\omega\log\omega)$. Hence the Lemma. ∎

Lemma 18**.**

Procedure $\sf compute\mbox{-}max\mbox{-}SLS$ takes as input set of endpoints $\mathcal{E}$ and interval $I$, computes the maximum height of SLS contained in interval $I$, and takes $O(\log n+\Delta\log\omega)$ time in the worst case.

Proof.

$\sf compute\mbox{-}max\mbox{-}SLS$ works as follows (Algorithm 8): an intersection query is performed on $\mathcal{E}$ with $I$ (Line 2). Let $S$ be the set returned by the intersection query. For every endpoint $t\in S$, to compute the height $h_{t}$ of SLS $e_{t}$, the following steps are used: If $Z_{t}$ is non empty then the minimum value in $Z_{t}$ is assigned to $h_{t}$ (Line 10). Otherwise, $h_{t}$ is assigned a value which is one more than the maximum value in ${NZ}_{t}$ (Line 8). The maximum value of the height of an SLS at any endpoint in $S$ is computed as $h$ = $\max\{h_{t}|t\in S\}$ (Line 12). The procedure returns the set $S$ and value $h$.

Running time of $\sf compute\mbox{-}max\mbox{-}SLS$ is dominated by the intersection query in Line 2 and the loop in Line 4-13. We know that $|S|\leq\Delta$ and $|\mathcal{E}|\leq 2n$. Therefore, worst case time taken by $\sf compute\mbox{-}max\mbox{-}SLS$ is $O(\log n+\Delta\log\omega)$. Hence the Lemma. ∎

Lemma 19**.**

Procedure $\sf update\mbox{-}Endpoints$ takes set of endpoints $S$ and $L(I)$ as input, update the SLS at the endpoints contained in set $S$ and takes $O(\Delta\log\omega)$ time in the worst case.

Proof.

The procedure works as follows (Algorithm 9): for every $t\in S$, $L(I)$ is deleted from $Z_{t}$ and $L(I)$ is inserted to ${NZ}_{t}$. For one SLS $e_{t}$ it takes $O(\log\omega)$ time and $|S|\leq\Delta$. Therefore, worst case time taken by $\sf update\mbox{-}Endpoints$ is $O(\Delta\log\omega)$. Hence the Lemma. ∎

Procedure \sf compute\mbox{-}Offset$$(I): This procedure is same as the one described in Section 3.1.

5 Quadratic lower bound for induced neighborhood subgraph computation

In Section 2.2 we showed that a direct implementation of the KT-algorithm will not run in sub-quadratic time. From Section 2.1 the crucial step is to compute maximum clique in an induced subgraph of the neighborhood of the interval inserted during an update. In this section we explore an interesting connection between computing the induced subgraph of the neighborhood of a vertex in a graph and the well-known OMv conjecture due to Henzinger et al., [2]. Formally, we define the following problem:

**Induced Neighborhood Subgraph Computation: ** The input to the Induced Neighborhood Subgraph Computation problem consists of the adjacency matrix $M$ of a directed graph and a set $S$ of vertices. The goal is to compute the graph induced by $N_{out}(S)\cup S$ and output the subgraph as adjacency lists. Here $N_{out}(S)$ is the set of those vertices which have a directed edge from some vertex in $S$. In other words, there is a directed edge from $v_{j}$ to $v_{k}$ iff the entry $M[k][j]$ is $1$.

We show that Induced Neighborhood Subgraph Computation problem is at least as hard as the following problem.

Online Boolean Matrix-Vector Multiplication (OMv)[2]: The input for this online problem consists of an $n\times n$ matrix $M$, and a sequence of $n$ boolean column vectors $v_{1},\ldots,v_{n}$, presented one after another to the algorithm. For each $1\leq i\leq n-1$, the online algorithm should output $M\cdot v_{i}$ before $v_{i+1}$ is presented to the algorithm. Note that in this product, a multiplication is an AND operation and the addition is an OR operation.

The current best algorithm for the OMv problem has an expected running time of $O(\frac{n^{3}}{2^{\sqrt{\log n}}})$ [21]. The following conjecture, due to Henzinger et al., [2], is well known about the OMv problem.

**OMv conjecture: ** The Online Boolean Matrix-Vector Multiplication (OMv) problem does not have a $O(n^{3-\epsilon})$ algorithm for any $\epsilon>0$.

In Theorem 20 we reduce OMv problem to Induced Neighborhood Subgraph Computation problem. As a conseuqence of our reduction an efficient algorithm for Induced Neighborhood Subgraph Computation problem implies an efficient algorithm for the OMv problem.

Theorem 20**.**

Any algorithm for Induced Neighborhood Subgraph Computation problem needs at least quadratic time unless OMv conjecture is false.

Proof.

We show that an algorithm to solve the Induced Neighborhood Subgraph Computation problem can be used to solve the Online Boolean Matrix-Vector Multiplication problem. Let $\mathcal{A}$ be an algorithm for the Induced Neighborhood Subgraph Computation problem with the running time of $\mathcal{A}$ being $O(n^{2-\epsilon})$, for some $\epsilon>0$. We use algorithm $\mathcal{A}$ to solve the Online Boolean Matrix-Vector Multiplication problem in $O(n^{3-\epsilon})$ time as follows : Let $M$ be the input matrix for the Online Boolean Matrix-Vector Multiplication problem and let $V_{1},\ldots V_{n}$ be the column vectors presented to the algorithm one after the other. For the column vector $V_{i}$, let set $S_{i}=\{v_{j}|V_{i}[j]=1,0\leq j\leq n-1\}$. To compute $M\cdot V_{i}$, we invoke $\mathcal{A}$ on input $\{M,S_{i}\}$. Let $G_{S_{i}}$ denote the induced subgraph on $N_{out}(S_{i})\cup S_{i}\subseteq V$ computed by the algorithm $\mathcal{A}$. Note that $G_{S_{i}}$ is an induced subgraph of the directed graph whose adjacency matrix is $M$. To output the column vector $M\cdot V_{i}$, we observe that the $j$-th row in the output column vector is 1 if and only if $v_{j}\in G_{S_{i}}$ and there is an edge $(u,v_{j})$ in $G_{S_{i}}$ such that $u\in S_{i}$. Given that $G_{S_{i}}$ has been computed in $O(n^{2-\epsilon})$ time, it follows that the number of edges in $G_{S_{i}}$ is $O(n^{2-\epsilon})$ and consequently the column vector $M\cdot V_{i}$ can be computed in $O(n^{2-\epsilon})$ time. Therefore, using the $O(n^{2-\epsilon})$ algorithm $\mathcal{A}$ we can solve Boolean Matrix-Vector Multiplication problem in $O(n^{3-\epsilon})$ time. If we believe that the OMv conjecture is indeed true, then it follows that the Induced Neighborhood Subgraph Computation problem cannot have an $O(n^{2-\epsilon})$ algorithm for any $\epsilon>0$. Hence the Theorem. ∎

5.1 OMv conjecture is false for instances with the consecutive ones property

A 0-1 matrix is said to have the consecutive ones property if in each row, the column indices which have a 1 form an interval. A 0-1 column vector satisfies the consecutive ones property if the row indices which have a 1 in the column form an interval. We consider a special case of the OMv problem where the input matrix $M$ and the sequence of online vectors $\{v_{1},v_{2},\dots,v_{n}\}$ satisfy consecutive ones property. Each row in the matrix $M$ corresponds to an interval and every column index is a point on the number line. In particular, in the $i$-th row if $l$ and $r$ are the least and largest column index, respectively, such that $M[i][l]=M[i][r]=1$, then the $i$-th row corresponds to the interval $I_{i}=[l,r]$. For each $1\leq j\leq n$, if $p$ and $q$ are the least and largest indices in $v_{j}$ such that $v_{j}[p]=v_{j}[q]=1$ then the vector $v_{j}$ is interpreted as the interval $I_{v_{j}}=[p,q]$.

Now, using the data structures described in Table 2 in Section 2.4 we design an algorithm to solve OMv problem in quadratic time for this special case.

Theorem 21**.**

OMv conjecture is false if the input matrix and the vectors in the online vector sequence have the consecutive ones property.

Proof.

The proof is by presenting an algorithm to solve the OMv problem. The algorithm has a preprocessing step in which the intervals corresponding to the rows of the matrix are maintained in an interval tree. Subsequently, the matrix vector product is computed using queries to the interval tree.

**Preprocessing step: ** The interval corresponding to the rows in $M$ are computed. Let $\sf row$ = $\{I_{1},I_{2},\dots,I_{n}\}$ denote the set of intervals corresponding to the rows in $M$. Computing the set $\sf row$ takes $O(n^{2})$ time. An interval tree $T_{\sf row}$ is constructed using the set $\sf row$. The construction of $T_{\sf row}$ takes $O(n\log n)$ time. Therefore, total time required in the preprocessing step is $O(n^{2})$.

**Computing $M\cdot v_{j}$: ** For $1\leq j\leq n$, when vector $v_{j}$ is presented, interval $I^{j}$ corresponding to $v_{j}$ is computed in $O(n)$ time. Let $H$ be the set returned by the intersection query $T_{\sf row}.intersection(I^{j})$. Since, $|H|\leq n$, from Table 2 the time required by the query is $O(\log n+n)$. $v_{\sf out}=M\cdot v_{j}$ is now computed as follows: for each $1\leq i\leq n$, if interval $I_{i}$ is present in $H$ then the $i$-th position in the vector $v_{\sf out}$ is set to $1$, otherwise [math]. Thus $v_{\sf out}$ can be computed in $O(n)$ time. Therefore, total time required for computing $M\cdot v_{j}$ is $O(n)$. Thus the OMv problem on such instances can be solved in time $O(n^{2})$. Hence the Theorem. ∎