pinecone/core-2020-05-10-deduplication huggingface dataset:
Comparing Syntactic and Semantic Action Refinement

AbstractThe semantic definition of action refinement on labelled configuration structures is compared with the notion ofsyntactic substitution, which can be used as another notion of action refinement in a process algebraic setting. The comparison is done by studying a process algebra equipped with sequential composition, parallel composition with an explicit synchronisation set, and an operator for action refinement. On the one hand, the language (including the refinement operator) is given a configuration structure semantics. On the other hand, a reduction procedure transforms a process termPinto aflatterm (i.e., with the refinement operator not occurring in it)red(P) by means of syntactic substitution, defined in a structural inductive way. The main aim of the paper is to investigate general conditions under which the termsPandred(P) have the same semantics. The results we present are essentially dependent on the question whether the refined action can be synchronised or not. In the latter case,Pandred(P) give rise to isomorphic configuration structures under mild assumptions. The former case is considerably more difficult, since then refinement cannot be expected to distribute over parallel composition. We give necessary and sufficientsemanticconditions under which distribution still holds up to semantic equivalence. Subsequently, we also give sufficient (but not necessary)syntacticconditions for reducible terms. Finally, we generalise these results to a language with recursion
Normal Proofs and Their Grammar

AbstractWe present grammatical (or equational) descriptions of the set of normal inhabitants {M|Γ⊢M:A,Minβ-normal form} of a given typeAunder a given basisΓ, both for the standard simple type system (in the partial discharge convention) and for the system in the total discharge convention (or the Prawitz-style natural deduction system). It is shown that in the latter system we can describe the set by a (finite) context-free grammar, but for the standard system this is not necessarily the case because we may need an infinite supply of fresh (bound) variables to describe the set. In both cases, however, our grammars reflect the structure of normal inhabitants in such a way that, when non-terminals are ignored, a derivation tree of the grammars yielding aλ-termMcan be identified with Böhm tree ofM. We give some applications of the grammatical descriptions. Among others, we give simple algorithms for the emptiness/finiteness problem of the set of normal inhabitants of a given type (both for the standard and nonstandard systems)
Ntyft/ntyxt Rules Reduce to Ntree Rules

AbstractGroote and Vaandrager introduced thetyft/tyxt formatfor Transition System Specifications (TSSs), and established that for each TSS in this format that iswell-founded, the bisimulation equivalence it induces is a congruence. In this paper, we construct for each TSS in tyft/tyxt format an equivalent TSS that consists oftree rulesonly. As a corollary we can give an affirmative answer to an open question, namely whether the well-foundedness condition in the congruence theorem for tyft/tyxt can be dropped. These results extend to tyft/tyxt with negative premises and predicates
A Symbolic Semantics for theπ-Calculus

AbstractWe use symbolic transition systems as a basis for providing theπ-calculus with an alternative semantics. The latter is more amenable to automatic manipulation and sheds light on the logical differences among different forms of bisimulation over algebras of name-passing processes. Symbolic transitions have the form[formula], whereφis a boolean combination of equalities on names that has to hold for the transition to take place, andαis standard aπ-calculus action. On top of the symbolic transition system, a symbolic bisimulation is defined that captures the standard ones. Finally, a sound and complete proof system is introduced for symbolic bisimulation
Efficient Perfectly Secure Message Transmission in Synchronous Networks

AbstractWe study perfectly secure message transmission (SMT) in general synchronous networks where processors and communication lines may be Byzantine faulty. Dolevet al.(J. Assoc. Comput. Mach.40, No. 1, 17–47, Jan. 1993) first posed and solved the problem; our work significantly improves on their algorithms in the number of communication bits and the amount of local computation. Hence, our algorithms are better suited for traditional and fiber-optic networks than previous algorithms while requiring the same amount of connectivity. The algorithms we develop do not rely on any complexity theoretic assumptions and simultaneously achieve the three goals of perfect secrecy, perfect resiliency, and worst case time that is linear in the diameter of the 1?network. Our algorithms assume that the containment assumption holds, i.e., there is effectively one adversary who controls and coordinates the activities of the faulty processors and lines. In SMT, a processor (Sender) wishes to transmit a secret message to another processor (Receiver) in such a way as to satisfy secrecy and resiliency requirements simultaneously. In 1-waySMT, Sender can send information to Receiver via the wires that connect them, but Receiver cannot send information to Sender. In 2-waySMT, Sender and Receiver can send information to each other via the wires. Aphaseis a send from Sender to Receiver or vice versa. First, we develop a 3-phase algorithm for 2-way SMT. Next, we present a 2-phase algorithm for 2-way SMT. To our knowledge, this is the first 2-phase algorithm for SMT that uses communication and ?computation costs that are polynomial in the number of wires that connect the sender and the receiver. The second algorithm uses less time and more communication bits than the first algorithm. Both the 2?phase and 3-phase algorithms employ new techniques to detect faulty paths. We also present a simple algorithm for 1-way SMT
Contention-Free Complexity of Shared Memory Algorithms

AbstractWorst-case time complexity is a measure of the maximum time needed to solve a problem over all runs. Contention-free time complexity indicates the maximum time needed when a process executes by itself, without competition from other processes. Since contention is rare in well-designed systems, it is important to design algorithms which perform well in the absence of contention. We study the contention-free time complexity of shared memory algorithms using two measures: step complexity, which counts the number of accesses to shared registers; and register complexity, which measures the number of different registers accessed. Depending on the system architecture, one of the two measures more accurately reflects the elapsed time. We provide lower and upper bounds for the contention-free step and register complexity of solving the mutual exclusion problem as a function of the number of processes and the size of the largest register that can be accessed in one atomic step. We also present bounds on the worst-case and contention-free step and register complexities of solving the naming problem. These bounds illustrate that the proposed complexity measures are useful in differentiating among the computational powers of different primitive
The Discriminating Power of Multiplicities in theλ-Calculus

AbstractTheλ-calculus with multiplicities is a refinement of the lazyλ-calculus where the argument in an application comes with a multiplicity, which is an upper bound to the number of its uses. This introduces potential deadlocks in the evaluation. We study the discriminating power of this calculus over the usualλ-terms. We prove in particular that the observational equivalence induced by contexts with multiplicities coincides with the equality of Lévy–Longo trees associated withλ-terms. This is a consequence of the characterization we give of the corresponding observational precongruence, as an intensional preorder involvingη-expansion, namely, Ong's lazy Plotkin–Scott–Engeler preorder
Aperiodic Languages in Concurrency Monoids

AbstractAutomata with concurrency relations A are labelled transition systems with a collection of binary relations indicating when two events, in a given state of the automaton, are concurrent. We investigate concurrency monoidsM(A) comprising all finite computation sequences of A, modulo a canonical congruence induced by the concurrency relations, with composition as monoid operation. Under suitable assumptions on A we obtain a characterization of the star- free languages ofM(A). This generalizes a classical result of M. P. Schützenberger and a result of G. Guaiana, A. Restivo and S. Salemi in trace theory
Lower Bounds on Learning Decision Lists and Trees

Abstractk-Decision lists and decision trees play important roles in learning theory as well as in practical learning systems.k-Decision lists generalize classes such as monomials,k-DNF, andk-CNF, and like these subclasses they are polynomially PAC-learnable [R. Rivest,Mach. Learning2(1987), 229–246]. This leaves open the question of whetherk-decision lists can be learned as efficiently ask-DNF. We answer this question negatively in a certain sense, thus disproving a claim in a popular textbook [M. Anthony and N. Biggs, “Computational Learning Theory,” Cambridge Univ. Press, Cambridge, UK, 1992]. Decision trees, on the other hand, are not even known to be polynomially PAC-learnable, despite their widespread practical application. We will show that decision trees are not likely to be efficiently PAC-learnable. We summarize our specific results. The following problems cannot be approximated in polynomial time within a factor of 2logδnfor anyδ<1, unlessNP⊂DTIME[2polylogn]: a generalized set cover,k-decision lists,k-decision lists by monotone decision lists, and decision trees. Decision lists cannot be approximated in polynomial time within a factor ofnδ, for some constantδ>0, unlessNP=P. Also,k-decision lists withl0–1 alternations cannot be approximated within a factor loglnunlessNP⊂DTIME[nO(loglogn)] (providing an interesting comparison to the upper bound obtained by A. Dhagat and L. Hellerstein [in“FOCS '94,” pp. 64–74])
Combining Decision Algorithms for Matching in the Union of Disjoint Equational Theories

AbstractThis paper addresses the problem of systematically building a matching algorithm for the union of two disjoint theoriesE1∪E2provided that matching algorithms are known in both theoriesE1andE2. In general, the blind use of combination techniques introduces unification. Two different restrictions are considered in order to reduce this unification to matching. First, we show that combining matching algorithms (with linear constant restriction) is always sufficient for solving a pure fragment of combined matching problems. Second, the investigated method is complete for the largest class of theories where unification is not needed, including regular collapse-free theories and linear theories. Syntactic conditions are given to define this class of theories in which solving the combined matching problem is performed in a modular way
Sensitive Functions and Approximate Problems

AbstractProperties of functions that are good measures of the CRCW PRAM complexity of computing them are investigated. While theblock sensitivityis known to be a good measure of the CREW PRAM complexity, no such measure is known for CRCW PRAMs. It is shown that the complexity of computing a function is related to itseverywhere sensitivity, introduced by Vishkin and Wigderson. Specifically, the time required to compute a functionf:Dn→Rof everywhere sensitivityes(f) withPprocessors and unbounded memory isΩ(log[loges(f)/(log(|D|+4P/es(f)))]). This improves results of Azar and of Vishkin and Wigderson. This lower bound is used to derive new lower bounds for someapproximate problems. These problems can often be solved faster than their exact counterparts and for many applications, it is sufficient to solve the approximate problem. It is shown thatapproximate selection,approximate counting,approximate compaction, andpadded sortingall require timeΩ(loglogn) with a linear number of processors, if the level of accuracy desired is moderately high. For these levels of accuracy, no lower bounds were known for these problems on the PRAM model. The lower bounds for some of the problems are tight
Bayesianism: An Algorithmic Analysis

AbstractThe Bayesian program in statistics starts from the assumption that an individual can always ascribe a definite probability to any event. It will be demonstrated that this assumption is incompatible with the natural requirement that the individual's subjective probability distribution should be computable. We shall construct a probabilistic algorithm producing with probability extremely close to 1 an infinite binary sequence which is not random with respect to any computable probability distribution (we use Dawid's notion of randomness,computable calibration, but the results hold for other widely known notions of randomness as well). Since the Bayesian knows the algorithm, he must believe that this sequence will be noncalibrable. On the other hand, it seems that the Bayesian must believe that the sequence is random with respect to his own probability distribution. We hope that the discussion of this apparent paradox will clarify the foundations of Bayesian statistics. We analyse also the time of computation and the place of “losing randomness.” We show that we need only polynomial time and space to demonstrate non-calibration effects on finite sequences
Real Number Computability and Domain Theory

AbstractWe present the different constructive definitions of real number that can be found in the literature. Using domain theory we analyse the notion of computability that is substantiated by these definitions and we give a definition of computability for real numbers and for functions acting on them. This definition of computability turns out to be equivalent to other definitions given in the literature using different methods. Domain theory is a useful tool to study higher order computability on real numbers. An interesting connection between Scott topology and the standard topologies on the real line and on the space of continuous functions on reals is stated. An important result in this paper is the proof that every computable functional on real numbers is continuous w.r.t. the compact open topology on the function space
Axiomatizing Prefix Iteration with Silent Steps

AbstractPrefix iteration is a variation on the original binary version of the Kleene star operationP*Q, obtained by restricting the first argument to be an atomic action. The interaction of prefix iteration with silent steps is studied in the setting of Milner's basic CCS. Complete equational axiomatizations are given for four notions of behavioural congruence over basic CCS with prefix iteration, viz., branching congruence,η-congruence, delay congruence, and weak congruence. The completeness proofs forη-, delay, and weak congruence are obtained by reduction to the completeness theorem for branching congruence. It is also argued that the use of the completeness result for branching congruence in obtaining the completeness result for weak congruence leads to a considerable simplification with respect to the only direct proof presented in the literature. The preliminaries and the completeness proofs focus on open terms, i.e., terms that may contain process variables. As a by-product, theω-completeness of the axiomatizations is obtained, as well as their completeness for closed terms
The Limit of Splitn-Language Equivalence

AbstractSplitting is a simple form of action refinement that may be used to express the duration of actions. In particular,splitnsubdivides each action intonphases. Petri netsNandN′ aresplitn-language equivalent ifsplitn(N) andsplitn(N′) are language equivalent. It is known that these equivalences get finer and finer with increasingn. This paper characterizes the limit of this sequence by a newly defined partial order semantics. This semantics is obtained from the interval-semiword semantics, which is fully abstract for action refinement and language equivalence, by closing it under a special swap operation. The new swap equivalence lies strictly between interval-semiword and step-sequence equivalence
Relational Properties of Domains

AbstractNew tools are presented for reasoning about properties of recursively defined domains. We work within a general, category-theoretic framework for various notions of “relation” on domains and for actions of domain constructors on relations. Freyd's analysis of recursive types in terms of a property of mixed initiality/finality is transferred to a corresponding property ofinvariantrelations. The existence of invariant relations is proved under completeness assumptions about the notion of relation. We show how this leads to simpler proofs of the computational adequacy of denotational semantics for functional programming languages with user-declared datatypes. We show how the initiality/finality property of invariant relations can be specialized to yield an induction principle for admissible subsets of recursively defined domains, generalizing the principle of structural induction for inductively defined sets. We also show how the initiality/finality property gives rise to the co-induction principle studied by the author. [Theoret. Comput. Sci.124, 195–219 (1994)], by which equalities between elements of recursively defined domains may be proved via an appropriate notion of “bisimulation.
Verifying Programs with Unreliable Channels

AbstractWe consider the verification of a particular class of infinite-state systems, namely systems consisting of finite-state processes that communicate via unbounded lossy FIFO channels. This class is able to model, e.g., link protocols such as the Alternating Bit Protocol and HDLC. For this class of systems, we show that several interesting verification problems are decidable by giving algorithms for verifying (1) thereachability problem—is a finite set of global states reachable from some other global state of the system ? (2)safety properties over tracesformulated as regular sets of allowed finite traces, and (3)eventuality properties—do all computations of a system eventually reach a given set of states? We have used the algorithms to verify some idealized sliding-window protocols with reasonable time and space resources. Our results should be contrasted with the well-known fact that these problems are undecidable for systems with unboundedperfectFIFO channels
Standard ML–NJ Weak Polymorphism and Imperative Constructs

AbstractStandard ML of New Jersey (SML–NJ) uses “weak type variables” to restrict the polymorphic use of functions that may allocate reference cells, manipulate continuations, or use exceptions. However, the type system used in the SML–NJ compiler has not previously been presented in a form other than source code nor proved correct. We present a set of typing rules, based on analysis of the concepts underlying “weak polymorphism”, that appears to subsume the implemented algorithm and uses type variables of only a slightly more general nature than the compiler. One insight in the analysis is that allowing a variable to occur both “ordinarily” and “weakly” in a type permits a simpler and more flexible formulation of the typing rules. In particular, we are able to treat applications of polymorphic functions to imperative arguments with greater flexibility than SML–NJ. The soundness of the type system is proved for imperative code using operational semantics, by showing that evaluation preserves typability. By incorporating assumptions about memory addresses in the type system, we avoid proofs by co-induction
Database Query Languages Embedded in the Typed Lambda Calculus

AbstractWe investigate the expressive power of the typedλ-calculus when expressing computations over finite structures, i.e., databases. We show that the simply typedλ-calculus can express various database query languages such as the relational algebra, fixpoint logic, and the complex object algebra. In our embeddings, inputs and outputs areλ-terms encoding databases, and a program expressing a query is aλ-term which types when applied to an input and reduces to an output. Our embeddings have the additional property that PTIME computable queries are expressible by programs that, when applied to an input, reduce to an output in a PTIME sequence of reduction steps. Under our database input-output conventions, all elementary queries are expressible in the typedλ-calculus and the PTIME queries are expressible in the order-5 (order-4) fragment of the typedλ-calculus (with equality)
Full Abstraction for a Shared-Variable Parallel Language

AbstractWe give a new denotational semantics for a shared-variable parallel programming language and prove full abstraction: the semantics gives identical meanings to commands if and only if they induce the same behavior in all program contexts. The meaning of a command is a set of “transition traces,” which record the ways in which a command may interact with and be affected by its environment. We show how to modify the semantics to incorporate new program constructs, to allow for different levels of granularity or atomicity, and to model fair infinite computation, in each case achieving full abstraction with respect to an appropriate notion of program behavior
Bisimulation from Open Maps

AbstractAn abstract definition of bisimulation is presented. It makes possible a uniform definition of bisimulation across a range of different models for parallel computation presented as categories. As examples, transition systems, synchronisation trees, transition systems with independence (an abstraction from Petri nets), and labelled event structures are considered. On transition systems the abstract definition readily specialises to Milner's strong bisimulation. On event structures it explains and leads to a strengthening of the history-preserving bisimulation of Rabinovitch and Traktenbrot and van Glabeek and Goltz. A tie-up with open maps in a (pre)topos, as they appear in the work of Joyal and Moerdijk, brings to light a new model, presheaves on categories of pomsets, into which the usual category of labelled event structures embeds fully and faithfully. As an indication of its promise, this new presheaf model has “refinement” operators. The general approach yields a logic, generalising Hennessy–Milner logic, which is characteristic for the generalised notion of bisimulation
A Coinduction Principle for Recursive Data Types Based on Bisimulation

AbstractThe concept of bisimulation from concurrency theory is used to reason about recursively defined data types. From two strong-extensionality theorems stating that the equality (resp. inequality) relation is maximal among all bisimulations, a proof principle for the final coalgebra of an endofunctor on a category of data types (resp. domains) is obtained. As an application of the theory developed, an internal full abstraction result (in the sense of S. Abramsky and C.-H. L. Ong [Inform. and Comput.105, 159–267 (1993)] for the canonical model of the untyped call-by-valueλ-calculus is proved. Also, the operational notion of bisimulation and the denotational notion of final semantics are related by means of conditions under which both coincide
Forward and Backward Simulations II. Timing-Based Systems

AbstractA general automaton model for timing-based systems is presented and is used as the context for developing a variety of simulation proof techniques for such systems. These techniques include (1) refinements, (2) forward and backward simulations, (3) hybrid forward–backward and backward–forward simulations, and (4) history and prophecy relations. Relationships between the different types of simulations, as well as soundness and completeness results, are stated and proved. These results are (with one exception) analogous to the results for untimed systems in Part I of this paper. In fact, many of the results for the timed case are obtained as consequences of the analogous results for the untimed case