pinecone/core-2020-05-10-deduplication huggingface dataset:
One-Unambiguous Regular Languages

AbstractThe ISO standard for the Standard Generalized Markup Language (SGML) provides a syntactic meta-language for the definition of textual markup systems. In the standard, the right-hand sides of productions are based on regular expressions, although only regular expressions that denote words unambiguously, in the sense of the ISO standard, are allowed. In general, a word that is denoted by a regular expression is witnessed by a sequence of occurrences of symbols in the regular expression that match the word. In an unambiguous regular expression as defined by Booket al.(1971,IEEE Trans. Comput.C-20(2), 149–153), each word has at most one witness. But the SGML standard also requires that a witness be computed incrementally from the word with a one-symbol lookahead; we call such regular expressions 1-unambiguous. A regular language is a 1-unambiguouslanguage if it is denoted by some 1-unambiguous regular expression. We give a Kleene theorem for 1-unambiguous languages and characterize 1-unambiguous regular languages in terms of structural properties of the minimal deterministic automata that recognize them. As a result we are able to prove the decidability of whether a given regular expression denotes a 1-unambiguous language; if it does, then we can construct an equivalent 1-unambiguous regular expression in worst-case optimal time
Local Simplification

AbstractWe present a modification to the paramodulation inference system, where semantic equality and nonequality literals are stored aslocal simplifierswith each clause. The local simplifiers are created when new clauses are generated and inherited by the descendants of that clause. Then the local simplifiers can be used to perform demodulation and unit simplification, if certain conditions are satisfied. This reduces the search space of the theorem proving procedure and the length of the proofs obtained. In fact, we show that for ground SLD resolution with any selection rule, any set of clauses has a polynomial length proof. Without this technique, proofs may be exponential. We show that this process is sound, complete, and compatible with deletion rules (e.g., demodulation, subsumption, unit simplification, and tautology deletion), which do not have to be modified to preserve completeness. We also show the relationship between this technique and model elimination
Set Constraints in Some Equational Theories

AbstractSet constraints are relations between sets of ground terms over a given alphabet. They give a natural formalism for many problems in program analysis, type inference, order-sorted unification, and constraint logic programming. In this paper we start studies of set constraints in the environment given by equational specifications. We show that in the case of associativity (i.e., in free monoids) as well as in the case of associativity and commutativity (i.e., in commutative monoids) the problem of consistency of systems of set constraints is undecidable; in linear nonerasing shallow theories the consistency of systems of positive set constraints is NEXPTIME-complete and in linear shallow theories the problem for positive and negative set constraints is decidable
Repeated Redundant Inequalities in Constraint Logic Programming

AbstractFuture redundant inequalities in a constraint logic program are those that are guaranteed to be subsumed after no more than one subsequent procedure call, whenever they are encountered at run time. It has been noted that such inequalities need only be tested for consistency with the current constraint set, thus resulting in dramatic savings in execution speed and space usage. Furthermore, they can be detected at compile time, leading to a valuable compiler optimization. By considering the role of such inequalities in a program, we generalize the notion of future redundancy in a number of ways and thus broaden its applicability. As a result, we show how to dramatically improve the performance of a wider class of programs that rely heavily on inequalities
Set Constraints and Logic Programming

AbstractSet constraints are inclusion relations between expressions denoting sets of ground terms over a ranked alphabet. They are the main ingredient in set-based program analysis. In this paper we describe a constraint logic programming languageclp(sc) over set constraints in the style of J. Jaffar and J.-L. Lassez (1987, “Proc. Symp. Principles of Programming Languages 1987,” pp. 111–119). The language subsumes ordinary logic programs over an Herbrand domain. We give an efficient unification algorithm and operational, declarative, and fixpoint semantics. We show how the language can be applied in set-based program analysis by deriving explicitly the monadic approximation of the collecting semantics of N. Heintze and J. Jaffar (1992, “Set Based Program Analysis”; 1990, “Proc. 17th Symp. Principles of Programming Languages,” pp. 197–209)
One-Unambiguous Regular Languages

AbstractThe ISO standard for the Standard Generalized Markup Language (SGML) provides a syntactic meta-language for the definition of textual markup systems. In the standard, the right-hand sides of productions are based on regular expressions, although only regular expressions that denote words unambiguously, in the sense of the ISO standard, are allowed. In general, a word that is denoted by a regular expression is witnessed by a sequence of occurrences of symbols in the regular expression that match the word. In an unambiguous regular expression as defined by Booket al.(1971,IEEE Trans. Comput.C-20(2), 149–153) each word has at most one witness. But the SGML standard also requires that a witness be computed incrementally from the word with a one-symbol lookahead; we call such regular expressions 1-unambiguous. A regular language is a 1-unambiguous languageif it is denoted by some 1-unambiguous regular expression. We give a Kleene theorem for 1-unambiguous languages and characterize 1-unambiguous regular language in terms of structural properties of the minimal deterministic automata that recognize them. As a result we are able to prove the decidability of whether a given regular expression denotes a 1-unambiguous language; if it does, then we can construct an equivalent 1-unambiguous regular expression in worst-case optimal time
Succinct Representation, Leaf Languages, and Projection Reductions

AbstractIn this article, the following results are shown: 1. For succinctly encoded problemss(A), completeness under polynomial time reductions is equivalent to completeness under projection reductions, an extremely weak reduction defined by a quantifier-free projective formula. 2. The succinct versions(Aof a computational problemAis complete under projection reductions for the class of problems characterizable with leaf languageA, but not complete undermonotoneprojections. 3. A strong conversion lemma: IfAis reducible toBin polylogarithmic time, then the succinct version ofAis monotone projection reducible to the succinct version ofB. This result strengthens previous results by Papadimitriou and Yannakakis, and Balcázar and Lozano. It allows iterated application for multiple succinct problems. 4. For all syntactic complexity classes there exist complete problems undermonotoneprojection reductions. This positively answers a question by Stewart for a large number of complexity classes
All Structured Programs Have Small Tree Width and Good Register Allocation

AbstractThe register allocation problem for an imperative program is often modeled as the coloring problem of the interference graph of the control-flow graph of the program. The interference graph of a flow graphGis the intersection graph of some connected subgraphs ofG. These connected subgraphs represent the lives, or life times, of variables, so the coloring problem models that two variables with overlapping life times should be in different registers. For general programs with unrestricted gotos, the interference graph can be any graph, and hence we cannot in general color within a factorO(nε) from optimality unless NP=P. It is shown that if a graph has tree widthk, we can efficiently color any intersection graph of connected subgraphs within a factor (⌊k/2⌋+1) from optimality. Moreover, it is shown that structured (≡goto-free) programs, including, for example, short circuit evaluations and multiple exits from loops, have tree width at most 6. Thus, for every structured program, we can do register allocation efficiently within a factor 4 from optimality, regardless of how many registers are needed. The bounded tree decomposition may be derived directly from the parsing of a structured program, and it implies that the many techniques for bounded tree width may now be applied in compiler optimization, solving problems in linear time that are NP-hard, or even P-space hard, for general graphs
General Bounds on Statistical Query Learning and PAC Learning with Noise via Hypothesis Boosting

AbstractWe derive general bounds on the complexity of learning in the statistical query (SQ) model and in the PAC model with classification noise. We do so by considering the problem of boosting the accuracy of weak learning algorithms which fall within the SQ model. This new model was introduced by Kearns to provide a general framework for efficient PAC learning in the presence of classification noise. We first show a general scheme for boosting the accuracy of weak SQ learning algorithms, proving that weak SQ learning is equivalent to strong SQ learning. The boosting is efficient and is used to show our main result of the first general upper bounds on the complexity of strong SQ learning. Since all SQ algorithms can be simulated in the PAC model with classification noise, we also obtain general upper bounds on learning in the presence of classification noise for classes which can be learned in the SQ model
Reflective Relational Machines

AbstractWe propose a model of database programming withreflection(dynamic generation of queries within the host programming language), called thereflective relational machine, and characterize the power of this machine in terms of known complexity classes. In particular, the polynomial time restriction of the reflective relational machine is shown to express PSPACE, and to correspond precisely to uniform circuits of polynomial depth and exponential size. This provides an alternative, logic based formulation of the uniform circuit model, which may be more convenient for problems naturally formulated in logic terms, and establishes that reflection allows for more “intense” parallelism, which is not attainable otherwise (unless P=PSPACE). We also explore the power of the reflective relational machine subject to restrictions on the number of variables used, emphasizing the case of sublinear bounds
A Constant-Space Sequential Model of Computation for First-Order Logic

AbstractWe define and justify a natural sequential model of computation with a constant amount of read/write work space, despite unlimited (polynomial) access to read-only input and write-only output. The model is deterministic, uniform, and sequential. The constant work space is modeled by a finite number of destructively read boolean variables, assignable by formulas over the canonical boolean operations. We show that computation on this model is equivalent to expressibility in first-order logic, giving a duality between (read-once) constant-space serial algorithms and constant-time parallel algorithms
A Restricted Second Order Logic for Finite Structures

AbstractWe introduce a restricted version of second order logic SOωin which the second order quantifiers range over relations that are closed under the equivalence relation ≡kofkvariable equivalence, for somek. This restricted second order logic is an effective fragment of the infinitary logicLω∞ω, but it differs from other such fragments in that it is not based on a fixed point logic. We explore the relationship of SOωwith fixed point logics, showing that its inclusion relations with these logics are equivalent to problems in complexity theory. We also look at the expressibility of NP-complete problems in this logic
A Formal Approach to the Integration of Performance Aspects in the Modeling and Analysis of Concurrent Systems

AbstractA formal approach for modeling and analyzing concurrent systems is proposed which integrates performance characteristics in the early stages of the design process. The approach relies on both stochastically timed process algebras and stochastically timed Petri nets in order to exploit their complementary advantages. The approach is instantiated to the case of EMPA (extended Markovian process algebra), introduced together with the collection of its four semantics and the notion of equivalence that are required in order to implement the approach. Finally, the case study of the alternating bit protocol is presented to illustrate the adequacy of the approach
Self-Stabilizing Ring Orientation Using Constant Space

AbstractThe ring-orientation problem requires all processors on an anonymous ring to reach agreement on a direction along the ring. A self-stabilizing ring-orientation protocol eventually ensures that all processors on the ring agree on a direction, regardless of the initial states of the processors on which the protocol is started. In this paper we present two uniform deterministic self-stabilizing ring-orientation protocols for rings with an odd number of processors using only a constant number of states per processor. The first protocol operates in the link-register model under the distributed daemon, and the second protocol operates in the state-reading model under the central daemon. Both protocols do not assume an upper bound on the length of the ring and are therefore applicable to dynamic rings. As an application of our techniques we are able to prove that under the central daemon on an odd-length ring, the link-register model and the state-reading model are equivalent in the sense that any self-stabilizing protocol for the one model can be transformed to an equivalent, self-stabilizing protocol in the other model
Optimal Mistake Bound Learning Is Hard

AbstractThis paper provides evidence that there is no polynomial-time optimal mistake bound learning algorithm. This conclusion is reached via several reductions as follows. Littlestone (1988,Math. Learning2, 285–318) has introduced a combinatorial functionKfrom classes to integers and has shown that if a subroutine computingKis given, one can construct a polynomial-time optimal MB learning algorithm. We establish the reverse reduction. That is, given an optimal MB learning algorithm as a subroutine, one can computeKin polynomial time. Our result combines with Littlestone's to establish that the two tasks above have the same time complexity up to a polynomial. Next, we show that the VC-dimension decision problem is polynomially reducible to theK-decision problem. Papadimitriou and Yannakakis [PY93] have provided a strong evidence that the VC-dimension decision problem is not in P. Therefore, it is very unlikely that there is a polynomial-time optimal mistake bound learning algorith
Completeness and Non-Completeness Results with Respect to Read-Once Projections

AbstractSeveral models of restricted branching programs or binary decision diagrams have a lot of applications in hardware verification. These models are investigated here from a complexity theoretical viewpoint. Because of depth restrictions projections are not suitable as reduction type and have to be restricted to read-once projections. Several types of polynomial-size binary decision diagrams have complete problems with respect to polynomial read-once projections. On the contrary it can be proved that the classes of polynomial-size decision trees and polynomial-size read-once branching programs or free binary decision diagrams do not have such complete problems
An Interpretation of Typed Objects into Typedπ-Calculus

AbstractAn interpretation of Abadi and Cardelli's first-order functionobject calculusinto a typedπ-calculus is presented. The interpretation validates the subtyping relation and the typing judgements of the object calculus and is computationally adequate. This is the first interpretation of a typed object-oriented language into a process calculus. The study intends to offer a contribution to understanding on the one hand, the relationship betweenπ-calculus types and conventional types of programming languages and on the other hand, the usefulness of theπ-calculus as a metalanguage for the semantics of typed object-oriented languages. The type language for theπ-calculus has Pierce and Sangiorgi's I/O annotations, to separate the capabilities of reading and writing on a channel and variant types. Technical contributions of the paper are the presentation ofvariant typesfor theπ-calculus and their typing and subtyping properties, and an analysis of behavioural equivalences in aπ-calculus with variant types
An Extension of Fixpoint Logic with a Symmetry-Based Choice Construct

AbstractWe propose a mechanism of restricted non-determinism in logical languages that uses a so-called symmetry-based choice operator whose application is restricted only on symmetric elements. Based on this mechanism, we define a logical language that is in PTIME but strictly more expressive than fixed-point logic with counting. This language is based, on the one hand, on an extension of the inflationary fixed-point logic with a choice operator, called specified symmetry choice, and, on the other hand, on an introduction of a so-called logical reduction operator, which when added to the above extension of fixpoint logic, allows us to increase the expressive power
Double Horn Functions

AbstractIn this paper, we define double Horn functions, which are the Boolean functionsfsuch that bothfand its complement (i.e., negation)fare Horn, and investigate their semantical and computational properties. Double Horn functions embody a balanced treatment of positive and negative information in the course of the extension problem of partially defined Boolean functions (pdBfs), where a pdBf is a pair (T,F) of disjoint setsT,F⊆{0,1}nof true and false vectors, respectively, and an extension of (T,F) is a Boolean functionfthat is compatible withTandF. We derive syntactic and semantic characterizations of double Horn functions, and determine the number of such functions. The characterizations are then exploited to give polynomial time algorithms (i) that recognize double Horn functions from Horn DNFs (disjunctive normal forms), and (ii) that compute the prime DNF from an arbitrary formula, as well as its complement and its dual. Furthermore, we consider the problem of determining a double Horn extension of a given pdBf. We describe a polynomial time algorithm for this problem and moreover an algorithm that enumerates all double Horn extensions of a pdBf with polynomial delay. However, finding a shortest double Horn extension (in terms of the size of a formulaϕrepresenting it) is shown to be intractable
Decidability of the Finiteness of Ranges of Tree Transductions

AbstractThe finiteness of ranges of tree transductions is shown to be decidable for TBY+, the composition closure of macro tree transductions. Furthermore, TBY+definable sets and TBY+computable relations are considered, which are obtained by viewing a tree as an expression that denotes an element of a given algebra. A sufficient condition on the considered algebra is formulated under which the finiteness problem is decidable for TBY+definable sets and for the ranges of TBY+computable relations. The obtained result applies in particular to the class of string languages that can be defined by TBY+transductions via the yield mapping. This is a large class which is proved to form a substitution-closed full AFL
The Combinatorics of Effective Resistances and Resistive Inverses

AbstractLet matrix (σij) denote the edge conductances of an electrical network, so that there is a resistor ofrij=1/σijohms between nodesiandj. This uniquely determines the matrix (Rij) ofeffective resistances, defined such that if a potential of 1 V is applied across nodesiandj, a current of 1/Rijwill flow. We call (σij) theresistive inverseof (Rij). One source of interest in the resistive inverse, arising in the design of on-line algorithms, is that it produces an efficient random walk if the walk must pay a cost ofrijfor traversing edge (i,j). Coppersmithet al.(1993,J. Assoc. Comput. Mach.40(3), 421–453) showed that the random walk that makes transitions according to (σij) is more efficient—more “competitive”—than the random walk that makes transitions according to (Rij). Coppersmithet al.gave a simple but obscure four-step algorithm for computing the resistive inverse. We give a complete self-contained combinatorial explanation of this algorithm, including the classical theorems of Kirchhoff and Foster
Perfectly Secure Key Distribution for Dynamic Conferences

AbstractIn this paper we analyze perfectly secure key distribution schemes for dynamic conferences. In this setting,anymember of a group oftusers can compute a common key using only his private initial piece of information and theidentitiesof the othert−1 users in the group. Keys are secure against coalitions of up tokusers; that is, even ifkusers pool together their pieces they cannot compute anything about a key of any conference comprised oftother users. First we consider a noninteractive model where users compute the common key without any interaction. We prove the tight bound on the size of each user's piece of information of[formula]times the size of the common key. Then, we consider the model where interaction is allowed in the common key computation phase and show agapbetween the models by exhibiting a one-round interactive scheme in which the user's information is onlyk+t−1 times the size of the common key. Finally, we present its adaptation to network topologies with neighbourhood constraints and to asymmetric (e.g., client-server) communication models
Full Abstractness for a Functional/Concurrent Language with Higher-Order Value-Passing

AbstractWe study an applied typed call-by-valueλ-calculus which in addition to the usual types for higher-order functions contains an extra type called proc, for processes; the constructors for terms of this type are similar to those found in standard process calculi such as CCS. We first give an operational semantics for this language in terms of a labeled transition system which is then used to give a behavioral preorder based on contexts; the expressionNdominatesMif in every appropriate context ifMcan produce a boolean value then so canN. Based on standard domain constructors we define a model, a prime algebraic lattice, which isfully abstractwith respect to this behavior preorder; expressions are related in the model if and only if they are related behaviorally. The proof method uses concepts that are of independent interest. It involves characterizing the domain using filters of a property logic for program expressions and developing a program logic for relating program expressions with property formulae