OpenRaiser/Intern-Atlas huggingface dataset:
Feedback Capacity of Gaussian Channels Revisited
Venue: arXiv cs.IT 2019
Year: 2019

In this paper, we revisit the problem of finding the average capacity of the Gaussian feedback channel. First, we consider the problem of finding the average capacity of the analog Gaussian noise channel where the noise has an arbitrary spectral density. We introduce a new approach to the problem where we solve the problem over a finite number of transmissions and then consider the limit of an infinite number of transmissions. Further, we consider the important special case of stationary Gaussian noise with finite memory. We show that the channel capacity at stationarity can be found by solving a semi-definite program, and hence computationally tractable. We also give new proofs and results of the non stationary solution which bridges the gap between results in the literature for the stationary and non stationary feedback channel capacities. It's shown that a linear communication feedback strategy is optimal. Similar to the solution of the stationary problem, it's shown that the optimal linear strategy is to transmit a linear combination of the information symbols to be communicated and the innovations for the estimation error of the state of the noise process.
Computing the Geometric Intersection Number of Curves
Venue: arXiv cs.CG 2019
Year: 2019

The geometric intersection number of a curve on a surface is the minimal number of self-intersections of any homotopic curve, i.e. of any curve obtained by continuous deformation. Given a curve $c$ represented by a closed walk of length at most $\ell$ on a combinatorial surface of complexity $n$ we describe simple algorithms to (1) compute the geometric intersection number of $c$ in $O(n+ \ell^2)$ time, (2) construct a curve homotopic to $c$ that realizes this geometric intersection number in $O(n+\ell^4)$ time, (3) decide if the geometric intersection number of $c$ is zero, i.e. if $c$ is homotopic to a simple curve, in $O(n+\ell\log\ell)$ time. The algorithms for (2) and (3) are restricted to orientable surfaces, but the algorithm for (1) is also valid on non-orientable surfaces. To our knowledge, no exact complexity analysis had yet appeared on those problems. An optimistic analysis of the complexity of the published algorithms for problems (1) and (3) gives at best a $O(n+g^2\ell^2)$ time complexity on a genus $g$ surface without boundary. No polynomial time algorithm was known for problem (2) for surfaces without boundary. Interestingly, our solution to problem (3) provides a quasi-linear algorithm to a problem raised by Poincaré more than a century ago. Finally, we note that our algorithm for problem (1) extends to computing the geometric intersection number of two curves of length at most $\ell$ in $O(n+ \ell^2)$ time.
On Distributed Cooperative Decision-Making in Multiarmed Bandits
Venue: arXiv cs.SY 2019
Year: 2019

We study the explore-exploit tradeoff in distributed cooperative decision-making using the context of the multiarmed bandit (MAB) problem. For the distributed cooperative MAB problem, we design the cooperative UCB algorithm that comprises two interleaved distributed processes: (i) running consensus algorithms for estimation of rewards, and (ii) upper-confidence-bound-based heuristics for selection of arms. We rigorously analyze the performance of the cooperative UCB algorithm and characterize the influence of communication graph structure on the decision-making performance of the group.
Strong Secrecy for Cooperative Broadcast Channels
Venue: arXiv cs.IT 2019
Year: 2019

A broadcast channel (BC) where the decoders cooperate via a one-sided link is considered. One common and two private messages are transmitted and the private message to the cooperative user should be kept secret from the cooperation-aided user. The secrecy level is measured in terms of strong secrecy, i.e., a vanishing information leakage. An inner bound on the capacity region is derived by using a channel-resolvability-based code that double-bins the codebook of the secret message, and by using a likelihood encoder to choose the transmitted codeword. The inner bound is shown to be tight for semi-deterministic and physically degraded BCs and the results are compared to those of the corresponding BCs without a secrecy constraint. Blackwell and Gaussian BC examples illustrate the impact of secrecy on the rate regions. Unlike the case without secrecy, where sharing information about both private messages via the cooperative link is optimal, our protocol conveys parts of the common and non-confidential messages only. This restriction reduces the transmission rates more than the usual rate loss due to secrecy requirements. An example that illustrates this loss is provided.
Reachability Oracles for Directed Transmission Graphs
Venue: arXiv cs.CG 2019
Year: 2019

Let $P \subset \mathbb{R}^d$ be a set of $n$ points in $d$ dimensions such that each point $p \in P$ has an associated radius $r_p > 0$. The transmission graph $G$ for $P$ is the directed graph with vertex set $P$ such that there is an edge from $p$ to $q$ if and only if $|pq| \leq r_p$, for any $p, q \in P$. A reachability oracle is a data structure that decides for any two vertices $p, q \in G$ whether $G$ has a path from $p$ to $q$. The quality of the oracle is measured by the space requirement $S(n)$, the query time $Q(n)$, and the preprocessing time. For transmission graphs of one-dimensional point sets, we can construct in $O(n \log n)$ time an oracle with $Q(n) = O(1)$ and $S(n) = O(n)$. For planar point sets, the ratio $Ψ$ between the largest and the smallest associated radius turns out to be an important parameter. We present three data structures whose quality depends on $Ψ$: the first works only for $Ψ< \sqrt{3}$ and achieves $Q(n) = O(1)$ with $S(n) = O(n)$ and preprocessing time $O(n\log n)$; the second data structure gives $Q(n) = O(Ψ^3 \sqrt{n})$ and $S(n) = O(Ψ^3 n^{3/2})$; the third data structure is randomized with $Q(n) = O(n^{2/3}\log^{1/3} Ψ\log^{2/3} n)$ and $S(n) = O(n^{5/3}\log^{1/3} Ψ\log^{2/3} n)$ and answers queries correctly with high probability.
Weyl Spreading Sequence Optimizing CDMA
Venue: arXiv cs.IT 2019
Year: 2019

This paper shows an optimal spreading sequence in the Weyl sequence class, which is similar to the set of the Oppermann sequences for asynchronous CDMA systems. Sequences in Weyl sequence class have the desired property that the order of cross-correlation is low. Therefore, sequences in the Weyl sequence class are expected to minimize the inter-symbol interference. We evaluate the upper bound of cross-correlation and odd cross-correlation of spreading sequences in the Weyl sequence class and construct the optimization problem: minimize the upper bound of the absolute values of cross-correlation and odd cross-correlation. Since our optimization problem is convex, we can derive the optimal spreading sequences as the global solution of the problem. We show their signal to interference plus noise ratio (SINR) in a special case. From this result, we propose how the initial elements are assigned, that is, how spreading sequences are assigned to each users. In an asynchronous CDMA system, we also numerically compare our spreading sequences with other ones, the Gold codes, the Oppermann sequences, the optimal Chebyshev spreading sequences and the SP sequences in Bit Error Rate. Our spreading sequence, which yields the global solution, has the highest performance among the other spreading sequences tested.
A theory of contemplation
Venue: arXiv cs.AI 2019
Year: 2019

In this paper you can explore the application of some notable Boolean-derived methods, namely the Disjunctive Normal Form representation of logic table expansions, and extend them to a real-valued logic model which is able to utilize quantities on the range [0,1], [-1,1], [a,b], (x,y), (x,y,z), and etc. so as to produce a logical programming of arbitrary range, precision, and dimensionality, thereby enabling contemplation at a logical level in notions of arbitrary data, colors, and spatial constructs, with an example of the production of a game character's logic in mathematical form.
A Time-Space Trade-off for Computing the k-Visibility Region of a Point in a Polygon
Venue: arXiv cs.CG 2019
Year: 2019

Let $P$ be a simple polygon with $n$ vertices, and let $q \in P$ be a point in $P$. Let $k \in \{0, \dots, n - 1\}$. A point $p \in P$ is $k$-visible from $q$ if and only if the line segment $pq$ crosses the boundary of $P$ at most $k$ times. The $k$-visibility region of $q$ in $P$ is the set of all points that are $k$-visible from $q$. We study the problem of computing the $k$-visibility region in the limited workspace model, where the input resides in a random-access read-only memory of $O(n)$ words, each with $Ω(\log{n})$ bits. The algorithm can read and write $O(s)$ additional words of workspace, where $s \in \mathbb{N}$ is a parameter of the model. The output is written to a write-only stream. Given a simple polygon $P$ with $n$ vertices and a point $q \in P$, we present an algorithm that reports the $k$-visibility region of $q$ in $P$ in $O(cn/s+c\log{s} + \min\{\lceil k/s \rceil n,n \log{\log_s{n}}\})$ expected time using $O(s)$ words of workspace. Here, $c \in \{1, \dots, n\}$ is the number of critical vertices of $P$ for $q$ where the $k$-visibility region of $q$ may change. We generalize this result for polygons with holes and for sets of non-crossing line segments.
Efficient Containment of Exact SIR Markovian Processes on Networks
Venue: arXiv cs.SI 2019
Year: 2019

This paper introduces a theoretical framework for the analysis and control of the stochastic susceptible-infected-removed (SIR) spreading process over a network of heterogeneous agents. In our analysis, we analyze the exact networked Markov process describing the SIR model, without resorting to mean-field approximations, and introduce a convex optimization framework to find an efficient allocation of resources to contain the expected number of accumulated infections over time. Numerical simulations are presented to illustrate the effectiveness of the obtained results.
A Markov Chain Algorithm for Compression in Self-Organizing Particle Systems
Venue: arXiv cs.DC 2019
Year: 2019

In systems of programmable matter, we are given a collection of simple computation elements (or particles) with limited (constant-size) memory. We are interested in when they can self-organize to solve system-wide problems of movement, configuration and coordination. Here, we initiate a stochastic approach to developing robust distributed algorithms for programmable matter systems using Markov chains. We are able to leverage the wealth of prior work in Markov chains and related areas to design and rigorously analyze our distributed algorithms and show that they have several desirable properties. We study the compression problem, in which a particle system must gather as tightly together as possible, as in a sphere or its equivalent in the presence of some underlying geometry. More specifically, we seek fully distributed, local, and asynchronous algorithms that lead the system to converge to a configuration with small boundary. We present a Markov chain-based algorithm that solves the compression problem under the geometric amoebot model, for particle systems that begin in a connected configuration. The algorithm takes as input a bias parameter $λ$, where $λ> 1$ corresponds to particles favoring having more neighbors. We show that for all $λ> 2+\sqrt{2}$, there is a constant $α> 1$ such that eventually with all but exponentially small probability the particles are $α$-compressed, meaning the perimeter of the system configuration is at most $α\cdot p_{min}$, where $p_{min}$ is the minimum possible perimeter of the particle system. Surprisingly, the same algorithm can also be used for expansion when $0 < λ< 2.17$, and we prove similar results about expansion for values of $λ$ in this range. This is counterintuitive as it shows that particles preferring to be next to each other ($λ> 1$) is not sufficient to guarantee compression.
Effect of Jitter on the Settling Time of Mesochronous Clock Retiming Circuits
Venue: arXiv cs.ET 2019
Year: 2019

It is well known that timing jitter can degrade the bit error rate (BER) of receivers that recover the clock from input data. However, timing jitter can also result in an indefinite increase in the settling time of clock recovery circuits, particularly in low swing mesochronous systems. Mesochronous clock retiming circuits are required in repeaterless low swing on-chip interconnects. We first discuss how timing jitter can result in a large increase in the settling time of the clock recovery circuit. Next, the circuit is modelled as a Markov chain with absorbing states. The mean time to absorption of the Markov chain, which represents the mean settling time of the circuit, is determined. The model is validated through behavioural simulations of the circuit, the results of which match well with the model predictions. We consider circuits with (i) data dependent jitter, (ii) random jitter, and (iii) combination of both of them. We show that a mismatch between the strengths of up and down corrections of the retiming can reduce the settling time. In particular, a 10% mismatch can reduce the mean settling time by up to 40%. We leverage this fact toward improving the settling time performance, and propose useful techniques based on biased training sequences and mismatched charge pumps. We also present a coarse+fine clock retiming circuit, which can operate in coarse first mode, to reduce the settling time substantially. These fast settling retiming circuits are verified with circuit simulations.
Dual-Timescale Spectrum Management in Small-Cell Wireless Networks
Venue: arXiv cs.IT 2019
Year: 2019

To attain the targeted data rates of next generation cellular networks requires dense deployment of small cells in addition to macro cells which provide wide coverage. Dynamic radio resource management is crucial to the success of such heterogeneous networks due to much more pronounced traffic and interference variations in small cells. This work proposes a framework for spectrum management organized according to two timescales, which include 1) centralized optimization on a moderate timescale corresponding to typical duration of user sessions (several seconds to minutes in today's networks), and 2) distributed spectrum allocation on a fast timescale corresponding to typical latency requirements (a few milliseconds). An optimization problem is formulated to allocate resources on the slower timescale with consideration of (distributed) opportunistic scheduling on the faster timescale. Both fixed and fully flexible user association schemes are considered. Iterative algorithms are developed to solve these optimization problems efficiently for a cluster of cells with guaranteed convergence. Simulation results demonstrate advantages of the proposed framework and algorithms.
h-Index Manipulation by Undoing Merges
Venue: arXiv cs.DL 2019
Year: 2019

The h-index is an important bibliographic measure used to assess the performance of researchers. Dutiful researchers merge different versions of their articles in their Google Scholar profile even though this can decrease their h-index. In this article, we study the manipulation of the h-index by undoing such merges. In contrast to manipulation by merging articles (van Bevern et al. [Artif. Intel. 240:19-35, 2016]) such manipulation is harder to detect. We present numerous results on computational complexity (from linear-time algorithms to parameterized computational hardness results) and empirically indicate that at least small improvements of the h-index by splitting merged articles are unfortunately easily achievable.
Learning Unknown Service Rates in Queues: A Multi-Armed Bandit Approach
Venue: arXiv cs.SY 2019
Year: 2019

Consider a queueing system consisting of multiple servers. Jobs arrive over time and enter a queue for service; the goal is to minimize the size of this queue. At each opportunity for service, at most one server can be chosen, and at most one job can be served. Service is successful with a probability (the service probability) that is a priori unknown for each server. An algorithm that knows the service probabilities (the "genie") can always choose the server of highest service probability. We study algorithms that learn the unknown service probabilities. Our goal is to minimize queue-regret: the (expected) difference between the queue-lengths obtained by the algorithm, and those obtained by the "genie." Since queue-regret cannot be larger than classical regret, results for the standard multi-armed bandit problem give algorithms for which queue-regret increases no more than logarithmically in time. Our paper shows surprisingly more complex behavior. In particular, as long as the bandit algorithm's queues have relatively long regenerative cycles, queue-regret is similar to cumulative regret, and scales (essentially) logarithmically. However, we show that this "early stage" of the queueing bandit eventually gives way to a "late stage", where the optimal queue-regret scaling is $O(1/t)$. We demonstrate an algorithm that (order-wise) achieves this asymptotic queue-regret in the late stage. Our results are developed in a more general model that allows for multiple job classes as well.
A Linear-Time Branching-Time Spectrum for Behavioral Specification Theories
Venue: arXiv cs.LO 2019
Year: 2019

We propose behavioral specification theories for most equivalences in the linear-time--branching-time spectrum. Almost all previous work on specification theories focuses on bisimilarity, but there is a clear interest in specification theories for other preorders and equivalences. We show that specification theories for preorders cannot exist and develop a general scheme which allows us to define behavioral specification theories, based on disjunctive modal transition systems, for most equivalences in the linear-time--branching-time spectrum.
Linear Depth Increase of Lambda Terms along Leftmost-Outermost Beta-Reduction
Venue: arXiv cs.LO 2019
Year: 2019

Performing $n$ steps of $β$-reduction to a given term in the $λ$-calculus can lead to an increase in the size of the resulting term that is exponential in $n$. The same is true for the possible depth increase of terms along a $β$-reduction sequence. We explain that the situation is different for the leftmost-outermost strategy for $β$-reduction: while exponential size increase is still possible, depth increase is bounded linearly in the number of steps. For every $λ$-term $M$ with depth $d$, in every step of a leftmost-outermost $β$-reduction rewrite sequence starting from $M$ the term depth increases by at most $d$. Hence the depth of the $n$-th reduct of $M$ in such a rewrite sequence is bounded by $d\cdot (n+1)$. We prove the lifting of this result to $λ$-term representations as orthogonal first-order term rewriting systems, which can be obtained by the lambda-lifting transformation. For the transfer to lambda-calculus, we rely on correspondence statements via lambda-lifting. We argue that the linear-depth-increase property can be a stepping stone for an alternative proof of, and so can shed new light on, a result by Accattoli and Dal Lago (2015) that states: leftmost-outermost $β$-reduction rewrite sequences of length $n$ in the lambda-calculus can be implemented on a reasonable machine with an overhead that is polynomial in $n$ and the size of the initial term.
Parallel Local Graph Clustering
Venue: arXiv cs.DC 2019
Year: 2019

Graph clustering has many important applications in computing, but due to growing sizes of graphs, even traditionally fast clustering methods such as spectral partitioning can be computationally expensive for real-world graphs of interest. Motivated partly by this, so-called local algorithms for graph clustering have received significant interest due to the fact that they can find good clusters in a graph with work proportional to the size of the cluster rather than that of the entire graph. This feature has proven to be crucial in making such graph clustering and many of its downstream applications efficient in practice. While local clustering algorithms are already faster than traditional algorithms that touch the entire graph, they are sequential and there is an opportunity to make them even more efficient via parallelization. In this paper, we show how to parallelize many of these algorithms in the shared-memory multicore setting, and we analyze the parallel complexity of these algorithms. We present comprehensive experiments on large-scale graphs showing that our parallel algorithms achieve good parallel speedups on a modern multicore machine, thus significantly speeding up the analysis of local graph clusters in the very large-scale setting.
Assessing the Computational Complexity of Multi-Layer Subgraph Detection
Venue: arXiv cs.CC 2019
Year: 2019

Multi-layer graphs consist of several graphs (layers) over the same vertex set. They are motivated by real-world problems where entities (vertices) are associated via multiple types of relationships (edges in different layers). We chart the border of computational (in)tractability for the class of subgraph detection problems on multi-layer graphs, including fundamental problems such as maximum matching, finding certain clique relaxations (motivated by community detection), or path problems. Mostly encountering hardness results, sometimes even for two or three layers, we can also spot some islands of tractability.
A Tight Lower Bound for the Weights of Maximum Weight Matching in Bipartite Graphs
Venue: arXiv cs.DM 2019
Year: 2019

Let $\Ga$ be the collection of all weighted bipartite graphs each having $σ$ and $m$, as the size of a vertex partition and the total weight, respectively. We give a tight lower bound $\lceil \frac{m-σ}σ \rceil+1$ for the set $\{\textit{Wt}(\textit{mwm}(G))~|~G \in \Ga\}$ which denotes the collection of weights of maximum weight bipartite matchings of all graphs in $\Ga$.
Non-Homogenizable Classes of Finite Structures
Venue: arXiv cs.LO 2019
Year: 2019

Homogenization is a powerful way of taming a class of finite structures with several interesting applications in different areas, from Ramsey theory in combinatorics to constraint satisfaction problems (CSPs) in computer science, through (finite) model theory. A few sufficient conditions for a class of finite structures to allow homogenization are known, and here we provide a necessary condition. This lets us show that certain natural classes are not homogenizable: 1) the class of locally consistent systems of linear equations over the two-element field or any finite Abelian group, and 2) the class of finite structures that forbid homomorphisms from a specific MSO-definable class of structures of treewidth two. In combination with known results, the first example shows that, up to pp-interpretability, the CSPs that are solvable by local consistency methods are distinguished from the rest by the fact that their classes of locally consistent instances are homogenizable. The second example shows that, for MSO-definable classes of forbidden patterns, treewidth one versus two is the dividing line to homogenizability.