Augmented Map

In computer science, the augmented map is an abstract data type (ADT) based on ordered maps, which associates each ordered map an augmented value. For an ordered map $m$ with key type $K$, comparison function $<_K$ on $K$ and value type $V$, the augmented value is defined based on two functions: a ''base'' function $g: K\times V \mapsto A$ and a ''combine'' function $f: A\times A\mapsto A$, where $A$ is the type of the augmented value. The base function $g$ converts a single entry in $m$ to an augmented value, and the combine function $f$ combines multiple augmented values. The combine function $f$ is required to be associative and have an identity $I$ (i.e., $A,f,I$ forms a monoid). We extend the definition of the associative function $f$ as follows:

$f(\emptyset)=I$
$f(a)=a$
$f(a_1,a_2,\dots,a_n)=f(f(a_1,a_2,\dots,a_),a_n)$

Then the augmented value of an ordered map $m=\$ is defined as follows:

$A(m)=f(g(k_1,v_1),g(k_2,v_2),\dots,g(k_n,v_n))$

Accordingly, an augmented map can be formally defined as a seven-tuple $\mathbb(K,<_K,V,A,g,f,I)$. For example, an augmented map with integral keys and values, on which the augmented value is defined as the sum of all values in the map, is defined as:
$M_1 = \mathbb(\mathbb,<_\mathbb,\mathbb,\mathbb,(k,v)\mapsto v, +_\mathbb,0)$

As an abstract data type, the augmented map is often used to model problems and serves as an abstraction with a useful interface. It is designed for supporting fast range sums, which means to quickly return the augmented value of all entries in a certain key range.

Interface

In addition to the interface for a standard ordered map, the augmented map should also support functions for range sums. In particular:
*aug_left$(m,k)$: returns the augmented value of all entries in $m$ with keys no more than $k$.
*aug_right$(m,k)$: returns the augmented value of all entries in $m$ with keys no less than $k$.
*aug_range$(m,k_1,k_2)$: returns the augmented value of all entries in $m$ with keys in range _1,k_2/math>.
*aug_val$(m)$: returns the augmented value of all entries in $m$.
Some functions, although are not defined based on augmented values, can make use of augmented values to accelerate their algorithms. Usually, they would require some certain representation of augmented maps, and certain conditions for input parameters.
*aug_filter$(m,h)$: returns all entries in $m$ satisfying the indicator $h: A\mapsto \text$. It is only applicable when $h(a)\vee h(b)\Leftrightarrow h(f(a,b))$. In this case, the aug_filter function is equivalent to filter$m,h'$, where $h':K\times V\mapsto \text$ and $h(g(k,v))\Leftrightarrow h'(k,v)$. When the augmented map is implemented using augmented trees, this function can be implemented asymptotically more efficient than the naive implementation.
*aug_project$(g',f',m,k_1,k_2)$: returns $g'(aug\_range(m,k_1,k_2))$. Here $g':A\mapsto B$, $f':B\times B\mapsto B$. It requires $(B,f',g'(I))$ to be a monoid and $f'(g'(a),g'(b))=g'(f(a,b))$. This function is useful when the augmented values
are themselves maps or other large data structures. It allows projecting the augmented values down onto another type by $g'$ (e.g. project augmented values with complicated structures to values like their sizes) then summing them by $f'$, and is much more efficient when applicable.

Implementation

Augmented trees

The augmented map can be supported efficiently by augmented trees, where each tree node is augmented by the augmented value of all entries in its subtree. Because of the associativity of the combine function $f$, the augmented value of a certain tree is fixed, and is independent of the shape of the tree, regardless of rotations. In this case, by combining the partial sums in the tree nodes, any range sum can be returned in $O(\log n)$ time on an augmented map of size $n$, assuming both $f$ and $g$ have constant cost.
For aug_filter, the tree structure takes the advantage that if the augmented value of a subtree does not satisfy the indicator $h$, the whole tree gets discarded. In this case, the cost of aug_filter is $O(k\log(1+\frac)$ where $k$ is the output size.
For aug_project, whenever a whole subtree falls in the range _1,k_2/math>, its augmented value can be directly combined to the result, instead of requiring traversing the tree.

Prefix structures

Another implementation is to use prefix structures, which stores the augmented value of all prefixes of the map. For the above-defined augmented map $M_1$, the prefix structure is an array stored the prefix sum of the values, sorted by their keys.
Prefix structures are particularly useful for aug_left, but can be inefficient to implement other functions on the augmented map interface. It can be useful in some geometric algorithms.

Example application

1D stabbing query

A 1D stabbing query takes as input a set of intervals on 1D number line. The query asks for if a given point is covered by any input interval, or all intervals covering this point. An augmented map can be defined for this problem, where the keys are the left endpoints of all intervals, values are the corresponding right endpoints, and the augmented value is the maximum value of all right endpoints in the map. More formally:

$M_=(\mathbb,<_\mathbb,\mathbb,\mathbb,(k,v)\mapsto v, \text_\mathbb,-\infty)$

To report if any interval covers a given point $p$, the query algorithm simply determines if aug_left$(p)>p$. This is because aug_left looks at all intervals that start before $p$, and if the maximum right endpoint among them exceeds $p$, then $p$ must be covered.
When implemented with augmented trees, the augmented map $M_\text$ is exactly an interval tree. Constructing such an augmented tree structure costs work $O(n\log n)$, $O(\log n)$ parallel depth and $O(n)$ space. Each stabbing query can be done in time $O(\log n)$.

2D range query

A 2D range query takes as input a set of points on 2 dimensions. The query asks for all points (or the number) in a certain rectangle, whose edges are parallel to the axis. An augmented map can be defined for this problem, which is a two-level nested map structure. The outer map stores all points and sort them by their x-coordinates. The augmented value of the outer map is an inner augmented map structure, which stores the same set of points as the outer map, but sorts them by their y-coordinates. The augmentation of the inner trees accumulate the count of points, i.e., the augmented value of an inner map is its size. Accordingly, the combine function of the outer map is to take a union of the two inner augmented maps. More formally:

$M_=(Y,<_Y,X,\mathbb,(k,v)\mapsto 1,+_\mathbb,0)$
$M_=(X,<_X,Y,M_\text,(k,v)\mapsto M_\text.singleton(v,k),M_\text.\text,M_\text.\text)$

Here for simplicity, assume all coordinates are unique. $X$ and $Y$ are the types of the x- and y-coordinates.
To answer the range query in rectangle $(x_1,x_2,y_1,y_2)$, the query algorithm extracts the augmented value of the outer map in the key range _1,x_2/math>, which is an inner map of all desired points sorted by y-coordinates. Therefore, the algorithm takes another aug_range on this inner map and gets the result. For counting queries, the algorithm can make use of the aug_project function.

$query(m,x_1,x_2,y_1,y_2)=M_\text.\text\_\text(g',+_\mathbb,m,x_1,x_2)$
$\textg':M_\text\mapsto \mathbb, g'(m')=M_\text.\text\_\text(m,y_1,y_2)$

If both the inner and the outer maps are implemented by augmented trees, then the whole two-level map structure becomes a range tree structure. If the inner map is supported by the augmented tree structure, and the outer tree is supported as the prefix structure, then the algorithm becomes a sweepline algorithm.

Other examples

Other examples include segment queries, inverted index searching, rectangle queries, etc.

Library support

A parallel implementation of the augmented map interface is provided in a library PAM.

Notes

References

{{Data structures

Data types
Abstract data types
data structures