pinecone/core-2020-05-10-deduplication huggingface dataset:
Structure of the Invertible CA Transformations Group

AbstractWe describe the structure of the group of all invertible CA transformations acting on 1-dimensional finite-length cellular automata defined on a finite states set. It turns out that the group is a direct product of semidirect products of cyclic and symmetric groups. The analysis of this group has been carried out by means of an isomorphic image of the invertible CA transformations group, which was easier to handle. A presentation of the group by generators and relations is also supplied. Most of the results obtained can also be applied to analyse the automorphism group of any finite one-to-one dynamical system
Selective Mu-Calculus and Formula-Based Equivalence of Transition Systems

AbstractIn model checking for temporal logic, the correctness of a system with respect to a desired behavior is verified by checking whether a structure that models the system satisfies a formula describing the behavior. Most existing verification techniques are based on a representation of the system by means of a labeled transition system. In this approach to verification, the efficiency of the model checking is essentially influenced by the number of states of the transition system. In this paper we present a new temporal logic, the selective mu-calculus, and an equivalence between transition systems based on the formulae of this logic. This property preserving equivalence can be used to reduce the size of transition systems. The equivalence (called ρ-equivalence) is based on the set, ρ, of actions occurring inside the modal operators of a selective mu-calculus formula. We prove that the ρ-equivalence coincides with the equivalence induced by the set of the selective mu-calculus formulae with occurring actions in ρ. Thus, a formula can be more efficiently checked on a transition system ρ-equivalent to the standard one, but smaller than it, since all the actions not in ρ are “discarded.
On the Inapproximability of Disjoint Paths and Minimum Steiner Forest with Bandwidth Constraints

AbstractIn this paper, we study the inapproximability of several well-known optimization problems in network optimization. We show-that the max directed vertex-disjoint paths problem cannot be approximated within ratio 2log1−εn unless NP⊆DTIME[2polylogn], the max directed edge-disjoint paths problem cannot be approximated within ratio 2log1−εn unless NP⊆DTIME[2polylogn], the integer multicommodity flow problem in directed graphs cannot be approximated within ratio 2log1−εn unless NP⊆DTIME[2polylogn], the max undirected vertex-disjoint paths problem does not have a polynomial time approximation scheme unless P=NP, and the minimum Steiner forest with bandwidth constraints problem cannot be approximated within ratio exp(poly(n)) unless P=NP
Competitive Routing of Virtual Circuits with Unknown Duration

AbstractIn this paper we present a strategy to route unknown duration virtual circuits in a high-speed communication network. Previous work on virtual circuit routing concentrated on the case where the call duration is known in advance. We show that by allowing O(logn) reroutes per call, we can achieve O(logn) competitive ratio with respect to the maximum load (congestion) for the unknown duration case, where n is the number of nodes in the network. This is in contrast to the Ω(n) lower bound on the competitive ratio for this case if no rerouting is allowed (Azar et al., 1992, Proc. 33rd IEEE Annual Symposium of Foundations of Computer Science, pp. 218–225). Our routing algorithm can be also applied in the context of machine load balancing of tasks with unknown duration. We present an algorithm that makes O(logn) reassignments per task and achieves O(logn) competitive ratio with respect to the load, where n is the number of parallel machines. For a special case of unit load tasks we design a constant competitive algorithm. The previously known algorithms that achieve up to polylogarithmic competitive ratio for load balancing of tasks with unknown duration dealt only with special cases of related machines case and unit-load tasks with restricted assignment (Azar et al., 1993, Proc. Workshop on Algorithms and Data Structures, pp. 119–130; Azar et al., 1992, Proc. 3rd ACM-SIAM Symposium on Discrete Algorithms, pp. 203–210)
On Relationships between Statistical Zero-Knowledge Proofs

AbstractThis paper solves several fundamental open problems about statistical zero-knowledge interactive proofs (SZKIPs). The following two theorems are proven: •If language L has a statistical zero-knowledge interactive proof against an honest verifier, then L has a statistical zero-knowledge “public-coin” interactive proof against an honest verifier. (Theorem 1) •If L has a statistical zero-knowledge public-coin interactive proof against an honest verifier then “the complement of L” has a statistical zero-knowledge constant (one) round interactive proof against an honest verifier. (Theorem 2) The following corollaries are obtained directly from these two theorems and the recent result by Goldreich, Sahai, and Vadhan (1998, “Proc. of STOC,” pp. 409–418). •[Public-coin SZKIP=Private-coin SZKIP].[Honest verifier SZKIP=Any verifier SZKIP]. If L has a statistical zero-knowledge interactive proof against an “honest verifier,” then L has a statistical zero-knowledge public-coin interactive proof against “any verifier.” •[SZKIP=co-SZKIP]. If L has a statistical zero-knowledge interactive proof, then the “complement” of L has a statistical zero-knowledge (public-coin) interactive proof. •[Bounded round SZKIP=Unbounded round SZKIP]. If L has a statistical zero-knowledge interactive proof, then L has a statistical zero-knowledge “constant (one) round” interactive proof against an honest verifier. •[Black-box simulation SZKIP=Auxiliary-input SZKIP]. If L has a statistical “auxiliary-input” zero-knowledge interactive proof, then L has a statistical “black-box simulation” zero-knowledge interactive proof
Data Independence of Read, Write, and Control Structures in PRAM Computations

AbstractWe introduce the notions of control and communication structures in PRAM computations and relate them to the concept of data independence. Our main result is to characterize differences between unbounded fan-in parallelism ACk, bounded fan-in parallelism NCk, and the sequential classes DSPACE(logn) and LOGDCFL in terms of a PRAM's communication structure and instruction set. Our findings give a concrete indication that in parallel computations writing is more powerful than reading. Further characterizations are given for parallel pointer machines and the semiunbounded fan-in circuit classes SACk. In particular, we obtain the first characterizations of NCk and DSPACE(logn) in terms of PRAMs. Finally, we introduce Index-PRAMs, which in some sense have built-in data independence. We propose Index-PRAMs as a tool for the development of data-independent parallel algorithms. Index-PRAMs serve for studying the essential differences between the above mentioned complexity classes with respect to the underlying instruction set used
Computational Sample Complexity and Attribute-Efficient Learning

AbstractTwo fundamental measures of the efficiency of a learning algorithm are its running time and the number of examples it requires (its sample complexity). In this paper we demonstrate that even for simple concept classes, an inherent tradeoff can exist between running time and sample complexity. We present a concept class of 1-decision lists and prove that while a computationally unbounded learner can learn the class from O(1) examples, under a standard cryptographic assumption any polynomial-time learner requires almost Θ(n) examples. Using a different construction, we present a concept class of k-decision lists which exhibits a similar but stronger gap in sample complexity. These results strengthen the results of Decatur et al. (1997, in “Proc. Tenth Ann. Conf. Comput. Learning Theory,” pp. 130–142) on distribution-free computational sample complexity and come within a logarithmic factor of the largest possible gap for concept classes of k-decision lists. Finally, we construct a concept class of decision lists which can be learned attribute-efficiently and can be learned in polynomial time but cannot be learned attribute-efficiently in polynomial time. This is the first result which shows that attribute-efficient learning can be computationally hard. The main tools used are one-way permutations, error-correcting codes and pseudorandom generators
A 5/4 Linear Time Bin Packing Algorithm

AbstractIn 1985, Martel published a linear time algorithm with a 43 asymptotic worst-case ratio for the one-dimensional bin packing problem. The algorithm is based on a linear time classification of the sizes of the items, and thereafter—according to the number of elements in certain subclasses—pairing the items in a clever way. In his paper Martel mentioned a natural generalization of this algorithm, that suggested a 54 algorithm. Although this seemed to be very simple, the improvement has not been realized until now. In this paper we present an algorithm which uses the ideas of Martel and has a 54 asymptotic worst-case ratio
An Average-Case Optimal One-Variable Pattern Language Learner

AbstractA new algorithm for learning one-variable pattern languages from positive data is proposed and analyzed with respect to its average-case behavior. We consider the total learning time that takes into account all operations till convergence to a correct hypothesis is achieved. For almost all meaningful distributions defining how the pattern variable is replaced by a string to generate random examples of the target pattern language, it is shown that this algorithm converges within an expected constant number of rounds and a total learning time that is linear in the pattern length. Thus, our solution is average-case optimal in a strong sense. Though one-variable pattern languages can neither be finitely inferred from positive data nor PAC-learned, our approach can be extended to a probabilistic finite learner that exactly infers all one-variable pattern languages from positive data with high confidence. It is a long-standing open problem whether or not pattern languages can be learned in cases that empty substitutions for the pattern variables are also allowed. Our learning strategy can be generalized to this situation as well. Finally, we show some experimental results for the behavior of this new learning algorithm in practice
Time–Space Tradeoffs for Satisfiability

AbstractWe give the first nontrivial model-independent time–space tradeoffs for satisfiability. Namely, we show that SAT cannot be solved in n1+o(1) time and n1−ε space for any ε>0 general random-access nondeterministic Turing machines. In particular, SAT cannot be solved deterministically by a Turing machine using quasilinear time and n space. We also give lower bounds for log-space uniform NC1 circuits and branching programs. Our proof uses two basic ideas. First we show that if SAT can be solved nondeterministically with a small amount of time then we can collapse a nonconstant number of levels of the polynomial-time hierarchy. We combine this work with a result of Nepomnjaščiı that shows that a nondeterministic computation of superlinear time and sublinear space can be simulated in alternating linear time. A simple diagonalization yields our main result. We discuss how these bounds lead to a new approach to separating the complexity classes NL and NP. We give some possibilities and limitations of this approach
Separating NP-Completeness Notions under Strong Hypotheses

AbstractLutz (1993, “Proceedings of the Eight Annual Conference on Structure in Complexity Theory,” pp. 158–175) proposed the study of the structure of the class NP=NTIME(poly) under the hypothesis that NP does not have p-measure 0 (with respect to Lutz's resource bounded measure (1992, J. Comput. System Sci.44, 220–258)). Lutz and Mayordomo (1996, Theoret. Comput. Sci.164, 141–163) showed that, under this hypothesis, NP-m-completeness and NP-T-completeness differ, and they conjectured that additional NP-completeness notions can be separated. Here we prove this conjecture for the bounded-query reducibilities. In fact, we consider a new weaker hypothesis, namely the assumption that NP is not p-meager with respect to the resource bounded Baire category concept of Ambos-Spies et al. (1988, Lecture Notes in Computer Science, Vol. 329, pp. 1–16). We show that this category hypothesis is sufficient to get: (i)For k⩾2, NP-btt(k)-completeness is stronger than NP-btt(k+1)-completeness. (ii)For k⩾1, NP-bT(k)-completeness is stronger than NP-bT(k+1)-completeness. (iii)For every k⩾2, NP-bT(k−1)-completeness is not implied by NP-btt(k+1)-completeness and NP-btt(2k−2)-completeness is not implied by NP-bT(k)-completeness. (iv)NP-btt-completeness is stronger than NP-tt-completeness
On TC0, AC0, and Arithmetic Circuits

AbstractContinuing a line of investigation that has studied the function classes #P, #SAC1, #L, and #NC1, we study the class of functions #AC0. One way to define #AC0 is as the class of functions computed by constant-depth polynomial-size arithmetic circuits of unbounded fan-in addition and multiplication gates. In contrast to the preceding function classes, for which we know to nontrivial lower bounds, lower bounds for #AC0 follow easily from established circuit lower bounds. One of our main results is a characterization of TC0 in terms of #AC0: A language A is in TC0 if and only if there is a #AC0 function f and a number k such that x∈A⇔f(x)=2|x|k. Using the naming conventions of Fenner et al. (1994, J. Comput. System Sci.48, 116–148) and Caussinus et al. (1998, J. Comput. System Sci.57, 200–212), this yieldsTC0=PAC0=C=AC0. Another restatement of this characterization is that TC0 can be simulated by constant-depth arithmetic circuits, with a single threshold gate. We hope that perhaps this characterization of TC0 in terms of AC0 circuits might provide a new avenue of attack for proving lower bounds. Our characterization differs markedly from earlier characterizations of TC0 in terms of arithmetic circuits over finite fields. Using our model of arithmetic circuits, computation over finite fields yields ACC0. We also prove a number of closure properties and normal forms for #AC0
Circuits over PP and PL

AbstractWilson's (1985, J. Comput. System. Sci.31, 169–181) model of oracle gates provides a framework for considering reductions whose strength is intermediate between truth-table and Turing. Improving on a stream of previously published results, we prove that PL and PP are closed under NC1 reductions. This answers an open problem of Ogihara (1996, “Proc. 37th Ann. IEEE Symp. Found. Computer Sci.”). More generally, we show that NCPPk+1=ACPPk and NCPLk+1=ACPLk for all k⩾0. On the other hand, we construct an oracle A such that NCPPAk≠NCPPAk+1 for all integers k⩾1. Slightly weaker than NC1 reductions are Boolean formula reductions. We ask whether PL and PP are closed under Boolean formula reductions. This is a nontrivial question despite NC1=BF, because that equality is easily seen not to relativize. We prove that PPPlog2n/loglogn−T⊆BFPP⊆PrTIME(nO(logn)). Because PPPlog2n/loglogn−T⊈PP relative to an oracle, we think it is unlikely that PP is closed under Boolean formula reductions. We also show that PL is unlikely to be closed under BF reductions
Inequalities for Shannon Entropy and Kolmogorov Complexity

AbstractIt was mentioned by Kolmogorov (1968, IEEE Trans. Inform. Theory14, 662–664) that the properties of algorithmic complexity and Shannon entropy are similar. We investigate one aspect of this similarity. Namely, we are interested in linear inequalities that are valid for Shannon entropy and for Kolmogorov complexity. It turns out that (1) all linear inequalities that are valid for Kolmogorov complexity are also valid for Shannon entropy and vice versa; (2) all linear inequalities that are valid for Shannon entropy are valid for ranks of finite subsets of linear spaces; (3) the opposite statement is not true; Ingleton's inequality (1971, “Combinatorial Mathematics and Its Applications,” pp. 149–167. Academic Press, San Diego) is valid for ranks but not for Shannon entropy; (4) for some special cases all three classes of inequalities coincide and have simple description. We present an inequality for Kolmogorov complexity that implies Ingleton's inequality for ranks; another application of this inequality is a new simple proof of one of Gács–Körner's results on common information (1973, Problems Control Inform. Theory2, 149–162)
Adaptive Packet Routing for Bursty Adversarial Traffic

AbstractOne of the central tasks of networking is packet routing when edge bandwidth is limited. Tremendous progress has been achieved by separating the issue of routing into two conceptual subproblems: path selection and congestion resolution along the selected paths. However, this conceptual separation has a serious drawback: each packet's path is fixed at the source and cannot be modified adaptively en-route. The problem is especially severe when packet injections are modeled by an adversary, whose goal is to cause traffic-jams. In this paper, we consider this adversarial setting, motivated by the adversarial queuing theory model of Borodin et al. (1996, in “Proc. of 28th STOC,” pp. 376–385). More precisely, we consider an adversary who injects packets, with only their destinations specified, into network nodes in a continuous manner subject to certain limitations on the injection rate. The question whether it is possible to deal with such an adversary and to design protocols that would discover routes which avoid traffic jams so that nodes only store a bounded number of packets was left as an open problem by Andrews et al. (1997, in “Proc. of 38th FOCS,” pp. 294–302) (who deal with the nonadaptive case where the adversary provides routes for the packets). In the present paper, we resolve this open problem. In particular, we present a simple, deterministic, local-control protocol that applies to any network topology. Our protocol guarantees that, for any injection sequence generated by the adversary, the buffers at the nodes are polynomially bounded and that each packet has a polynomially bounded delivery time
Approximating the Bandwidth via Volume Respecting Embeddings

AbstractA linear arrangement of an n-vertex graph is a one-to-one mapping of its vertices to the integers {1, …, n}. The bandwidth of a linear arrangement is the maximum difference between mapped values of adjacent vertices. The problem of finding a linear arrangement with smallest possible bandwidth is NP-hard. We present a randomized algorithm that runs in nearly linear time and outputs a linear arrangement whose bandwidth is within a polylogarithmic multiplicative factor of optimal. Our algorithm is based on a new notion, called volume respecting embeddings, which is a natural extension of small distortion embeddings of Bourgain and of Linial, London and Rabinovich
A Comparison of Tree Transductions Defined by Monadic Second Order Logic and by Attribute Grammars

AbstractTwo well-known formalisms for the specification and computation of tree transductions are compared: the mso graph transducer and the attributed tree transducer with look-ahead, respectively. The mso graph transducer, restricted to trees, uses monadic second order logic to define the output tree in terms of the input tree. The attributed tree transducer is an attribute grammar in which all attributes are trees; it is preceded by a look-ahead phase in which all attributes have finitely many values. The main result is that these formalisms are equivalent, i.e., that the attributed tree transducer with look-ahead is an appropriate implementation model for the tree transductions that are specifiable in mso logic. This result holds for mso graph transducers that produce trees with shared subtrees. If no sharing is allowed, the attributed tree transducer satisfies the single use restriction
New Efficient and Secure Protocols for Verifiable Signature Sharing and Other Applications

AbstractVerifiable signature sharing (VΣS) was introduced by Franklin and Reiter in “Eurocrypt '95” (Lecture Notes in Computer Science, Vol. 921, pp. 50–63, Springer-Verlag, Berlin, 1995). VΣS enables the recipient of a digital signature, who is not necessarily the original signer, to share that signature among n proxies so that a subset of them can later reconstruct it. Efficient protocols were also given for RSA, Rabin, ElGamal, Schnorr, and DSS signatures. However, their RSA and Rabin VΣS protocols were subsequently broken and their DSS VΣS lacks a formal proof of security. We present new protocols for RSA, Rabin, and DSS VΣS. Our protocols are efficient and provably secure and can tolerate the malicious behavior of up to half of the proxies. The RSA VΣS scheme is based on a completely novel approach. The recipient of the signature will not share it using conventional secret sharing schemes, but instead will simply encrypt it using a threshold cryptosystem, i.e., a public key whose matching secret key is kept shared at the proxies. She will then also provide the proxies with a proof that the ciphertext indeed contains a signature. The crux of the problem was to design a threshold cryptosystem that would make such a proof efficient. We present several variants of our basic scheme, one of which requires no interaction between the recipient of the signature and the proxies to establish such a proof and one in which the reconstruction of the signature by the proxies is completely non-interactive. The RSA VΣS scheme can be easily adapted to Rabin's signatures. The DSS VΣS scheme is a modified version of the ElGamal VΣS scheme mentioned above which allows for a proof of security. The main application of VΣS is the incorporation of digital cash into multiparty protocols, e.g., cash escrow and secure distributed auctions. Our protocols thus provide simple, efficient, and secure solutions for those applications. Furthermore we believe that some of our techniques are of independent interest. Some of the by-products of our main result are a new threshold cryptosystem, a new undeniable signature scheme, and a way to create binding RSA cryptosystems
On the Limits of Nonapproximability of Lattice Problems

AbstractWe show simple constant-round interactive proof systems for problems capturing the approximability, to within a factor of n, of optimization problems in integer lattices, specifically, the closest vector problem (CVP) and the shortest vector problem (SVP). These interactive proofs are for the coNP direction; that is, we give an interactive protocol showing that a vector is far from the lattice (for CVP) and an interactive protocol showing that the shortest-lattice-vector is long (for SVP). Furthermore, these interactive proof systems are honest-verifier perfect zero-knowledge. We conclude that approximating CVP (resp., SVP) within a factor of n is in NP∩coAM. Thus, it seems unlikely that approximating these problems to within a n factor is NP-hard. Previously, for the CVP (resp., SVP) problem, Lagarias et al. (1990, Combinatorica10, 333–348), Håstad (1988, Combinatorica8, 75–81), and Banaszczyk (1993, Math. Annal.296, 625–635) showed that the gap problem corresponding to approximating CVP (resp., SVP) within n is in NP∩coNP. On the other hand, Arora et al. (1997, J. Comput. System Sci.54, 317–331) showed that the gap problem corresponding to approximating CVP within 2log0.999n is quasi-NP-hard