We explore in this chapter questions of existence and uniqueness for solutions to stochastic differential equations and offer a study of their properties. This endeavor is really a study of diffusion processes. Loosely speaking, the term diffusion is attributed to a Markov process which has continuous sample paths and can be characterized in terms of its infinitesimal generator.

Stochastic Differential Equations

As companies strive to develop artefacts intended for services instead of traditional sell-off, new challenges in the product development process arise to promote continuous improvement and increasing market profits. This creates a focus on product life-cycle components as companies then make life-cycle commitments, where they are responsible for the function availability during the extent of the life-cycle, i.e. functional products. One of these life-cycle components is manufacturing; therefore, companies search for new approaches of success during manufacturability evaluation already in engineering design. Efforts have been done to support early engineering design, as this phase sets constraints and opportunities for manufacturing. These efforts have turned into design for manufacturing methods and guidelines. A further step to improve the life-cycle focus during early engineering design is to reuse results and use experience from earlier projects. However, because results and experiences created during project work are often not documented for reuse, only remembered by some people, there is a need for design support. Knowledge engineering (KE) is a methodology for creating knowledge-based systems, e.g. systems that enable reuse of earlier results and make available both explicit and tacit corporate knowledge, enabling the automated generation and evaluation of new engineering design solutions during early product development. There are a variety of KE-approaches, such as knowledge-based engineering, case-based reasoning and programming, which have been used in research to develop design for manufacturing methods and applications. There are, however, opportunities for research where several approaches and their interdependencies, to create a transparent picture of how KE can be used to support engineering design, are investigated. The aim of the research presented in this thesis is to create new methods for design for manufacturing, by using several approaches of KE, and find the beneficial and less beneficial aspects of these methods in comparison to each other and earlier research. This thesis presents methods and applications for design for manufacturing using KE. KE has been employed in several ways, namely rule-based, rule-, programmingand finite element analysis (FEA)-based, and ruleand plan-based, which are tested and compared with each other. Results show that KE can be used to generate information about manufacturing in several ways. The rule-based way is suitable for supporting life-cycle commitments, as engineering design and manufacturing can be integrated with maintenance and performance predictions during early engineering design, though limited to the firing of production rules. The rule-, programmingand FEA-based way can be used to integrate computer-aided design tools and virtual manufacturing for non-linear stress and displacement analysis. This way may also bridge the gap between engineering designers and computational experts, even though this way requires a larger effort to program than the rule-based. The ruleand planbased way can enable design for manufacturing in two fashions – based on earlier manufacturing plans and based on rules. Because earlier manufacturing plans, together with programming algorithms, can handle knowledge that may be more intricate to capture as rules, as opposed to the time demanding routine work that is often automated by means of rules, several opportunities for designing for manufacturing exist.

Methods and Applications

We construct a stream-cipher S whose implementation is secure even if a bounded amount of arbitrary (adversarially chosen) information on the internal state ofS is leaked during computation. This captures all possible side-channel attacks on S where the amount of information leaked in a given period is bounded, but overall can be arbitrary large. The only other assumption we make on the implementation of S is that only data that is accessed during computation leaks information. The stream-cipher S generates its output in chunks K1, K2, . . . and arbitrary but bounded information leakage is modeled by allowing the adversary to adaptively chose a function fl : {0,1}* rarr {0, 1}lambda before Kl is computed, she then gets fl(taul) where taul is the internal state ofS that is accessed during the computation of Kg. One notion of security we prove for S is that Kg is indistinguishable from random when given K1,..., K1-1,f1(tau1 ),..., fl-1(taul-1) and also the complete internal state of S after Kg has been computed (i.e. S is forward-secure). The construction is based on alternating extraction (used in the intrusion-resilient secret-sharing scheme from FOCS'07). We move this concept to the computational setting by proving a lemma that states that the output of any PRG has high HILLpseudoentropy (i.e. is indistinguishable from some distribution with high min-entropy) even if arbitrary information about the seed is leaked. The amount of leakage lambda that we can tolerate in each step depends on the strength of the underlying PRG, it is at least logarithmic, but can be as large as a constant fraction of the internal state of S if the PRG is exponentially hard.

/pdf/leakage-resilient-cryptography-15i0byrphr.pdf

Leakage-Resilient Cryptography

Network management requires accurate estimates of metrics for traffic engineering (e.g., heavy hitters), anomaly detection (e.g., entropy of source addresses), and security (e.g., DDoS detection). Obtaining accurate estimates given router CPU and memory constraints is a challenging problem. Existing approaches fall in one of two undesirable extremes: (1) low fidelity general-purpose approaches such as sampling, or (2) high fidelity but complex algorithms customized to specific application-level metrics. Ideally, a solution should be both general (i.e., supports many applications) and provide accuracy comparable to custom algorithms. This paper presents UnivMon, a framework for flow monitoring which leverages recent theoretical advances and demonstrates that it is possible to achieve both generality and high accuracy. UnivMon uses an application-agnostic data plane monitoring primitive; different (and possibly unforeseen) estimation algorithms run in the control plane, and use the statistics from the data plane to compute application-level metrics. We present a proof-of-concept implementation of UnivMon using P4 and develop simple coordination techniques to provide a ``one-big-switch'' abstraction for network-wide monitoring. We evaluate the effectiveness of UnivMon using a range of trace-driven evaluations and show that it offers comparable (and sometimes better) accuracy relative to custom sketching solutions.

https://dl.acm.org/doi/pdf/10.1145/2934872.2934906

One Sketch to Rule Them All: Rethinking Network Flow Monitoring with UnivMon

Over the last decade, there has been considerable interest in designing algorithms for processing massive graphs in the data stream model. The original motivation was two-fold: a) in many applications, the dynamic graphs that arise are too large to be stored in the main memory of a single machine and b) considering graph problems yields new insights into the complexity of stream computation. However, the techniques developed in this area are now finding applications in other areas including data structures for dynamic graphs, approximation algorithms, and distributed and parallel computation. We survey the state-of-the-art results; identify general techniques; and highlight some simple algorithms that illustrate basic ideas.

/pdf/graph-stream-algorithms-a-survey-1m1oq4kh5y.pdf

Graph stream algorithms: a survey

Given a stream p1, …, pm of items from a universe U, which, without loss of generality we identify with the set of integers {1, 2, …, n}, we consider the problem of returning all l2-heavy hitters, i.e., those items j for which fj ≥ є √F2, where fj is the number of occurrences of item j in the stream, and F2 = ∑i ∈ [n] fi2. Such a guarantee is considerably stronger than the l1-guarantee, which finds those j for which fj ≥ є m. In 2002, Charikar, Chen, and Farach-Colton suggested the CountSketch data structure, which finds all such j using Θ(log2 n) bits of space (for constant є > 0). The only known lower bound is Ω(logn) bits of space, which comes from the need to specify the identities of the items found. In this paper we show one can achieve O(logn loglogn) bits of space for this problem. Our techniques, based on Gaussian processes, lead to a number of other new results for data streams, including: (1) The first algorithm for estimating F2 simultaneously at all points in a stream using only O(lognloglogn) bits of space, improving a natural union bound. (2) A way to estimate the l∞ norm of a stream up to additive error є √F2 with O(lognloglogn) bits of space, resolving Open Question 3 from the IITK 2006 list for insertion only streams.

https://dl.acm.org/doi/pdf/10.1145/2897518.2897558

Beating CountSketch for heavy hitters in insertion streams

Lock managers are widely used by distributed systems. Traditional centralized lock managers can easily support policies between multiple users using global knowledge, but they suffer from low performance. In contrast, emerging decentralized approaches are faster but cannot provide flexible policy support. Furthermore, performance in both cases is limited by the server capability. We present NetLock, a new centralized lock manager that co-designs servers and network switches to achieve high performance without sacrificing flexibility in policy support. The key idea of NetLock is to exploit the capability of emerging programmable switches to directly process lock requests in the switch data plane. Due to the limited switch memory, we design a memory management mechanism to seamlessly integrate the switch and server memory. To realize the locking functionality in the switch, we design a custom data plane module that efficiently pools multiple register arrays together to maximize memory utilization We have implemented a NetLock prototype with a Barefoot Tofino switch and a cluster of commodity servers. Evaluation results show that NetLock improves the throughput by 14.0-18.4x, and reduces the average and 99% latency by 4.7-20.3x and 10.4-18.7x over DSLR, a state-of-the-art RDMA-based solution, while providing flexible policy support.

https://dl.acm.org/doi/pdf/10.1145/3387514.3405857

NetLock: Fast, Centralized Lock Management Using Programmable Switches

The problem of (approximately) counting the number of triangles in a graph is one of the basic problems in graph theory. In this paper we study the problem in the streaming model. Specifically, the amount of memory required by a randomized algorithm to solve this problem. In case the algorithm is allowed one pass over the stream, we present a best possible lower bound of Ω(m) for graphs G with m edges. If a constant number of passes is allowed, we show a lower bound of Ω(m/T), T the number of triangles. We match, in some sense, this lower bound with a 2-pass O(m/T1/3)-memory algorithm that solves the problem of distinguishing graphs with no triangles from graphs with at least T triangles. We present a new graph parameter ρ(G) --- the triangle density, and conjecture that the space complexity of the triangles problem is Θ(m/ρ(G)). We match this by a second algorithm that solves the distinguishing problem using O(m/ρ(G))-memory.

How hard is counting triangles in the streaming model

We explore clustering problems in the streaming sliding window model in both general metric spaces and Euclidean space. We present the first polylogarithmic space O(1)-approximation to the metric k-median and metric k-means problems in the sliding window model, answering the main open problem posed by Babcock, Datar, Motwani and O'Callaghan [5], which has remained unanswered for over a decade. Our algorithm uses O(k3log6W) space and poly(k, log W) update time, where W is the window size. This is an exponential improvement on the space required by the technique due to Babcock, et al. We introduce a data structure that extends smooth histograms as introduced by Braverman and Ostrovsky [11] to operate on a broader class of functions. In particular, we show that using only polylogarithmic space we can maintain a summary of the current window from which we can construct an O(1)-approximate clustering solution.Merge-and-reduce is a generic method in computational geometry for adapting offline algorithms to the insertion-only streaming model. Several well-known coreset constructions are maintainable in the insertion-only streaming model using this method, including well-known coreset techniques for the k-median and k-means problems in both low-and high-dimensional Euclidean spaces [31, 15]. Previous work [27] has adapted coreset techniques to the insertion-deletion model, but translating them to the sliding window model has remained a challenge. We give the first algorithm that, given an insertion-only streaming coreset of space s (maintained using merge-and-reduce method), maintains this coreset in the sliding window model using O(s2e--2 log W) space.For clustering problems, our results constitute the first significant step towards resolving problem number 20 from the List of Open Problems in Sublinear Algorithms [39].

Clustering problems on sliding windows

In a ground-breaking paper, Indyk and Woodruff (STOC 05) showed how to compute $F_k$ (for $k>2$) in space complexity $O(\mbox{\em poly-log}(n,m)\cdot n^{1-\frac2k})$, which is optimal up to (large) poly-logarithmic factors in $n$ and $m$, where $m$ is the length of the stream and $n$ is the upper bound on the number of distinct elements in a stream The best known lower bound for large moments is $\Omega(\log(n)n^{1-\frac2k})$ A follow-up work of Bhuvanagiri, Ganguly, Kesh and Saha (SODA 2006) reduced the poly-logarithmic factors of Indyk and Woodruff to $O(\log^2(m)\cdot (\log n+ \log m)\cdot n^{1-{2\over k}})$ Further reduction of poly-log factors has been an elusive goal since 2006, when Indyk and Woodruff method seemed to hit a natural "barrier" Using our simple recursive sketch, we provide a different yet simple approach to obtain a $O(\log(m)\log(nm)\cdot (\log\log n)^4\cdot n^{1-{2\over k}})$ algorithm for constant $\epsilon$ (our bound is, in fact, somewhat stronger, where the $(\log\log n)$ term can be replaced by any constant number of $\log $ iterations instead of just two or three, thus approaching $log^*n$ Our bound also works for non-constant $\epsilon$ (for details see the body of the paper) Further, our algorithm requires only $4$-wise independence, in contrast to existing methods that use pseudo-random generators for computing large frequency moments

Vladimir Braverman

Papers

Beating CountSketch for heavy hitters in insertion streams

NetLock: Fast, Centralized Lock Management Using Programmable Switches

How hard is counting triangles in the streaming model

Clustering problems on sliding windows

Recursive Sketching For Frequency Moments