pinecone/core-2020-05-10-deduplication huggingface dataset:
A Sequent Calculus for Subtyping Polymorphic Types

AbstractWe present two complete systems for polymorphic types with sub- typing. One system is in the style of natural deduction, while another is a Gentzen-style sequent calculus system. We prove several meta- mathematical properties for these systems including cut elimination, subject reduction, coherence, and decidability of type reconstruction. Following the approach by J. Mitchell, the sequents are given a simple semantics using logical relations over applicative structures. The systems are complete with respect to this semantics. The logic which emerges from this paper can be seen as a successor to the original Hilbert style system proposed by J. Mitchell in 1988, and to the “half way” sequent calculus of G. Longo, K. Milsted, and S. Soloviev proposed in 1995
Learning to Win Process-Control Games Watching Game-Masters

AbstractThe present paper focuses on some interesting classes of process-control games, where winning essentially means successfully controlling the process. A master for one of these games is an agent who plays a winning strategy. In this paper we investigate situations in which even a complete model (given by a program) of a particular game does not provide enough information to synthesize—even incrementally—a winning strategy. However, if in addition to getting a program, a machine may also watch masters play winning strategies, then the machine is able to incrementally learn a winning strategy for the given game. Studied are successful learning from arbitrary masters and from pedagogically useful selected masters. It is shown that selected masters are strictly more helpful for learning than are arbitrary masters. Both for learning from arbitrary masters and for learning from selected masters, though, there are cases where one can learn programs for winning strategies from masters but not if one is required to learn a program for the master's strategy itself. Both for learning from arbitrary masters and for learning from selected masters, one can learn strictly more by watching m+1 masters than one can learn by watching only m. Last, a simulation result is presented where the presence of a selected master reduces the complexity from infinitely many semantic mind changes to finitely many syntactic ones
Reduction Algorithms for Graphs of Small Treewidth

AbstractThis paper presents a number of new ideas and results on graph reduction applied to graphs of bounded treewidth. S. Arnborg, B. Courcelle, A. Proskurowski, and D. Seese (J. Assoc. Comput. Mach.40, 1134–1164 (1993)) have shown that many decision problems on graphs can be solved in linear time on graphs of bounded treewidth, using a finite set of reduction rules. These algorithms can be used to solve problems on graphs of bounded treewidth without the need to obtain a tree decomposition of the input graph first. We show that the reduction method can be extended to solve the construction variants of many decision problems on graphs of bounded treewidth, including all problems definable in monadic second order logic. We also show that a variant of these reduction algorithms can be used to solve (constructive) optimization problems in O(n) time. For example, optimization and construction variants of INDEPENDENT SET and HAMILTONIAN COMPLETION NUMBER can be solved in this way on graphs of small treewidth. Additionally, we show that the results of H. L. Bodlaender and T. Hagerup (SIAM J. Comput.27, 1725–1746 (1998)) can be applied to our reduction algorithms, which results in parallel reduction algorithms that use O(n) operations and O(log n log* n) time on an EREW PRAM, or O(log n) time on a CRCW PRAM
Adding For-Loops to First-Order Logic

AbstractWe study the query language BQL: the extension of the relational algebra with for-loops. We also study FO(FOR): the extension of first-order logic with a for-loop variant of the partial fixpoint operator. In contrast to the known situation with query languages, which include while-loops instead of for-loops, BQL and FO(FOR) are not equivalent. Among the topics we investigate are: the precise relationship between BQL and FO(FOR); inflationary versus noninflationary iteration; the relationship with logics that have the ability to count; and nested versus unnested loops
SGML and XML Document Grammars and Exceptions

AbstractThe Standard Generalized Markup Language (SGML) and the Extensible Markup Language (XML) allow users to define document-type definitions (DTDs), which are essentially extended context-free grammars expressed in a notation that is similar to extended Backus–Naur form. The right-hand side of a production, called a content model, is both an extended and a restricted regular expression. The semantics of content models for SGML DTDs can be modified by exceptions (XML does not allow exceptions). Inclusion exceptions allow named elements to appear anywhere within the content of a content model, and exclusion exceptions preclude named elements from appearing in the content of a content model. We give precise definitions of the semantics of exceptions, and prove that they do not increase the expressive power of SGML DTDs when we restrict DTDs according to accepted SGML practice. We prove the following results:1. Exceptions do not increase the expressive power of extended context-free grammars.2. For each DTD with exceptions, we can obtain a structurally equivalent extended context-free grammar.3. For each DTD with exceptions, we can construct a structurally equivalent DTD when we restrict the DTD to adhere to accepted SGML practice.4. Exceptions are a powerful shorthand notation—eliminating them may cause exponential growth in the size of an extended context-free grammar or of a DTD
Verification by Augmented Finitary Abstraction

AbstractThe paper deals with the proof method of verification by finitary abstraction (VFA), which presents a feasible approach to the verification of the temporal properties of (potentially infinite-state) reactive systems. The method consists of a two-step process by which, in a first step, the system and its temporal specification are jointly abstracted into a finite-state system and a finite-state specification. The second step uses model checking to establish the validity of the abstracted property over the abstracted system. The VFA method can be considered a viable alternative to verification by temporal deduction which, up to now, has been the main method generally applicable for verification of infinite-state systems. The paper presents a general recipe for the joint abstraction, which is shown to be sound, where soundness means that validity over the abstract system implies validity over the concrete (original) system. To make the method applicable for the verification of liveness properties, pure abstraction is sometimes no longer adequate. We show that by augmenting the system by an appropriate (and standardly constructible) progress monitor, we obtain an augmented system, whose computations are essentially the same as the original system, and which may now be abstracted while preserving the desired liveness properties. We refer to the extended method as verification by augmented abstraction (VAA). We then proceed to show that the VAA method is sound and complete for proving all properties expressible by temporal logic (including both safety and liveness). Completeness establishes that whenever the property is valid, there exists a finitary abstraction which abstracts the system, augmented by an appropriate progress monitor, into a finite-state system which validated the abstracted property
On a Generalized Notion of Mistake Bounds

AbstractThis paper proposes the use of constructive ordinals as mistake bounds in the on-line learning model. This approach elegantly generalizes the applicability of the on-line mistake bound model to learnability analysis of very expressive concept classes like pattern languages, unions of pattern languages, elementary formal systems, and minimal models of logic programs. The main result in the paper shows that the topological property of effective finite bounded thickness is a sufficient condition for on-line learnability with a certain ordinal mistake bound. An interesting characterization of the on-line learning model is shown in terms of the identification in the limit framework. It is established that the classes of languages learnable in the on-line model with a mistake bound of α are exactly the same as the classes of languages learnable in the limit from both positive and negative data by a Popperian, consistent learner with a mind change bound of α. This result nicely builds a bridge between the two models
Linear Concurrent Constraint Programming: Operational and Phase Semantics

AbstractIn this paper we give a logical semantics for the class CC of concurrent constraint programming languages and for its extension LCC based on linear constraint systems. Besides the characterization in intuitionistic logic of the stores of CC computations, we show that both the stores and the successes of LCC computations can be characterized in intuitionistic linear logic. We illustrate the usefulness of these results by showing with examples how the phase semantics of linear logic can be used to give simple “semantical” proofs of safety properties of LCC programs
Approximating Unweighted Connectivity Problems in Parallel

AbstractGiven an integer k and a k-edge-connected graph G=(V, E), we wish to find an E′⊆E of minimum size such that the graph (V, E′) is k-edge-connected. This problem is NP-hard and the best performance ratio achieved by known NC approximation algorithms is 2. For the special case where the input integer k is fixed to be 2, it is known that a performance ratio of 1.5+ϵ for any ϵ>0 can be achieved by an NC approximation algorithm. This paper considers the more general case where k is polylogarithmic in the size of the input graph, and presents the first NC approximation algorithm with a performance ratio of 1.924 for this case. We also consider the vertex analogue of this problem in which we require k-vertex-connectivity instead of k-edge-connectivity. We present the first NC approximation algorithm with a performance ratio of 1.931 for the special case where the input integer k is fixed to be 3
Optimal Deterministic Protocols for Mobile Robots on a Grid

AbstractThis paper studies a system of m robots operating in a set of n work locations connected by aisles in a n×n grid, where m≤n. From time to time the robots need to move along the aisles, in order to visit disjoint sets of locations. The movement of the robots must comply with the following constraints: (1) no two robots can collide at a grid node or traverse a grid edge at the same time; (2) a robot's sensory capability is limited to detecting the presence of another robot at a neighboring node. We present a deterministic protocol that, for any small constant ϵ>0, allows m≤(1-ϵ)n robots to visit their target locations in O(dn) time, where each robot visits no more than d≤n targets and no target is visited by more than one robot. We also prove a lower bound showing that our protocol is optimal. Prior to this paper, no optimal protocols were known for d>1. For d=1, optimal protocols were known only for m≤n, while for general m≤n only a suboptimal randomized protocol was known
Optimal Pebble Motion on a Tree

AbstractIn this paper we consider the following pebble coordination problem. Consider a tree with n vertices and k pebbles located at distinct vertices of the tree. Each pebble can be moved from its current position to an adjacent unoccupied vertex. Among the k pebbles, one distinguished pebble has been assigned a destination. We give an O(n5) algorithm for the problem of designing the shortest sequence of moves that takes the distinguished pebble from its original position to its destination. Our algorithm improves the running time of the best previously presented algorithm that needed to solve O(n6) min-cost flow problems on graphs of size O(n). Our algorithm does not resort to reduction to flow but is instead based on a novel dynamic programming approach
Implementing Shared Memory on Mesh-Connected Computers and on the Fat-Tree

AbstractWe present deterministic upper and lower bounds on the slowdown required to simulate an (n, m)-PRAM on a variety of networks. The upper bounds are based on a novel scheme that exploits the splitting and combining of messages. This scheme can be implemented on an n-node d-dimensional mesh (for constant d) and on an n-leaf pruned butterfly and attains the smallest worst-case slowdown to date for such interconnections, namely, O(n1/d(log(m/n))1-1/d) for the d-dimensional mesh (with constant d) and O(nlog(m/n)) for the pruned butterfly. In fact, the simulation on the pruned butterfly is the first PRAM simulation scheme on an area-universal network. Finally, we prove restricted and unrestricted lower bounds on the slowdown of any deterministic PRAM simulation on an arbitrary network, formulated in terms of the bandwidth properties of the interconnection as expressed by its decomposition tree
On Weighted vs Unweighted Versions of Combinatorial Optimization Problems

AbstractWe investigate the approximability properties of several weighted problems, by comparing them with the respective unweighted problems. For an appropriate (and very general) definition of niceness, we show that if a nice weighted problem is hard to approximate within r, then its polynomially bounded weighted version is hard to approximate within r−o(1). Then we turn our attention to specific problems, and we show that the unweighted versions of MIN VERTEX COVER, MIN SAT, MAX CUT, MAX DICUT, MAX 2SAT, and MAX EXACTkSAT are exactly as hard to approximate as their weighted versions. We note in passing that MIN VERTEX COVER is exactly as hard to approximate as MIN SAT. In order to prove the reductions for MAX 2SAT, MAX CUT, MAX DICUT, and MAX E3SAT we introduce the new notion of “mixing” set and we give an explicit construction of such sets. These reductions give new non-approximability results for these problems
On the Decisional Complexity of Problems Over the Reals

AbstractWe consider the role of randomness for the decisional complexity in algebraic decision (or computation) trees, i.e., the number of comparisons ignoring all other computation. Recently Ting and Yao showed that the problem of finding the maximum of n elements has decisional complexity O(log2n) (1994, Inform. Process. Lett., 49, 39–43). In contrast, Rabin showed in 1972 an Ω(n) bound for the deterministic case (1972, J. Comput. System Sci., 6, 639–650). We point out that their technique is applicable to several problems for which corresponding Ω(n) lower bounds hold. We show that in general the randomized decisional complexity is logarithmic in the size of the decision tree. We then turn to the question of the number of random bits needed to obtain the Ting and Yao result. We provide a deterministic O(k log n) algorithm for finding the elements which are larger than a given element, given a bound k on the number of these elements. We use this algorithm to obtain an O(log2n) random bits and O(log2n) queries algorithm for finding the maximum
On Privacy and Partition Arguments

AbstractA function and f(x1, x2,…, xn) is said to be t-private if there exists a (randomized) communication protocol for computing f, such that no coalition of at most t participants can infer any additional information from the execution of the protocol other than what follows from their inputs and the value of f. It is known that every n-argument function f defined over finite domains can be computed ⌊n−12⌋-privately. The classes of 1-private two-argument functions and of t-private Boolean functions admit relatively simple characterizations. In contrast, the general question of characterizing the class of t-private functions of n arguments is still open. The only technique that appears in the literature for proving non-t-privacy of a function f(x1, x2,…,xn) over a finite domain, where n≥3 and ⌈n2⌉≤t≤n−1, uses a reduction to the two-party case via a partition argument. A necessary condition for f being t-private is that for every partition (S; S) of the parties {1, 2,…,n} such that both |S|≤t and |S|≤t, the two-argument function obtained by viewing f as a function of {xi}i∈S and {xi}i∈S is 1-private. The question whether the use of such partition reductions together with the two-party characterization is powerful enough to characterize privacy in the multiparty case was raised as an open problem in previous works. These works also exhibit an affirmative answer for specific classes of functions. We answer this question negatively. We show that even if more general partition reductions are used, in which the n parties are partitioned into k sets (2≤k≤n−1) rather than just two, those reductions are still too weak to characterize privacy. On the other hand, we show that increasing the number of sets k does give some extra characterization power
On Fairness Notions in Distributed Systems I. A Characterization of Implementability

AbstractThis is the first part of a two-part paper in which we discuss the implementability of fairness notions in distributed systems where asynchronous processes interact via synchronous constructs—usually called multiparty interactions. In this part we present a criterion for fairness notions and show that if a fairness notion violates the criterion, then no deterministic algorithm for scheduling multiparty interactions can satisfy the fairness notion. Conversely, the implementation is possible if the criterion is obeyed. Thus, the criterion is sufficient and necessary to guarantee the implementability of all possible fairness notions. To our knowledge, this is the first such criterion to appear in the literature. The main benefit of the proposed criterion is that it reduces reasoning about a complex and concrete implementation model to reasoning about a simpler and abstract model for process interaction. To illustrate this, we use the criterion to examine several important fairness notions, including strong interaction fairness, strong process fairness, weak process fairness, U-fairness, and hyperfairness. All, except weak process fairness, fail to pass the criterion. Moreover, we also apply the criterion to analyze the system structures rendering the impossibility phenomena. This analysis helps us separate, for each fairness notion, the set of systems for which the fairness notion can be implemented from those for which it cannot
On Fairness Notions in Distributed Systems II. Equivalence-Completions and Their Hierarchies

AbstractThis is the second part of a two-part paper in which we discuss the implementability of fairness notions in distributed systems where asynchronous processes interact via multiparty interactions. We focus here on equivalence-robust fairness notions where equivalence computations are either all fair or all unfair. Francez et al. (1992, Formal Aspects Comput.4, 582–591) propose a notion of completion to transform a non-equivalence-robust fairness notion to an equivalence-robust one while maintaining several properties of the source. However, a completion may not preserve strong feasibility—a necessary and sufficient condition for a completion to be implementable. In this paper, we study the system requirement for a completion to be strongly feasible and determine the strongest implementable completion for every given fairness notion. Moreover, for most systems we obtain a fairness notion, which we refer to as SG+, such that SG+ is the strongest fairness notion that is both implementable and equivalence-robust. We also provide a comprehensive comparison of SG+ and several well-known fairness notions and their minimal and maximal completions. Finally, we show that if equivalence-robustness is dropped, then in general it is impossible to define a fairness notion that is implementable and stronger than all other implementable fairness notions, unless the system consists of only one interaction. This implies plenty of leeway in the design of fairness notions suitable for various applications
Static Analysis for the π-Calculus with Applications to Security

AbstractControl Flow Analysis is a static technique for predicting safe and computable approximations to the set of values that the objects of a program may assume during its execution. We present an analysis for the π-calculus that shows how names will be bound to actual channels at run time. The result of our analysis establishes a super-set of the set of channels to which a given name may be bound and of the set of channels that may be sent along a given channel. Besides a set of rules that permits one to validate a given solution, we also offer a constructive procedure that builds solutions in low polynomial time. Applications of our analysis include establishing two simple security properties of processes. One example is that P has no leaks: P offers communication to the external environment through public channels only and confines its secret channels within itself. The other example is connected to the no read-up/no write-down property of Bell and LaPadula: once processes are given levels of security clearance, we check that a process at a high level never sends channels to processes at a lower level
The Complexity of the Kn,n-Problem for Node Replacement Graph Languages

AbstractThe bounded Kn,n-problem is the question whether or not a graph language of a given graph grammar contains arbitrarily large complete bipartite subgraphs Kn,n. In this paper, we investigate the complexity of this problem for all relevant classes of node replacement graph grammers. Our main result states that the bounded Kn,n-problem is NL-complete for reduced nonblocking eNCE graph grammars and for reduced linear NCE graph grammars. As an application, our results settle the complexity of the problems whether or not the graph language of a given confluent, boundary, or linear graph grammar has bounded tree-width and whether or not it is an HR graph language
On the Descriptive and Algorithmic Power of Parity Ordered Binary Decision Diagrams

AbstractThe main result of this paper is a polynomial time algorithm that minimizes the number of nodes in a parity OBDD (ordered binary decision diagram). Moreover, we prove that the synthesis and the equivalence test for ⊕OBDDs, which are the fundamental operations for circuit verification, have polynomial time deterministic solutions. We conclude that it takes deterministic polynomial time to decide whether the parity of clauses/implicants is satisfiable. Several functions typically used as examples in theory, e.g., the indirect storage access function, have exponential OBDD-size but are of polynomial size if ⊕OBDDs are used
A Theory of Observables for Logic Programs

AbstractWe define a semantic framework to reason about properties of abstractions of SLD-derivations. The framework allows us to address problems such as the relation between the (top-down) operational semantics and the (bottom-up) denotational semantics, the existence of a denotation for a set of definite clauses and their properties (compositionality w.r.t. various syntactic operators, correctness, minimality, and precision). Using abstract interpretation techniques to model abstraction allows us to state very simple conditions on the observables which guarantee the validity of several general theorems
Language-based Performance Prediction for Distributed and Mobile Systems

AbstractWe present a framework for performance prediction of distributed and mobile systems. We rely on process calculi and their structural operational semantics. The dynamic behaviour is described through transition systems whose transitions are labelled by encodings of their proofs that we then map into stochastic processes. We enhance related works by allowing general continuous distributions resorting to a notion of enabling between transitions. We also discuss how the number of resources available affects the overall model. Finally, we introduce a notion of bisimulation that takes stochastic information into account and prove it to be a congruence. When only exponential distributions are of interest our equivalence induces a lumpable partition on the underlying Markov process