Aggregate contribution of iceberg queries

Abstract

One or more embodiments determine a distance between at least two vectors of n coordinates. A set of heavy coordinates is identified from a set of n coordinates associated with at least two vectors. A set of light coordinates is identified from the set of n coordinates associated with the at least two vectors. A first estimation of a contribution is determined from the set of heavy coordinates to a rectilinear distance between the at least two vectors. A second estimation of a contribution is determined from the set of light coordinates to the rectilinear distance norm. The first estimation is combined with the second estimation.

Description

BACKGROUND

The present invention generally relates to data streams, and more particularly relates to measuring distance between data in a data stream.

Recent years have witnessed an explosive growth in the amount of available data. Data stream algorithms have become a quintessential tool for analyzing such data. These algorithms have found diverse applications, such as large scale data processing and data warehousing, machine learning, network monitoring, and sensor networks and compressed sensing. A key ingredient in all these applications is a distance measure between data. In nearest neighbor applications, a database of points is compared to a query point to find the nearest match. In clustering, classification, and kernels, e.g., those used for support vector machines (SVM), given a matrix of points, all pairwise distances between the points are computed. In network traffic analysis and denial of service detection, global flow statistics computed using Net-Flow software are compared at different times via a distance metric. Seemingly unrelated applications, such as the ability to sample an item in a tabular database proportional to its weight, i.e., to sample from the forward distribution, or to sample from the output of a SQL Join, require a distance estimation primitive for proper functionality.

One of the most robust measures of distance is the ₁-distance (rectilinear distance), also known as the Manhattan or taxicab distance. The main reason is that this distance is robust is that it less sensitive to outliers. Given vectors x, y∈ⁿ, the ₁-distance is defined as

${x-y}_1\stackrel{\mathrm{def}}{=}\sum _{i=1}^nx_i-y_i.$ This measure, which also equals twice the total variation distance, is often used in statistical applications for comparing empirical distributions, for which it is more meaningful and natural than Euclidean distance. The ₁-distance also has a natural interpretation for comparing multisets, whereas Euclidean distance does not. Other applications of ₁ include clustering, regression (and with applications to time sequences), Internet-traffic monitoring, and similarity search. In the context of certain nearest-neighbor search problems, “the Manhattan distance metric is consistently more preferable than the Euclidean distance metric for high dimensional data mining applications”. The ₁-distance may also support faster indexing for similarity search.

Another application is with respect to estimating cascaded norms of a tabular database, i.e. the _p norm on a list of attributes of a record is first computed, then these values are summed up over records. This problem is known as ₁(_p) estimation. An example application is in the processing of financial data. In a stock market, changes in stock prices are recorded continuously using a r_log quantity known as logarithmic return on investment. To compute the average historical volatility of the stock market from the data, the data is segmented by stock, the variance of the r_log values are computed for each stock, and then these variances are averaged over all stocks. This corresponds to an ₁ (₂) computation (normalized by a constant). As a subroutine for computing ₁(₂), the best known algorithms use a routine for ₁-estimation.

BRIEF SUMMARY

In one embodiment, a method for determining a distance between at least two vectors of n coordinates is disclosed. The method comprises identifying a set of heavy coordinates from a set of n coordinates associated with at least two vectors. A heavy coordinate is represented as |x_i|≧∈²∥x∥₁, where x is a vector, i is a coordinate in the set of n coordinates, and c is an arbitrary number. A set of light coordinates is identified from the set of n coordinates associated with the at least two vectors, wherein a light coordinate is represented as |x_i|<∈²∥x∥₁. A first estimation of a contribution is determined from the set of heavy coordinates to a rectilinear distance between the at least two vectors. A second estimation of a contribution is determined from the set of light coordinates to the rectilinear distance norm. The first estimation is combined with the second estimation.

In another embodiment, an information processing system for determining a distance between at least two vectors of n coordinates is disclosed. The information processing system comprises a memory and a processor that is communicatively coupled to the memory. A data stream analyzer is communicatively coupled to the processor and the memory. The data stream analyzer is configured to perform a method. The method comprises identifying a set of heavy coordinates from a set of n coordinates associated with at least two vectors. A heavy coordinate is represented as |x_i|≧∈²∥x∥₁, where x is a vector, i is a coordinate in the set of n coordinates, and c is an arbitrary number. A set of light coordinates is identified from the set of n coordinates associated with the at least two vectors, wherein a light coordinate is represented as |x_i|<∈²∥x∥₁. A first estimation of a contribution is determined from the set of heavy coordinates to a rectilinear distance between the at least two vectors. A second estimation of a contribution is determined from the set of light coordinates to the rectilinear distance norm. The first estimation is combined with the second estimation.

In yet another embodiment, a computer program product for determining a distance between at least two vectors of n coordinates is disclosed. The computer program product comprises a storage medium readable by a processing circuit and storing instructions for execution by the processing circuit for performing a method comprising. The method comprises identifying a set of heavy coordinates from a set of n coordinates associated with at least two vectors. A heavy coordinate is represented as |x_i|≧∈²∥x∥₁, where x is a vector, i is a coordinate in the set of n coordinates, and ∈ is an arbitrary number. A set of light coordinates is identified from the set of n coordinates associated with the at least two vectors, wherein a light coordinate is represented as |x_i|<∈²∥x∥₁. A first estimation of a contribution is determined from the set of heavy coordinates to a rectilinear distance between the at least two vectors. A second estimation of a contribution is determined from the set of light coordinates to the rectilinear distance norm. The first estimation is combined with the second estimation.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

The accompanying figures where like reference numerals refer to identical or functionally similar elements throughout the separate views, and which together with the detailed description below are incorporated in and form part of the specification, serve to further illustrate various embodiments and to explain various principles and advantages all in accordance with the present invention, in which:

FIG. 1 is a block diagram illustrating one example of an operating environment comprising an adaptive search personalization system according to one embodiment of the present invention;

FIG. 2 shows a bounding of Var[Φ|]=E[Φ²|]−E²[Φ|] according to one embodiment of the present invention;

FIG. 3 shows an equality for E[D_i,j²|] according to one embodiment of the present invention;

FIG. 4 shows an equality for Pr[_L∪{y}ⁱ|] according to one embodiment of the present invention;

FIG. 5 shows an equality for E[sign(x_w)sign(x_y)σ^i(w)(w)σ^i(y)(y) D_{i(w), j(w)}D_i(y),j(y)|] according to one embodiment of the present invention;

FIG. 6 shows another equality when a set of bounds are combined according to one embodiment of the present invention;

FIG. 7 shows one example of pseudocode of an ₁-estimation according to one embodiment of the present invention;

FIG. 8 shows a proof for Lemma 7 according to one embodiment of the present invention;

FIG. 9 shows an equality for

$E_{A,h}\left[\frac{R}{I}·\sum _{j\in I}{\tilde{L}}_1\left(j\right)|{ℱ}_L,I_{\prime }^{}\right]$ according to one embodiment of the present invention;

FIG. 10 shows an equality for Pr_h[(h(i)=j)′_l|_L] according to one embodiment of the present invention;

FIG. 11 shows another equality according to one embodiment of the present invention;

FIG. 12 shows an equality for Pr_h[h(i)=j|j∈I] according to one embodiment of the present invention;

FIG. 13 shows yet another equality based on Bayes' theorem according to one embodiment of the present invention;

FIG. 14 shows a probability of correctness according to one embodiment of the present invention; and

FIG. 15 is an operational flow diagram illustrating one example of a process for determination a distance between at least two vectors of n coordinates according to one embodiment of the present invention.

DETAILED DESCRIPTION

Operating Environment

FIG. 1 shows one example of an operating environment 100 applicable to various embodiments of the present invention. In particular, FIG. 1 shows a computer system/server 102 that is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well-known computing systems, environments, and/or configurations that may be suitable for use with computer system/server 102 include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the above systems or devices, and the like. Computer system/server 102 may be described in the general context of computer system-executable instructions, such as program modules, being executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, and so on that perform particular tasks or implement particular abstract data types.

As shown in FIG. 1, a computer system/server 102 is shown in the form of a general-purpose computing device. The components of computer system/server 102 can include, but are not limited to, one or more processors or processing units 104, a system memory 106, and a bus 108 that couples various system components including system memory 106 to processor 104. Bus 108 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnects (PCI) bus.

Computer system/server 102 typically includes a variety of computer system readable media. Such media may be any available media that is accessible by computer system/server 1002, and it includes both volatile and non-volatile media, removable and non-removable media. System memory 106, in one embodiment, comprises a data stream analyzer 110 that performs one or more of the embodiments discussed below with respect to measuring distance between data. It should be noted that the data stream analyzer 110 can also be implemented in hardware as well. The system memory 106 can include computer system readable media in the form of volatile memory, such as random access memory (RAM) 112 and/or cache memory 114.

Computer system/server 102 can further include other removable/non-removable, volatile/non-volatile computer system storage media. By way of example only, storage system 116 can be provided for reading from and writing to a non-removable, non-volatile magnetic media (not shown and typically called a “hard drive”). Although not shown, a magnetic disk drive for reading from and writing to a removable, non-volatile magnetic disk (e.g., a “floppy disk”), and an optical disk drive for reading from or writing to a removable, non-volatile optical disk such as a CD-ROM, DVD-ROM or other optical media can be provided. In such instances, each can be connected to bus 108 by one or more data media interfaces. As will be further depicted and described below, memory 106 may include at least one program product having a set (e.g., at least one) of program modules that are configured to carry out the functions of embodiments of the invention.

Program/utility 118, having a set (at least one) of program modules 120, may be stored in memory 106 by way of example, and not limitation, as well as an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data or some combination thereof, may include an implementation of a networking environment. Program modules 120 generally carry out the functions and/or methodologies of embodiments of the invention as described herein.

Computer system/server 102 may also communicate with one or more external devices 122 such as a keyboard, a pointing device, a display 124, etc.; one or more devices that enable a user to interact with computer system/server 126; and/or any devices (e.g., network card, modem, etc.) that enable computer system/server 102 to communicate with one or more other computing devices. Such communication can occur via I/O interfaces 126. Still yet, computer system/server 102 can communicate with one or more networks such as a local area network (LAN), a general wide area network (WAN), and/or a public network (e.g., the Internet) via network adapter 128. As depicted, network adapter 1026 communicates with the other components of computer system/server 102 via bus 108. It should be understood that although not shown, other hardware and/or software components could be used in conjunction with computer system/server 102. Examples, include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archival storage systems, etc.

Overview

The inventors paper entitled “Fast Manhattan Sketches in Data Streams”, by Jelani Nelson and David P. Woodruff, ACM PODS '10 Indiana, Ind., USA which is hereby incorporated by reference in its entirety. As discussed above, the ₁-distance, also known as the Manhattan or taxicab distance, between two vectors x, y in ⁿ is Σ_i=1ⁿ|x_i−y_i|. Approximating this distance is a fundamental primitive on massive databases, with applications to clustering, nearest neighbor search, network monitoring, regression, sampling, and support vector machines. One or more embodiments of the present invention are directed to the problem of estimating the ₁-distance in the most general turnstile model of data streaming.

Formally, given a total of m updates (positive or negative) to an n-dimensional vector x, one or more embodiments maintain a succinct summary, or sketch, of what has been seen so that at any point in time the data stream analyzer can output an estimate E(x) so that with high probability, (1−∈)∥x∥₁≦E(x)≦(1−∈)∥x∥₁, where ∈>0 is a tunable approximation parameter. Here, an update has the form (i, v), meaning that the value v should be added to coordinate i. One or more embodiments assume that v is an integer (this is without loss of generality by scaling), and that |v|≦M, where M is a parameter. Updates can be interleaved and presented in an arbitrary order. Of interest is the amount of memory to store the sketch, the amount of time to process a coordinate update, and the amount of time to output an estimate upon request.

One or more embodiments of the present invention are advantageous because they give the first 1-pass streaming algorithm for this problem in the turnstile model with O*(∈⁻²) space and O*(1) update time where the bounds are optimal up to O*(1) factors. The O* notation hides polylogarithmic factors in ∈, n, and the precision required to store vector entries. In particular, one or more embodiments provide 1-pass algorithm using ∈⁻² polylog(nmM) space for ₁-estimation in data streams with polylog(nmM) update time, and reporting time ∈⁻² polylog(nmM). This algorithm is simultaneously optimal in both the space and the update time up to polylog(nmM) factors. Conventional algorithms either required at least ∈⁻³ polylog(nmM) bits of space, or at least ∈⁻² update time. As ∈ can be arbitrarily small, the result of one or more embodiments can provide a substantial benefit over conventional algorithms. In light of known lower bounds, the space and time complexity of these one or more embodiments are optimal up to polylog(nmM) factors.

It should be noted that in the following discussion, for a function ƒ the notation O*(ƒ) is used to denote a function g=O(ƒ·polylog (nmM|∈)). Θ* and Ω* are similarly defined.

The improvements provided by one or more embodiments of the present invention result in corresponding gains for the aforementioned applications. Examples include the scan for nearest neighbor search, for which to obtain sketches of size O* (∈⁻²), these embodiments reduce the preprocessing time from O(nd∈⁻²) to O* (nd). These embodiments also shave an ∈⁻² factor in the time for computing all pairwise ₁-distance, in the update time for sampling from the forward distribution, in the time for comparing two collections of traffic-flow summaries, and in the time for estimating cascaded norms.

Techniques

Using the Cauchy sketches of Li (particularly, the geometric mean estimator) would require Ω*(∈⁻²) update time. Multi-level sketches can be used, incurring an extra Ω*(∈⁻¹) factor in the space. Various embodiments of the present invention achieve O*(1) update time by using Cauchy sketches (and particularly, Li's geometric mean estimator). However, to achieve this result one or more embodiments preprocess and partition the data, as discussed in greater detail below.

A Cauchy sketch is now described. Given a vector x, the sketch is a collection of counters

$Y_j=\sum _{i=1}^n{x}_1{C}_{i,j}\mathrm{for}j=1,\dots ,k,$ where the are standard Cauchy random variables with probability density function

$\mu \left(y\right)=\frac{1}{\pi \left(1+y^2\right)}.$ The C_i,j are generated pseudo-randomly using a pseudo-random generator (PRG). By the 1-stability of the Cauchy distribution, Y_j is also distributed as a standard Cauchy random variable, scaled by ∥x∥₁. Li shows that there is a constant c_k>0 so that for any k≧3, if k≧3, if Y₁, . . . , Y_k are independent Cauchy sketches, then the geometric mean estimatorEst_GM=c_k·(|Y₁|·|Y₂| . . . |Y_k|)^1/k has an expected value E[Est_GM]=∥x∥₁ a variance of Var[Est_GM]=Θ(∥x∥₁²/k). The space and time complexity of maintaining the Y₃ in a data stream are O*(k), and by linearity, can be computed in a single pass. By Chebyshev's inequality, for k=Θ(∈⁻²) one obtains a (1±∈)-approximation to ∥x∥₁ with constant probability, which can be amplified by taking the median of independent repetitions. While the space needed is O*(∈⁻²), so is the update time.

The starting point of one or more embodiments is the following idea. Suppose the coordinates into O(∈⁻²) are randomly partitioned into buckets. In each bucket Li's estimator is maintained, but only with parameter k=3. Given an update to a coordinate i, it lands in a unique bucket, and the contents of this bucket can be updated in O*(1) time. Using Θ(∈⁻²) buckets, the space is also O*(∈⁻²). One is then faced with the following temptation: letting G_i be the estimate returned by Li's procedure in bucket i for k=3, output

$G=\sum _{i=1}^r{G}_i.$ From the properties of the G_i, this is correct in expectation.

The main wrinkle is that Var[G] can be as large as Ω(∥x∥₁²), which is not good enough. To see that this can happen, suppose x contains only a single non-zero coordinate x₁=1. In the bucket containing x₁, the value G of Li's estimator is the geometric mean of 3 standard Cauchy random variables. By the above, Var[G]=Θ(∥x∥₁²/k)=Θ(∥x∥₁²).

Note though in the above example, x₁ contributed a large fraction of the ₁ mass of x (in fact, all of it). The main idea of one or more embodiments then is the following. A φ-heavy coordinate of the vector x is a coordinate i for which |x_i|≧φ·∥x∥₁. Algorithms for finding heavy coordinates, also known as iceberg queries, have been extensively studied in the database community, and such algorithms in the algorithm of one or more embodiments of the present invention. Set φ=∈². Every φ-heavy coordinate is removed from x, the contribution of these heavy coordinates are estimated separately, then the bucketing above is used on the remaining coordinates. This reduces Var[G] to O(∥x_tail∥₂²), where x_tail is the vector obtained from x by removing the heavy coordinates. A calculation shows that O(∥x_tail∥₂²)=O(∈₂∥x∥₁²), which is good enough to argue that ∥x_tail∥₁ can be estimated to within an additive ∈∥x∥₁ with constant probability. This idea can be implemented in a single pass.

The main remaining hurdle is estimating ∥x_head∥₁, the contribution to ∥x∥₁ from the heavy coordinates. Using current techniques the CountMin sketch, can be used to estimate the value of each ∈²-heavy coordinate up to an additive ∈³∥x∥₁. Summing the estimates gives ∥x_head∥₁ up to an additive ∈∥x∥₁. This, however, requires Ω*(∈⁻³) space, which, in some embodiments, cannot be afforded. Instead, a new subroutine, Filter, is designed that estimates the sum of the absolute values of the heavy coordinates, i.e., the value ∥x_head∥₁, up to an additive ∈∥x∥₁, without guaranteeing an accurate frequency estimate to any individual heavy coordinate. This relaxed guarantee is sufficient for correctness of our overall algorithm, and is implementable in O*(∈⁻²) space.

Other technical complications arise due to the fact that the partitioning is not truly random, nor is the randomness used by Li's estimator. Therefore, one or more embodiments use a family that is close to an O(∈⁻²)-wise independent family, but doesn't suffer the O(∈⁻²) evaluation time required of functions in such families (e.g., O(∈⁻²)-degree polynomial evaluation). These functions can be evaluated in constant time. The caveat is that the correctness analysis needs more attention.

Preliminaries

The algorithm used by the data stream analyzer 110 operates, in one embodiment, in the following model. A vector x of length n is initialized to 0, and it is updated in a stream of m updates from the set [n]×{−M, . . . , M}. An update (i, v) corresponds to the change x_i←x_i+v. In one embodiment, a (1±∈)-approximation to

${x}_1=\sum _{i=1}^nx_i$ is computed for some given parameter ∈>0. All space bounds in this discussion are in bits, and all logarithms are base 2, unless explicitly stated otherwise. Running times are measured as the number of standard machine word operations (integer arithmetic, bitwise operations, and bitshifts). A differentiation is made between update time, which is the time to process a stream update, and reporting time, which is the time required to output an answer. Each machine word is assumed to be Ω(log(nmM/∈)) bits so that index each vector can be indexed and arithmetic can be performed on vector entries and the input approximation parameter in constant time.

Throughout this discussion, for integer z, [z] is used to denote the set {1, . . . , z}. For reals A, B, A±B is used to denote some value in the interval [A−B, A+B]. Whenever a frequency x, is discussed, that frequency at the stream's end is being referred to. It is also assumes ∥x∥₁≠0 without loss of generality (note ∥x∥₁=0 iff ∥x∥₂=0, and the latter can be detected with arbitrarily large constant probability in O(log(nmM)) space and O(1) update and reporting time by, say, the AMS sketch), and that ∈<∈₀ for some fixed constant ∈₀.

₁ Streaming Algorithm

The ₁ streaming algorithm used by the data stream analyzer 110 for (1±∈)-approximating ∥x∥₁ is now discussed in greater detail. As discussed in above, the algorithm works by estimating the contribution to ₁ from the heavy coordinates and non-heavy coordinates separately, then summing these estimates.

A “φ-heavy coordinate” is an index i such that that |x_i|≧φ∥x∥₁. A known heavy coordinate algorithm is used for the turnstile model of streaming (the model currently being operating in) to identify the ∈²-heavy coordinates. Given this information, a subroutine, Filter (discussed below), is used to estimate the contribution of these heavy coordinates to ₁ up to an additive error of ∈∥x∥₁. This takes care of the contribution from heavy coordinates. R=Θ(1/∈²) “buckets” B_i are maintained in parallel, which the contribution from non-heavy coordinates to be estimated. Each index in [n] is hashed to exactly one bucket i[R]. The ith bucket keeps track of the dot product of x, restricted to those indices hashed to i, with three random Cauchy vectors, a known unbiased estimator of ₁ is applied due to Li (the “geometric mean estimator”) to estimate the ₁ norm of x restricted to indices hashed to i. The estimates from the buckets not containing any ∈²-heavy coordinates are then sum up (some scaling of). The value of the summed estimates turns out to be approximately correct in expectation. Then, using that the summed estimates only come from buckets without heavy coordinates, it can be shown that the variance is also fairly small, which then shows that the estimation of the contribution from the non-heavy coordinates is correct up to ∈|x|₁ with large probability.

The Filter Data Structure: Estimating the Contribution from Heavy Coordinates

In this section, it is assumed that a subset L⊂[n] of indices i is known so that (1) for all i for which |x_i|≧∈²∥x∥₁, iL, and (2) for all iL, |x₁|≧(∈²/2)∥x∥₁. Note this implies |L|≦2/∈². Furthermore, it is also assumed that sign(x_i) is known for each iL. Throughout this discussion, ahead denotes the vector x projected onto coordinates in L, so that Σ_i∈L|x|=∥x_head∥₁. The culmination of this section is Theorem 3, which shows that an estimate Φ=∥x_head|₁±∈∥x∥₁ in small space with large probability can be obtained via a subroutine referred to herein as Filter. The following uniform has family construction given is used.

THEOREM 1. Let S⊂U=[u] be a set of z>1 elements, and let V=[v], with 1<v≦u.

Suppose the machine word size is Ω(log(u)). For any constant c>0 there is a word RAM algorithm that, using time log(z) log^O(1)(v) and O(log(z)+log log(u)) bits of space, selects a family of functions from U to V (independent of S) such that:

• • 1. With probability 1−O(1/z^c), is z-wise independent when restricted to S.
  • 2. Any h can be represented by a RAM data structure using O(z log(v)) bits of space, and h can be evaluated in constant time after an initialization step taking O(z) time.

The BasicFilter data structure can be defined as follows. Choose a random sign vector σ{−1, 1}ⁿ from a 4-wise independent family. Put r=[27/∈²]. A hash function h: [n]→[r] is chosen at random from a family constructed randomly as in Theorem 1 with u=n, v=z=r, c=1. Note |L|+1<z. Also, r counters b₁, . . . , b_r are initialized to 0. Given an update of the form (i, v), add σ(i)·v to b_h(i).

The Filter data structure is defined as follows. Initialize s=[log 3(1/∈²)]+3 independent copies of the BasicFilter data structure. Given an update (i, v), perform the update described above to each of the copies of BasicFilter. This data structure can be thought of as an s×r matrix of counters D_i,j, i[s] and j[r]. The variable σⁱ denotes the sign vector σ in the i-th independent instantiation of BasicFilter, and similarly define hⁱ and ⁱ. Notice that the space complexity of Filter is O(∈⁻² log(1/∈)log(mM)+log(1/∈)log log n), where O represents a constant C that is independent of n. The update time is O(log(1/∈)).

For each wL for which hⁱ(w)=1, say a count D_i,j is good for w if for all yL\{w}, hⁱ(y)≠j. Since h_i is |L|-wise independent when restricted to L with probability at least 1−1/r, Pr[D_i,j is good for w]≧(1−1/r)·(1−(|i|−1)/r)≧⅔, where the second inequality holds for i≦1. It follows that since Filter is the concatenation of s independent copies of BasicFilter,

$\begin{array}{cc}\mathrm{Pr}\left[\forall w\in L,\exists i\in \left[s\right]\mathrm{for}\mathrm{which}{D}_{i,h^i\left(w\right)}\mathrm{is}\mathrm{good}\mathrm{for}w\right]\mathrm{Pr}\left[\forall w\in L,\exists i\in \left[s\right]\mathrm{for}\mathrm{which}{D}_{i,h^i\left(w\right)}\mathrm{is}\mathrm{good}\mathrm{for}w\right]\ge 1-L·\left(\frac{1}{3^s}\right)>\frac{9}{10}& \left(\mathrm{EQ}.1\right)\end{array}$ Let ∈ be the event of EQ. (1).

The following estimator Φ of ∥x_head∥₁ is defined given the data in the Filter structure, together with the list L. It is also assumed that holds, else the estimator is not well-defined. For each wL, let i(w) be the smallest i for which D_i,hi(w) is good for w, and let j(w)=h^i(w)(i). The estimator is then

$\Phi =\sum _{w\in L}\mathrm{sign}\left(x_w\right)·{\sigma }^{i\left(w\right)}\left(w\right)·D_{i\left(w\right),j\left(w\right)}.$ with σ being a random vector, each of its entries is either +1 or −1. Note that the Filter data structure comprises universal hashing replaced by uniform hashing, and has different estimation procedure that the CountSketch structure.

LEMMA 2: E[Φ|]=∥x_head∥₁ and Var[Φ|]≦2∈²∥x∥₁²/9

Proof: By linearity expectation,

$E\left[\Phi |\right]=\sum _{w\in L}E\left[\mathrm{sign}\left(x_w\right)·{\sigma }^{i\left(w\right)}\left(w\right)·D_{i\left(w\right),j\left(w\right)}|\right]$ Fix a wL, and for notational convenience let i=i(w) and j=j(w). For each y[n], set Γ(y)=1 if hⁱ(i)=j, and set Γ(y)=0 otherwise. Then

$E_{{\sigma }^i,h^i}\left[\mathrm{sign}\left(x_w\right)·{\sigma }^i\left(w\right)·D_{i,j}|\right]=\sum _y{E}_{{\sigma }^i,h^i}\left[\mathrm{sign}\left(x_w\right)x_y\Gamma \left(y\right){\sigma }^i\left(y\right){\sigma }^i\left(w\right)|\right]$

Consider any fixing of h′ subject to the occurrence of , and notice that σⁱ is independent of hⁱ. Since σⁱ is 4-wise independent, it follows that

$\begin{array}{cc}{E}_{{\sigma }^i}\left[\mathrm{sign}\left(x_w\right)·{\sigma }^i\left(w\right)·D_{i,j}|h^i\right]=E_{{\sigma }^i,h^i}\left[\mathrm{sign}\left(x_w\right)x_w\Gamma \left(w\right){\sigma }^i\left(w\right){\sigma }^i\left(w\right)\right]=x_w,& \left(\mathrm{EQ}.2\right)\end{array}$ and hence

$E\left[\Phi |\right]=\sum _{w\in L}x_w={x_{\mathrm{head}}}_1$

A bounding is now performed for Var[Φ|]=E[Φ²|]−E²[Φ|], or equivalently, the function shown in FIG. 2. First Σ_w∈LE[D_{i(w), j(w)}²|] is bound. A wL is fixed, and for notational convenience, put i(w) and j=j(w). Then E[D_i,j²|] is equal to that shown in FIG. 3, where the second equality follows from the fact that σ^j is 4-wise independent and independent of . Note Pr[hⁱ(y)=j|]=0 for any y∈(L\{w}), and Pr[hⁱ(w)=j|]=1 by definition.

Now consider a coordinate y∉L . For S⊂[n] let _sⁱ be the event that ⁱ is |S|-wise independent when restricted to S. By Bayes' rule Pr[_L∪{y}ⁱ|] is equal to that shown in FIG. 4. Conditioned on _L∪{y}ⁱ, the value hⁱ(y) is uniformly random even given the images of all members in L under hⁱ. Thus, Pr[hⁱ(y)=j|]≦10/(9r)+1/r<3/r. Since the bucket is good for w, the total contribution of such y to E[D_i,j²|] is at most 3·∥x_tail∥₂²/r, where x_tail is the vector x with the coordinates in L removed. The ∥x_tail∥₂² is maximized when there are ∈⁻² coordinates each of magnitude ∈²∥x∥₁. In this case ∥x_tail∥₂²=∈²∥x∥₁².

Hence,E[D_i,j²|]≦x_w²+3∈²∥x∥₁²/r≦x_w²+∈⁴∥x∥₁²/9

As |L|≦2∈⁻², it follows that

$\sum _{w\in L}E\left[D_{i,\left(w\right),j\left(w\right)}^2|\right]\le 2{\varepsilon }^2{x}_1^2/9+\sum _{w\in L}{x}_w^2$

Now turning to bounding

$\sum _{w\ne y\in L}E[\mathrm{sign}\left(x_w\right)\mathrm{sign}\left(x_y\right){\sigma }^{i\left(w\right)}\left(w\right){\sigma }^{i\left(y\right)}\left(y\right)\times D_{i\left(w\right),j\left(w\right)}{D}_{i\left(y\right),j\left(y\right)}]$ Fix distinct w, yL. Note that (i(w), j(w))≠(i(y), j(y)) conditioned on occurring. Suppose first that i(w)≠i(y), then the equality shown in FIG. 5 is obtained since it holds for any fisted h^i(w), h^i(w), where the final equality follows from EQ 2.

Now suppose that i(w)=i(y). Let i=i(w)=i(y) for notational convenience. Define the indicator random variable Γ^w(z)=1 if hⁱ(z)=j(w), and similarly let Γ^y(z)=1 if hⁱ(z)=j (y). Then the expression E[sign(x_w)sign(x_y)σ^i(w)(w)σ^i(w)(y)D_{i(w), j(w)}D_{i(y), j(y)}|] can be expanded using the definition D_{i(w), j(w)} and D_{i(y), j(y)} as:

$\sum _{z,z^{\prime }}E[\mathrm{sign}\left(x_w\right)\mathrm{sign}\left(x_y\right)x_z{z}_{z^{\prime }}{\Gamma }^w\left(z\right){\Gamma }^y\left(z^{\prime }\right){\sigma }^i\left(z\right){\sigma }^i\left(z^{\prime }\right)\times {\sigma }^i\left(w\right){\sigma }^i\left(y\right)]$

The variables z and z′ are fixed and a summand of the form E[sign(x_w)sign(x_y)x_zx_z′Γ^w(z)Γ^y(z′)×σⁱ(z)σⁱ(z′)σⁱ(w)σⁱ(y)|] is analyzed.

Consider any fixing of hⁱ subject to the occurrence of , and recall that σⁱ is independent of hⁱ. Since σ^j is 4-wise independent and a sign vector, it follows that this summand vanishes unless {z, z′} {w, y}. Moreover, since Γ^w(y)=Γ^y(w)=0, while Γ^w(w)=Γ^y(y)=1, then there must be the following, z=w and z′=y. In this case, E[sign(x_w)sign(x_y)x_zx_z′Γ^w(z)Γ^y(z′)×σⁱ(z)σⁱ(z′)σⁱ(w)σⁱ(y)|hⁱ]=|x_w|·|x_y|.

Hence, the total contribution of all distinct w, yL to Var[Φ|] is at most Σ_w≠∈L|x_w|·|x_y|.

Combining the bounds, it follows that the equalities in FIG. 6 are true. This completes the proof of the lemma.

By Chebyshev's inequality, Lemma 2 implies

$\mathrm{Pr}\left[\Phi -{x_{\mathrm{head}}}_1\ge \varepsilon {x}_1|\right]\le \frac{\mathrm{Var}\left[\Phi |\right]}{{\varepsilon }^2{x}_1^2}\le \frac{2{\varepsilon }^2{x}_1^2}{9{\varepsilon }^2{x}_1^2}=\frac{2}{9}$ and thus

$\mathrm{Pr}\left[\left(\Phi -{x_{\mathrm{head}}}_1\le \varepsilon {x}_1\right)\bigwedge \right]\ge \left(\frac{7}{9}\right)·\left(\frac{9}{10}\right)=\frac{7}{10}.$

The above findings are summarized with the following theorem:

THEOREM 3: Suppose that is a set L⊂[n] of indices j so that (1) for all j for which |x_j|≧υ²∥x∥₁, j∈L and (2) for all j∈L, |x_j|≧(∈²/2)∥x∥₁. Further, suppose sign(x_j) is known for each jL. Then, there is a 1-pass algorithm, Filter, which outputs an estimate for which with probability at least 7/10, |Φ−∥x_head∥₁|≦∈∥x∥₁. The space complexity of the algorithm is O(∈⁻² log(1/∈)log(mM)+log(1/∈)log log n). The update time is O(log(1/∈), and the reporting time is O(∈⁻² log(1/∈)).

The Final Algorithm

The final algorithm for (1±∈)-approximating ∥x∥₁, which was outlined above is now analyzed. The full details of the algorithm are shown in FIG. 7. Before giving the algorithm and analysis, the ₁ heavy coordinates problem is defined.

Definition 4: Let 0<γ<φ and δ>0 be given. In the ₁ heavy coordinates problem, with probability at least 1−δ a list L⊂[n] is outputted such that:

• • 1. For all i with |x_i|≧ø∥x∥₁, i∈L, iL.
  • 2. For all iL, |x_i|>(ø−γ)∥x∥₁.
  • 3. For each iL, an estimate {circumflex over (x)}_i is provided such that |{tilde over (x)}_i−x₁|<γ∥x∥₁.

Note that for γ≦φ/2, the last two items above imply sign(x_i) can be determined for iL. For a generic algorithm solving the ₁ heavy coordinates problem HHUpdate(φ), HHReport(φ), and HHSpace(φ) are used to denote update time, reporting time, and space, respectively, with parameter φ and γ=φ/2, δ=1/20.

There exist a few of solutions to the ₁ heavy coordinates problem in the turnstile model. The work gives an algorithm with HHSpace(φ)=O(φ⁻¹ log(mM)log(n)), HHUpdate(φ)=O(log(n)), and with HHReport(φ)=O(n log(n)), and gives an algorithm with HHSpace(φ)=O(φ⁻¹ log(φn) log log(φn) log(1/φ) log(mM)), and with HHUpdate(φ)=O(log(φn) log log(n) log(1/φ), and HHReport(φ)=O(φ⁻¹ log(φn) log log(φn) log(1/φ).

Also, the following theorem follows from Lemma 2.2 (with k=3 in their notation). In Theorem 5 (and in FIG. 7), the Cauchy distribution is a continuous probability distribution defined by its density function μ(x)=(π(1+x²))⁻¹. One can generate a Cauchy random variable X by setting X=tan(πU/2) for U a random variable uniform in [0, 1]. Of course, to actually implement our algorithm (or that of Theorem 5) one can only afford to store these random variables to some finite precision; this is discussed in Remark 9 below.

THEOREM 5: For an integer n>0, let A₁[j], . . . , A_n[j] be 3n independent Cauchy random variables for j=1, 2, 3. Let xRⁿ be arbitrary. Then given

$C_j=\sum _{i=1}^n{A}_i\left[j\right]·x_i\mathrm{for}j=1,2,3,$ the estimator

${\mathrm{Est}}_{\mathrm{GM}}={\mathrm{Est}}_{\mathrm{GM}}\left(C_1,C_2,C_3\right)=\frac{8\sqrt{3}}{9}·\sqrt[3]{C_1·C_2·C_3}$ satisfies the following two properties:

$1.E\left[{\mathrm{Est}}_{\mathrm{GM}}\right]={x}_1$ $2.\mathrm{Var}\left[{\mathrm{Est}}_{\mathrm{GM}}\right]=\frac{19}{8}·{x}_1^2$

It is shown in Theorem 6 that the algorithm outputs (1±O(e))∥x∥₁ with probability at least 3/5. Note this error term can be made c by running the algorithm with ∈′ being ∈ times a sufficiently small constant. Also, the success probability can be boosted to 1−δ by running O(log(1/δ)) instantiations of the algorithm in parallel and returning the median output across all instantiations.

THEOREM 6: The algorithm of FIG. 7 outputs (1±O(∈))∥x∥₁ with probability at least 3/5.

PROOF: Throughout this proof A is used to denote the 3n-tuple (A₁[1], . . . , A_n[n], . . . , A₁[3], . . . , A_n [3]), and for S⊂[n], _S is the event that the hash family that is randomly selected in Step 3 via Theorem 1 is ISI-wise independent when restricted to S. For an event , 1_∈ denotes the indicator random variable for . The variable x_head is used denote x projected onto the coordinates in L, and x_tad is used to denote the remaining coordinates. Note ∥x∥₁=∥x_head∥₁+∥x_tail∥₁.

The following lemma will now be proved. The proof requires some care since h is not always a uniform hash function on small sets, but is only so on any particular (small) set with large probability.

LEMMA 7: Conditioned on the randomness of HH of FIG. 7,

$E_{A,h}\left[\frac{R}{I}·\sum _{j\in I}{\tilde{L}}_1\left(j\right)\right]=\left(1\pm O\left(\varepsilon \right)\right){x_{\mathrm{tail}}}_1.$

PROOF: For ρ=1−Pr(_L), see FIG. 8, by Theorem 1 and Theorem 5.

The above expectation is now computed conditioned on I. Let ′_I be the event I=I′ for an arbitrary I′. Then, see FIG. 9. Now, see FIG. 10. It should be noted that if _L∪{i} occurs, the _I′ is independent of the event h(i)=j. Also, if _L occurs, then _I′ is independent of _L∪{i}. Thus, the above equals

${\mathrm{Pr}}_h\left[h\left(i\right)=j❘{ℱ}_{L\bigcup \left\{i\right\}}\right]·{\mathrm{Pr}}_h\left[{I^{\prime }}_{}❘{ℱ}_L\right]·\mathrm{Pr}\left[{ℱ}_{L\bigcup \left\{i\right\}}❘{ℱ}_L\right]+\mathrm{Pr}\left[⫬{ℱ}_{L\bigcup \left\{i\right\}}❘{ℱ}_L\right]·\mathrm{Pr}\left[{I^{\prime }}_{}❘{ℱ}_L\right]\times \mathrm{Pr}\left[h\left(i\right)=j❘⫬{ℱ}_{L\bigcup \left\{i\right\}},{ℱ}_L,{I^{\prime }}_{}\right].$

Note Pr[_L∪{i}|_L]≦[_L∪{i}]/Pr[_L]=ρ′_i/(1−ρ) for ρ′_i=1−Pr[_L∪{i}]. Also, Pr[_L∪{i}|_L]≧Pr[_L∪{i}] since Pr[_L∪{i}] is a weighted average of Pr[_L∪{i}|_L] and Pr[_L∪{i}|_L], and the latter is 0. This for some ρ″_i∈[0, ρ′_i] EQ. (4) is

$\frac{R}{I}·\sum _{j\in I}\sum _{i\notin L}{x}_i·\left(\frac{1-{\rho }_i^{″}}{R}\pm \frac{{\rho }_i^{\prime }}{1-\rho }\right)={x_{\mathrm{tail}}}_1-\sum _{i\notin L}{\rho }_i^{″}{x}_i\pm \left(\frac{{\max }_i{\rho }_i^{\prime }}{1-\rho }\right)·R·{x_{\mathrm{tail}}}_1.$

By the setting of c=2 when picking the hash family of Theorem 1 in Step 3, ρ, ρ′_i, ρ″_i=O(∈³)) for all I, and thus ρ′_i=I (1−ρ)·R=O(∈), implying the above is (1±O(∈))∥x_tail∥₁. Plugging this into EQ. 3 then shows that the desired expectation is (1±O(∈))∥x_tail∥₁.

The expected variance of (R/|I|)·Σ_j∈I{tilde over (L)}₁(j) is now bound.

LEMMA 8: Conditioned on HH being correct,

$E_h\left[{\mathrm{Var}}_A\left[\frac{R}{I}·\sum _{j\in I}^R{\tilde{L}}_1\left(j\right)\right]\right]=O\left({\varepsilon }^2·{x}_1^2\right).$

PROOF: For any fixed h, R/|I| is determined and the {tilde over (L)}₁(j) are pairwise independent. Thus for fixed h,

${\mathrm{Var}}_A\left[\frac{R}{I}·\sum _{j\in I}{\tilde{L}}_1\left(j\right)\right]={\left(\frac{R}{I}\right)}^2·\sum _{j\in I}{\mathrm{Var}}_A\left[{\tilde{L}}_1\left(j\right)\right].$

First observe that since |I|≧R−|L|≧2/∈², for any choice of h R/|I|≦2. Thus, up to a constant factor, the expectation that is trying to be computed is

$E_h\left[{\mathrm{Var}}_A\left[\sum _{j\in I}{\tilde{L}}_1\left(j\right)\right]\right].$ For notational convenience, {tilde over (L)}₁(j)=0 if j≠I. Now see FIG. 11. Now consider the quantity Pr_h[h(i)=j|j∈I]. Then Pr_h[h(i)=j|j∈I] is equal to that shown in FIG. 12. Then by Bayes' theorem, what is shown in FIG. 12 is at most that which is shown in FIG. 13. Note that |L|/R≦1/2. Also, by choice of c, z I the application of Theorem 1 in step 3, Pr[_L]=1−O(∈) and Pr[_L∪{i}]=O(1/R²). Thus overall Pr_h[h(i)=j|j∈I]=O(1/R).

An essentially identical calculation, but conditioning on _L∪{i,i′} instead of _L∪{i}, gives that Pr_h[(h(i)=j)(h(i′)=j)|j∈I]=O(1/R²). Combining these bounds with Eq. 5, the expected variance that is trying to be computed is O(∥x∥_tail∥₂²+∥x_tail|₁²/R).

The second summand is O(∈²∥x∥₁²). For the first summand, conditioned on HH being correct, every |x_i| for i∉L has |x_i|≦∈²∥x∥₁. Under this constraint, ∥x_tail∥₂² maximized when there are exactly 1/∈² coordinates i∈L each with |x_i|=∈²∥x∥₁ in which case ∥x_tail|₂²=∈²∥x∥₁².

The proof of correctness of the full algorithm shown in FIG. 7 will now be completed as follows. Conditioning is done on the event ∈_HH that HH succeeds, i.e., satisfies the three conditions of Definition 4. Given this, conditioning is done on the event ∈_F that F succeeds as defined by Theorem 3, i.e., that Φ=∥x_head∥₁±∥x∥₁.

Next, the quantity

$X=\frac{R}{I}·\sum _{j\in I}{\tilde{L}}_1\left(j\right)$ is looked at.

By Lemma 7, E[X], even conditioned on the randomness used by HH to determined L, is (1±O(∈))∥x_tail∥₁. Also conditioned on ∈_HH the expected value of Var[X] for a random h is O(∈²∥x∥₁²). Since Var[X] is always non-negative, Markov's bound applies and Var[X]=O(∈²∥x∥₁²) with probability at least 19/20 (over the randomness in selecting h).

Thus, by Chebyshev's inequality,

$\begin{array}{cc}{\mathrm{Pr}}_{A,h}\left[X-E\left[X\right]>t\varepsilon {x}_1❘{\mathrm{HH}}_{}\right]<\frac{1}{20}+O\left(1/t^2\right),& \left(\mathrm{EQ}.6\right)\end{array}$ which can be made at most 1/15 by setting t a sufficiently large constant. Call the event in EQ. 6 . Then, as long as _HH, _F, occur, the final estimate of ∥x∥₁ is (1±O(∈))(∥x_tail∥₁+∥x_head∥₁±O(∈∥x∥₁)=(1±O∈∥x∥₁) as desired. The probability of correctness is then at least that shown in FIG. 14.

Remark 9: It is known from previous work, that each A_i[j] can be maintained up to only O(log(n/∈)) bits of precision, and requires the same amount of randomness to generate, to preserve the probability of correctness to within an arbitrarily small constant. Then, note that the counters B_i[j] each only consume O(log(nmM/∈)) bits of storage.

Given Remark 9, the following theorem is given.

Theorem 10: Ignoring the space to store the A_i[j], the overall space required for the algorithm of FIG. 7 is O((∈⁻² log(nmM/∈)+log log(n))log(1/∈)+HHSpace(∈²). The update time and reporting times are, respectively, O(log(1/∈))+HHUpdate(∈²), and O(∈⁻² log(1/∈)+HHReport (∈²).PROOF: Ignoring F and HH, the update time is O(1) to compute h, and O(1) to update the corresponding B_h(i). Also ignoring F and HH, the space required is O(∈⁻² log(nmM/∈)) to store all the B_i[j] (Remark 9), and O(∈⁻² log(1/∈+log log(n)) bits to store h and randomly select the hash family it comes from (Theorem 1). The time to compute the final line in the estimator, given L and ignoring the time to compute Φ, is O(1/∈). The bounds stated above then take into account the complexities of F and HH.

Derandomizing the Final Algorithm

Observe that a naive implementation of storing the entire tuple A in FIG. 7 requires Ω(n log(n/∈)) bits. Considering that one goal is to have a small-space algorithm, this is clearly not affordable. As it turns out, using a now standard technique in streaming algorithms, one can avoid storing the tuple A explicitly. This is accomplished by generating A from a short, truly random seed which is then stretched out by a pseudorandom generator against space-bounded computation. In Indyk's original argument, he used Nisan's PRG to show that his entire algorithm was fooled by using the PRG to stretch a short seed of length O(∈⁻² log(n/∈) log(nmM/∈)) to generate Θ(n/∈²) Cauchy random variables. However, for fooling this algorithm, this derandomization step used Ω(1/∈²) time during each stream update to generate the necessary Cauchy random variables from the seed. Given that another goal of one or more embodiments is to have fast update time, this is not desired. Therefore, to derandomize the final algorithm discussed above, Nisan's PRG can be applied in such a way that the time to apply the PRG to the seed to retrieve any A_i[j] is small.

First, recall the definition of a finite state machine (FSM). An FSM M is parameterized by a tuple (T_init, S, Γ, n). The FSM M is always in some “state”, which is just a string x{0, 1}^S, and it starts in the state T_init. The parameter Γ is a function mapping {0, 1}^S×{0, 1}ⁿ→{0, 1}^S. Notation is abused and for x({0, 1}ⁿ)^r for r a positive integer, Γ(T, x) is used to denote Γ( . . . (Γ(Γ(T, x₁), x₂), . . . ), x_r). Note that given a distribution D over ({0, 1}ⁿ)^r, there is an implied distribution M(D) over {0, 1}^S obtained as Γ(T_init, D).

DEFINITION 11: Let t be a positive integer. For D, D′ two distributions on {0,1}^t, the total variation distance Δ(D, D′) is defined by

$\Delta \left(D,D^{\prime }\right)=\underset{T⋐{\left\{0,1\right\}}^t}{\max }{\mathrm{Pr}}_{X-D}\left[X\in T\right]-{\mathrm{Pr}}_{Y\leftarrow D^{\prime }}\left[Y\in T\right].$

THEOREM 12. Let U^t denote the uniform distribution on {0, 1}^t. For any positive integers r, n, and for some S=Θ(n), there exists a function G_nisan=: {0,1}^s→({0, 1}ⁿ)^r with s=O(S log(r)) such that for any FSM M=(T_init,S,T,n), Δ(M((U_n)_r), M(G_nisan(U_S)))≦=2^−S.

Furthermore, for any x{0, 1}^s and i[r], computing the n-bit block G_nisan(x)i requires O(S log(r)) space and O(log(r)) arithmetic operations on O(S)-bit words.

Before finally describing how Theorem 12 fits into a de-randomization of FIG. 7, the following standard lemma is stated.

LEMMA 13: If X₁, . . . , X_m are independent and Y1, . . . , Y_m are independent, then

$\Delta \left(X_{1}x\dots {\mathrm{xX}}_m,Y_{1}x\dots {\mathrm{xY}}_m\right)\le \sum _{i=1}^m\Delta \left(X_i,Y_i\right).$

Now, the derandomization of FIG. 7 is as follows. Condition on all the randomness in FIG. 7 except for A. Recall that R=Θ(1/∈²) “buckets” B_u. Each bucket contains three counters, which is a sum of at most n Cauchy random variables, each weighted by at most mM. Given the precision required to store A (Remark 9), the three counters in B, in total consume S′=O(log(nmM/∈)) bits of space. Consider the FSM M_u which has 2^S states for S=S′+log(n), representing the state of the three counters together with an index i_cur[n] that starts at 0. Define t as the number of uniform random bits required to generate each A_i[j], so that t=O(log(nmM/∈)) by Remark 9. Note t=Θ(S). Consider the transition function Γ:{0, 1}^3t→{0, 1}^S defined as follows: upon being fed (A_i[1], A_i[2], A_i[3]) (or more precisely, the 3t uniform random bits used to generate this tuple), increment i_cur then add A_i[j]·x_i to each B_u[j], for i being the (i_cur)th index i[n] such that h(i)=u. Now, note that if one feeds the (A_i[1], A_i[2], A_i[3]) for which h(i)=u to M_u, sorted by i, then the state of M_u corresponds exactly to the state of bucket B_u in the algorithm.

By Theorem 12, if rather than defining A by 3tr truly random bits (for r=n) it is defined instead by stretching a seed of length s=O(S log(n))=O(log(nmM/∈) log(n)) via G_nisan, then the distribution on the state of B_u at the end of the stream changes by at most a total variation distance of 2^−S. Now, suppose R independent seeds are used to generate different A vectors in each of the R buckets. Note that since each index i[n] is hashed to exactly one bucket, the A_i[j] across each bucket need not be consistent to preserve the behavior of our algorithm. Then for U^t being the uniform distribution on {0, 1}^t,Δ(M₁(U^3t)^rx . . . xM_R(U^3t)^r M₁(G_nisan(U^S))x . . . xM_R(U^S)))≦R·2^−S by Lemma 13.

By increasing S by a constant factor, R·2^−S can be ensured to be an arbitrarily small constant δ. Now, note that the product measure on the output distributions of the M_u corresponds exactly to the state of the entire algorithm at the end of the stream. Thus, if one considers T to be the set of states (B₁, . . . , B_R) for which the algorithm outputs a value (1±∈)∥x∥₁ (i.e., is correct), by definition of total variation distance (Definition 11), the probability of correctness of the algorithm changes by at most an additive δ when using Nisan's PRG instead of uniform randomness. Noting that storing R independent seeds just takes R_s space, and that the time required to extract any A_i[j] from a seed requires O(log(n)) time by Theorem 12, then there is the following theorem.

THEOREM 14: Including the space and time complexities of storing and accessing the A_i[j], the algorithm of FIG. 7 can be implemented with an additive O(∈⁻² log(nmM/∈) log(n)) increase to the space, additive O(log(n)) increase to the update time, and no change to the reporting time, compared with the bounds given in Theorem 10.

Therefore, as can be seen from the above discussion, one or more embodiments provide 1-pass algorithm using ∈⁻² polylog(nmM) space for ₁-estimation in data streams with polylog(nmM) update time, and reporting time ∈² polylog(nmM). This algorithm is the first to be simultaneously optimal in both the space and the update time up to polylog(nmM) factors. Conventional algorithms either required at least ∈⁻³ polylog(nmM) bits of space, or at least ∈² update time. As ∈ can be arbitrarily small, the result of one or more embodiments can provide a substantial benefit over conventional algorithms. In light of known lower bounds, the space and time complexity of these one or more embodiments are optimal up to polylog(nmM) factors.

Operational Flow

FIG. 15 is an operational flow diagram illustrating one example of measuring the distance between two or more vectors. The operational flow diagram of FIG. 15 begins at step 1502 and flows directly to step 1504. The data stream analyzer 110, at step 1504, analyzes at least two vectors of n coordinates. The data stream analyzer 110, at step 1506, identifies a set of heavy coordinates from the set of n coordinates associated with the at least two vectors. The data stream analyzer 110, at step 1508, identifies a set of light coordinates from the set of n coordinates. The data stream analyzer 110, at step 1510, determines a first estimate of a contribution from the set of heavy coordinates to the ₁ distance between the at least two vectors. The data stream analyzer 110, at step 1512, determines a second estimate of a contribution from the set of light coordinates to the ₁ distance between the at least two vectors. The data stream analyzer 110, at step 1514, sums the first estimate and the second estimate. The control flow then exits at step 1516.

Non-Limiting Examples

Aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.), or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system. Also, aspects of the present invention have been discussed above with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.

The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.

Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium include computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. A computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).

The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiments above were chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.

Claims

1. An information processing system for determining a distance between at least two vectors of n coordinates, the information processing comprising: a memory;a processor communicatively coupled to the memory; anda data stream analyzer communicatively coupled to the memory and the processor, the data stream analyzing being configured to perform a method comprising:identifying a set of coordinates from a set of n coordinates associated with at least two vectors as a set of heavy coordinates, wherein a heavy coordinate is represented as |xi|≧∈2∥x∥1, where x is a vector, i is a coordinate in the set of n coordinates, and ∈ is an arbitrary number;identifying a set of coordinates from the set of n coordinates associated with the at least two vectors, as a set of light coordinates, wherein a light coordinate is represented as |xi|≧∈2∥x∥1;determining a first estimation of a contribution from the set of heavy coordinates to a rectilinear distance between the at least two vectors; wherein determining the first estimation comprises multiplying each of a set of stream updates by a subset of a set of constructed hash functions, wherein the subset is defined based on ∈2;determining a second estimation of a contribution from the set of light coordinates to the rectilinear distance, wherein determining the second estimation comprises multiplying each of a set of stream updates by a subset of the set of constructed hash functions, wherein the subset is defined based on ∈2, and wherein the second estimation is determined separate from the first estimation; andcombining the first estimation with the second estimation.

2. The information processing system of claim 1, wherein determining the first estimation comprises: maintaining a first data structure by: selecting a random sign vector σ∈{−1, 1}n from a 4-wise independent family;setting r=[27/∈2];select a hash function h: [n]→[r] from a family constructed randomly; andinitializing r counters b1, . . . , br;receiving an update in the form of (i, v), where v is a change to i; andadding σ(i)·v to bh(i).

3. The information processing system of claim 2, wherein determining the first estimation further comprises: maintaining a second data structure by: initializing s=[log 3(1/∈2)]+3 independent copies of the first data structure;given the update (i, v) adding σ(i)·v to bh(i) to each of the three copies of the first data structure.

4. The information processing system of claim 2, wherein a space complexity of the second data structure is O(∈−2 log(1/∈)log(mM)+log(1/∈)log log n), where O is where O represents a constant C that is independent of n, m is a number of updates from a set [n]×{−M, . . . , M}, and where an update time of the second data structure is O(log(1/∈)).

5. The information processing system of claim 3, wherein the first estimation is equal to

6. The information processing system of claim 3, wherein determining the second estimation comprises: maintaining R=Θ(1/∈2) buckets Bi in parallel with the second data structure;mapping each i in [n] to exactly one bucket i∈[R], wherein the ith bucket keeps track of a dot product of x, restricted to those indices hashed to i, with three random Cauchy vectors;calculating a geometric mean of each bucket corresponding to the set of light coordinates; andsumming the geometric mean calculating each bucket.

7. The information processing system of claim 6, wherein the heavy coordinates are identified using a CountMin sketch algorithm, and wherein the set of light coordinates are identified as a set of buckets from the R=Θ(1/∈2) buckets failing to comprise any heavy coordinates.

8. A computer program product for determining a distance between at least two vectors of n coordinates comprising: a non-transitory computer readable storage medium having computer readable program code embodied therewith, the computer readable program code configured to perform a method comprising:

9. The computer program product of claim 8, wherein determining the first estimation comprises: maintaining a first data structure by: selecting a random sign vector σ∈{−1, 1}n from a 4-wise independent family;setting r=[27/∈2];select a hash function h: [n]→[r] from a family constructed randomly; andinitializing r counters b1, . . . , br;receiving an update in the form of (i, v), where v is a change to i; andadding σ(i) v to bh(i).

10. The computer program product of claim 9, wherein determining the first estimation further comprises: maintaining a second data structure by: initializing s=[log 3(1/∈2)]+3 independent copies of the first data structure;given the update (i, v) adding σ(i)·v to bh(i) to each of the three copies of the first data structure.

11. The computer program product of claim 9, wherein a space complexity of the second data structure is O(∈−2 log(1/∈)log(mM)+log(1/∈)log log n), where O is where O represents a constant C that is independent of n, m is a number of updates from a set [n]×{−M, . . . , M}, and where an update time of the second data structure is O(log(1/∈)).

12. The computer program product of claim 10, wherein determining the second estimation comprises: maintaining R=Θ(1/∈2) buckets Bi in parallel with the second data structure;mapping each i in [n] to exactly one bucket i∈[R], wherein the ith bucket keeps track of a dot product of x, restricted to those indices hashed to i, with three random Cauchy vectors;calculating a geometric mean of each bucket corresponding to the set of light coordinates; andsumming the geometric mean calculating each bucket.

13. The information processing system of claim 12, wherein the heavy coordinates are identified using a CountMin sketch algorithm, and wherein the set of light coordinates are identified as a set of buckets from the R=Θ(1/∈2) buckets failing to comprise any heavy coordinates.