OpenRaiser/Intern-Atlas huggingface dataset:
Optimal rate list decoding over bounded alphabets using algebraic-geometric codes
Venue: arXiv cs.CC 2020
Year: 2020

We give new constructions of two classes of algebraic code families which are efficiently list decodable with small output list size from a fraction $1-R-ε$ of adversarial errors where $R$ is the rate of the code, for any desired positive constant $ε$. The alphabet size depends only $ε$ and is nearly-optimal. The first class of codes are obtained by folding algebraic-geometric codes using automorphisms of the underlying function field. The list decoding algorithm is based on a linear-algebraic approach, which pins down the candidate messages to a subspace with a nice "periodic" structure. The list is pruned by precoding into a special form of "subspace-evasive" sets, which are constructed pseudorandomly. Instantiating this construction with the Garcia-Stichtenoth function field tower yields codes list-decodable up to a $1-R-ε$ error fraction with list size bounded by $O(1/ε)$, matching the existential bound up to constant factors. The parameters we achieve are thus quite close to the existential bounds in all three aspects: error-correction radius, alphabet size, and list-size. The second class of codes are obtained by restricting evaluation points of an algebraic-geometric code to rational points from a subfield. Once again, the linear-algebraic approach to list decoding to pin down candidate messages to a periodic subspace. We develop an alternate approach based on "subspace designs" to precode messages. Together with the subsequent explicit constructions of subspace designs, this yields a deterministic construction of an algebraic code family of rate $R$ with efficient list decoding from $1-R-ε$ fraction of errors over a constant-sized alphabet. The list size is bounded by a very slowly growing function of the block length $N$; in particular, it is at most $O(\log^{(r)} N)$ (the $r$'th iterated logarithm) for any fixed integer $r$.
On Hypothesis Testing Against Independence with Multiple Decision Centers
Venue: arXiv cs.IT 2020
Year: 2020

A distributed binary hypothesis testing problem is studied with one observer and two decision centers. Achievable type-II error exponents are derived for testing against conditional independence when the observer communicates with the two decision centers over one common and two individual noise-free bit pipes and when it communicates with them over a noisy broadcast channel (BC). The results are based on a coding and testing scheme that splits the observations into subblocks, so that transmitter and receivers can independently apply to each subblock either Gray-Wyner coordination coding with side-information or hybrid joint source-channel coding with side-information, followed by a Neyman-Pearson test over the subblocks at the receivers. This approach allows to avoid introducing further error exponents that one would expect from the receivers' decoding operations related to binning or the noisy transmission channel. The derived exponents are shown to be optimal in some special cases when communication is over noise-free links. The results reveal a tradeoff between the type-II error exponents at the two decision centers.
A Constant-Factor Approximation Algorithm for the Asymmetric Traveling Salesman Problem
Venue: arXiv cs.DS 2020
Year: 2020

We give a constant-factor approximation algorithm for the asymmetric traveling salesman problem (ATSP). Our approximation guarantee is analyzed with respect to the standard LP relaxation, and thus our result confirms the conjectured constant integrality gap of that relaxation. The main idea of our approach is a reduction to Subtour Partition Cover, an easier problem obtained by significantly relaxing the general connectivity requirements into local connectivity conditions. We first show that any algorithm for Subtour Partition Cover can be turned into an algorithm for ATSP while only losing a small constant factor in the performance guarantee. Next, we present a reduction from general ATSP instances to structured instances, on which we then solve Subtour Partition Cover, yielding our constant-factor approximation algorithm for ATSP.
Sublinear-Time Algorithms for Compressive Phase Retrieval
Venue: arXiv cs.DS 2020
Year: 2020

In the compressive phase retrieval problem, or phaseless compressed sensing, or compressed sensing from intensity only measurements, the goal is to reconstruct a sparse or approximately $k$-sparse vector $x \in \mathbb{R}^n$ given access to $y= |Φx|$, where $|v|$ denotes the vector obtained from taking the absolute value of $v\in\mathbb{R}^n$ coordinate-wise. In this paper we present sublinear-time algorithms for different variants of the compressive phase retrieval problem which are akin to the variants considered for the classical compressive sensing problem in theoretical computer science. Our algorithms use pure combinatorial techniques and near-optimal number of measurements.
A Symbolic Approach to Safety LTL Synthesis
Venue: arXiv cs.LO 2020
Year: 2020

Temporal synthesis is the automated design of a system that interacts with an environment, using the declarative specification of the system's behavior. A popular language for providing such a specification is Linear Temporal Logic, or LTL. LTL synthesis in the general case has remained, however, a hard problem to solve in practice. Because of this, many works have focused on developing synthesis procedures for specific fragments of LTL, with an easier synthesis problem. In this work, we focus on Safety LTL, defined here to be the Until-free fragment of LTL in Negation Normal Form~(NNF), and shown to express a fragment of safe LTL formulas. The intrinsic motivation for this fragment is the observation that in many cases it is not enough to say that something "good" will eventually happen, we need to say by when it will happen. We show here that Safety LTL synthesis is significantly simpler algorithmically than LTL synthesis. We exploit this simplicity in two ways, first by describing an explicit approach based on a reduction to Horn-SAT, which can be solved in linear time in the size of the game graph, and then through an efficient symbolic construction, allowing a BDD-based symbolic approach which significantly outperforms extant LTL-synthesis tools.
Some facts on Permanents in Finite Characteristics
Venue: arXiv cs.CC 2020
Year: 2020

The polynomial-time computability of the permanent over fields of characteristic 3 for k-semi-unitary matrices (i.e. square matrices such that the differences of their Gram matrices and the corresponding identity matrices are of rank k) in the case k = 0 or k = 1 and its #3P-completeness for any k > 1 (Ref. 9) is a result that essentially widens our understanding of the computational complexity boundaries for the permanent modulo 3. Now we extend this result to study more closely the case k > 1 regarding the (n-k)x(n-k)-sub-permanents (or permanent-minors) of a unitary nxn-matrix and their possible relations, because an (n-k)x(n-k)-submatrix of a unitary nxn-matrix is generically a k-semi-unitary (n-k)x(n-k)-matrix. The following paper offers a way to receive a variety of such equations of different sorts, in the meantime extending this direction of research to reviewing all the set of polynomial-time permanent-preserving reductions and equations for the sub-permanents of a generic matrix they might yield, including a number of generalizations and formulae (valid in an arbitrary prime characteristic) analogical to the classical identities relating the minors of a matrix and its inverse. Moreover, the second chapter also deals with the Hamiltonian cycle polynomial in characteristic 2 that surprisingly possesses quite a number of properties very similar to the corresponding ones of the permanent in characteristic 3, while over the field GF(2) it obtains even more amazing features. Besides, the third chapter is devoted to the computational complexity issues of the permanent and some related functions on a variety of Cauchy matrices and their certain generalizations, including constructing a polynomial-time algorithm (based on them) for the permanent of an arbitrary matrix in characteristic 5 (implying RP = NP) and conjecturing the existence of a similar scheme in characteristic 3.
Low Complexity Fair Scheduling in LTE/LTE-A Uplink Involving Multiple Traffic Classes
Venue: arXiv cs.NI 2020
Year: 2020

The bulk of the research on Long Term Evolution/Long Term Evolution-Advanced packet scheduling is concentrated in the downlink and the uplink is comparatively less explored. In up-link, channel aware scheduling with throughput maximization has been widely studied while considering an infinitely back-logged buffer model, which makes the investigations unrealistic. Therefore, we propose an optimal uplink packet scheduling pro-cedure with realistic traffic sources. Firstly, we advocate a joint channel and buffer aware algorithm, which maximizes the actual transmitted bit-count. Thereafter, we introduce delay constraints in our algorithm to support real-time traffic. We further enhance our algorithm by incorporating the varied delay and throughput requirements demanded by mixed traffic classes. Finally, we in-troduce priority flipping to minimize bandwidth starvation of lower priority traffic in presence of higher percentage of high priority traffic. We observe that a delay constraint may render the optimization-based proposals infeasible. Therefore, to avoid infeasibility, we replace the delay constraint with delay outage minimization (DOM). DOM aims at minimizing the packet drop due to delay violation. Moreover, DOM also helps in reducing the problems to a well-known assignment problem, which can be solved by applying the Hungarian algorithm. Hence, our approach delivers an optimal allocation with low computational complexity.
Structured Robust Submodular Maximization: Offline and Online Algorithms
Venue: arXiv cs.DS 2020
Year: 2020

Constrained submodular function maximization has been used in subset selection problems such as selection of most informative sensor locations. While these models have been quite popular, the solutions Constrained submodular function maximization has been used in subset selection problems such as selection of most informative sensor locations. While these models have been quite popular, the solutions obtained via this approach are unstable to perturbations in data defining the submodular functions. Robust submodular maximization has been proposed as a richer model that aims to overcome this discrepancy as well as increase the modeling scope of submodular optimization. In this work, we consider robust submodular maximization with structured combinatorial constraints and give efficient algorithms with provable guarantees. Our approach is applicable to constraints defined by single or multiple matroids, knapsack as well as distributionally robust criteria. We consider both the offline setting where the data defining the problem is known in advance as well as the online setting where the input data is revealed over time. For the offline setting, we give a general (nearly) optimal bi-criteria approximation algorithm that relies on new extensions of classical algorithms for submodular maximization. For the online version of the problem, we give an algorithm that returns a bi-criteria solution with sub-linear regret.
A '1+1' Algorithm for the Hamilton Cycle Problem
Venue: arXiv cs.DM 2020
Year: 2020

Deciding if a graph is a Hamilton graph, also named the Hamilton cycle problem, is important for discrete mathematics and computer science. Due to no characterization to identify Hamilton graphs effectively, there are no tractable algorithms to solve the Hamilton cycle problem. Grinberg Theorem is a necessary condition only for planar Hamilton graphs. In this paper, based on new studies on the Grinberg Theorem, in which we provided new properties of Hamilton graphs with respect to the cycle bases and improved the Grinberg Theorem to derive an efficient condition for Hamilton graphs, we present a new precise algorithm for deciding Hamilton graphs, named the '1+1' algorithm. Theoretically, the '1+1' algorithm terminates in $O(|E(G)|^3)$ worst time complexity, where $|\textit{E}(\textit{G})|$ is the size of the given graph $\textit{G}$.
Transparent Replication Using Metaprogramming in Cyan
Venue: arXiv cs.PL 2020
Year: 2020

Replication can be used to increase the availability of a service by creating many operational copies of its data called replicas. Active replication is a form of replication that has strong consistency semantics, easier to reason about and program. However, creating replicated services using active replication still demands from the programmer the knowledge of subtleties of the replication mechanism. In this paper we show how to use the metaprogramming infrastructure of the Cyan language to shield the application programmer from these details, allowing easier creation of fault-tolerant replicated applications through simple annotations.
Beyond Finite Layer Neural Networks: Bridging Deep Architectures and Numerical Differential Equations
Venue: arXiv cs.CV 2020
Year: 2020

In our work, we bridge deep neural network design with numerical differential equations. We show that many effective networks, such as ResNet, PolyNet, FractalNet and RevNet, can be interpreted as different numerical discretizations of differential equations. This finding brings us a brand new perspective on the design of effective deep architectures. We can take advantage of the rich knowledge in numerical analysis to guide us in designing new and potentially more effective deep networks. As an example, we propose a linear multi-step architecture (LM-architecture) which is inspired by the linear multi-step method solving ordinary differential equations. The LM-architecture is an effective structure that can be used on any ResNet-like networks. In particular, we demonstrate that LM-ResNet and LM-ResNeXt (i.e. the networks obtained by applying the LM-architecture on ResNet and ResNeXt respectively) can achieve noticeably higher accuracy than ResNet and ResNeXt on both CIFAR and ImageNet with comparable numbers of trainable parameters. In particular, on both CIFAR and ImageNet, LM-ResNet/LM-ResNeXt can significantly compress ($>50$\%) the original networks while maintaining a similar performance. This can be explained mathematically using the concept of modified equation from numerical analysis. Last but not least, we also establish a connection between stochastic control and noise injection in the training process which helps to improve generalization of the networks. Furthermore, by relating stochastic training strategy with stochastic dynamic system, we can easily apply stochastic training to the networks with the LM-architecture. As an example, we introduced stochastic depth to LM-ResNet and achieve significant improvement over the original LM-ResNet on CIFAR10.
Event-Triggered Diffusion Kalman Filters
Venue: arXiv cs.SY 2020
Year: 2020

Distributed state estimation strongly depends on collaborative signal processing, which often requires excessive communication and computation to be executed on resource-constrained sensor nodes. To address this problem, we propose an event-triggered diffusion Kalman filter, which collects measurements and exchanges messages between nodes based on a local signal indicating the estimation error. On this basis, we develop an energy-aware state estimation algorithm that regulates the resource consumption in wireless networks and ensures the effectiveness of every consumed resource. The proposed algorithm does not require the nodes to share its local covariance matrices, and thereby allows considerably reducing the number of transmission messages. To confirm its efficiency, we apply the proposed algorithm to the distributed simultaneous localization and time synchronization problem and evaluate it on a physical testbed of a mobile quadrotor node and stationary custom ultra-wideband wireless devices. The obtained experimental results indicate that the proposed algorithm allows saving 86% of the communication overhead associated with the original diffusion Kalman filter while causing deterioration of performance by 16% only. We make the Matlab code and the real testing data available online.
Binary Linear Codes with Optimal Scaling: Polar Codes with Large Kernels
Venue: arXiv cs.IT 2020
Year: 2020

We prove that, for the binary erasure channel (BEC), the polar-coding paradigm gives rise to codes that not only approach the Shannon limit but do so under the best possible scaling of their block length as a~function of the gap to capacity. This result exhibits the first known family of binary codes that attain both optimal scaling and quasi-linear complexity of encoding and decoding. Our proof is based on the construction and analysis of binary polar codes with large kernels. When communicating reliably at rates within $\varepsilon > 0$ of capacity, the code length $n$ often scales as $O(1/\varepsilon^μ)$, where the constant $μ$ is called the scaling exponent. It is known that the optimal scaling exponent is $μ=2$, and it is achieved by random linear codes. The scaling exponent of conventional polar codes (based on the $2\times 2$ kernel) on the BEC is $μ=3.63$. This falls far short of the optimal scaling guaranteed by random codes. Our main contribution is a rigorous proof of the following result: for the BEC, there exist $\ell\times\ell$ binary kernels, such that polar codes constructed from these kernels achieve scaling exponent $μ(\ell)$ that tends to the optimal value of $2$ as $\ell$ grows. We furthermore characterize precisely how large $\ell$ needs to be as a function of the gap between $μ(\ell)$ and $2$. The resulting binary codes maintain the recursive structure of conventional polar codes, and thereby achieve construction complexity $O(n)$ and encoding/decoding complexity $O(n\log n)$.
Energy Storage Arbitrage in Real-Time Markets via Reinforcement Learning
Venue: arXiv cs.SY 2020
Year: 2020

In this paper, we derive a temporal arbitrage policy for storage via reinforcement learning. Real-time price arbitrage is an important source of revenue for storage units, but designing good strategies have proven to be difficult because of the highly uncertain nature of the prices. Instead of current model predictive or dynamic programming approaches, we use reinforcement learning to design an optimal arbitrage policy. This policy is learned through repeated charge and discharge actions performed by the storage unit through updating a value matrix. We design a reward function that does not only reflect the instant profit of charge/discharge decisions but also incorporate the history information. Simulation results demonstrate that our designed reward function leads to significant performance improvement compared with existing algorithms.
A TTL-based Approach for Content Placement in Edge Networks
Venue: arXiv cs.NI 2020
Year: 2020

Edge networks are promising to provide better services to users by provisioning computing and storage resources at the edge of networks. However, due to the uncertainty and diversity of user interests, content popularity, distributed network structure, cache sizes, it is challenging to decide where to place the content, and how long it should be cached. In this paper, we study the utility optimization of content placement at edge networks through timer-based (TTL) policies. We propose provably optimal distributed algorithms that operate at each network cache to maximize the overall network utility. Our TTL-based optimization model provides theoretical answers to how long each content must be cached, and where it should be placed in the edge network. Extensive evaluations show that our algorithm significantly outperforms path replication with conventional caching algorithms over some network topologies.
Discussion among Different Methods of Updating Model Filter in Object Tracking
Venue: arXiv cs.CV 2020
Year: 2020

Discriminative correlation filters (DCF) have recently shown excellent performance in visual object tracking area. In this paper, we summarize the methods of updating model filter from discriminative correlation filter (DCF) based tracking algorithms and analyzes similarities and differences among these methods. We deduce the relationship between updating coefficient in high dimension (kernel trick), updating filter in frequency domain and updating filter in spatial domain, and analyze the difference among these different ways. We also analyze the difference between the updating filter directly and updating filter's numerator (object response power) with updating filter's denominator (filter's power). The experiments about comparing different updating methods and visualizing the template filters are used to prove our derivation.
Extracting Automata from Recurrent Neural Networks Using Queries and Counterexamples
Venue: arXiv cs.LG 2020
Year: 2020

We present a novel algorithm that uses exact learning and abstraction to extract a deterministic finite automaton describing the state dynamics of a given trained RNN. We do this using Angluin's L* algorithm as a learner and the trained RNN as an oracle. Our technique efficiently extracts accurate automata from trained RNNs, even when the state vectors are large and require fine differentiation.
Distances between States and between Predicates
Venue: arXiv cs.LO 2020
Year: 2020

This paper gives a systematic account of various metrics on probability distributions (states) and on predicates. These metrics are described in a uniform manner using the validity relation between states and predicates. The standard adjunction between convex sets (of states) and effect modules (of predicates) is restricted to convex complete metric spaces and directed complete effect modules. This adjunction is used in two state-and-effect triangles, for classical (discrete) probability and for quantum probability.
Local Access to Huge Random Objects through Partial Sampling
Venue: arXiv cs.DS 2020
Year: 2020

Consider an algorithm performing a computation on a huge random object. Is it necessary to generate the entire object up front, or is it possible to provide query access to the object and sample it incrementally "on-the-fly"? Such an implementation should emulate the object by answering queries in a manner consistent with a random instance sampled from the true distribution. Our first set of results focus on undirected graphs with independent edge probabilities, under certain assumptions. Then, we use this to obtain the first efficient implementations for the Erdos-Renyi model and the Stochastic Block model. As in previous local-access implementations for random graphs, we support Vertex-Pair and Next-Neighbor queries. We also introduce a new Random-Neighbor query. Next, we show how to implement random Catalan objects, specifically focusing on Dyck paths (always positive random walks on the integer line). Here, we support Height queries to find the position of the walk, and First-Return queries to find the time when the walk returns to a specified height. This in turn can be used to implement Next-Neighbor queries on random rooted/binary trees, and Matching-Bracket queries on random well bracketed expressions. Finally, we define a new model that: (1) allows multiple independent simultaneous instantiations of the same implementation to be consistent with each other without communication (2) allows us to generate a richer class of random objects that do not have a succinct description. Specifically, we study uniformly random valid $q$-colorings of an input graph $G$ with max degree $Δ$. The distribution over valid colorings is specified via a "huge" underlying graph $G$, that is far too large to be read in sub-linear time. Instead, we access $G$ through local neighborhood probes. We are able to answer queries to the color of any vertex in sub-linear time for $q > 9Δ$.