pinecone/core-2020-05-10-deduplication huggingface dataset:
Complexity of Nilpotent Unification and Matching Problems

AbstractWe consider the complexity of equational unification and matching problems where the equational theory contains a nilpotent function, i.e., a function f satisfying f(x, x)=0 where 0 is a constant. We show that nilpotent unification and matching are NP-complete. In the presence of associativity and commutativity, the problems still remain NP-complete. However, when 0 is also assumed to be the unity for the function f, the problems are solvable in polynomial time. We also show that the problem remains in P even when a homomorphism is added. An application of this result to a subclass of set constraints is illustrated. Second-order matching modulo nilpotence is shown to be undecidable
Building Decision Procedures for Modal Logics from Propositional Decision Procedures: The Case Study of Modal K(m)

AbstractThe goal of this paper is to propose a new technique for developing decision procedures for propositional modal logics. The basic idea is that propositional modal decision procedures should be developed on top of propositional decision procedures. As a case study, we consider satisfiability in modal K(m), that is modal K with m modalities, and develop an algorithm, called KSAT, on top of an implementation of the Davis–Putnam–Longemann–Loveland procedure. KSAT is thoroughly tested and compared with various procedures and in particular with the state-of-the-art tableau-based system KRIS. The experimental results show that KSAT outperforms KRIS and the other systems of orders of magnitude, highlight an intrinsic weakness of tableau-based decision procedures, and provide partial evidence of a phase transition phenomenon for K(m)
The Achievement of Knowledge Bases by Cycle Search

AbstractForward chaining is an algorithm that is particularly simple and therefore used in many inference systems. It computes the facts that are implied by a set of facts and rules. Unfortunately, this algorithm is not complete with respect to negation. To solve this problem, it is possible, in the context of propositional calculus, to automatically add the rules needed to make forward chaining complete. This transformation is a logical compilation of knowledge bases. This article presents a new method, based on a cycle search in a graph associated to the set of rules to compile, which allows a precise identification of what is needed for completeness
Using Tableaux to Automate the Lambek and Other Categorial Calculi

AbstractWe argue that, although labeled deduction can be quite costly in general, the complexity of keeping track of the label constraints built to encode the structure of the proofs does not necessarily render the strategy impractical. The point is illustrated with LLKE, a tableaux system for specification and test of categorial grammars. The paper presents and discusses the application of theorem proving in labeled analytic tableaux to natural language processing (NLP), describes algorithms and rules for tableau generation, introduces a new label-checking strategy, and identifies places where the complexity of the task can be tamed
Unification Algorithms Cannot Be Combined in Polynomial Time

AbstractWe establish that there is no polynomial-time general combination algorithm for unification in finitary equational theories, unless the complexity class #P of counting problems is contained in the class FP of function problems solvable in polynomial time. The prevalent view in complexity theory is that such a collapse is extremely unlikely for a number of reasons, including the fact that the containment of #P in FP implies that P=NP. Our main result is obtained by establishing the intractability of the counting problem for general AG-unification, where AG is the equational theory of Abelian groups. More specifically, we show that computing the cardinality of a minimal complete set of unifiers for general AG-unification is a #P-hard problem. In contrast, AG-unification with constants is known to be solvable in polynomial time. Since an algorithm for general AG-unification can be obtained as a combination of a polynomial-time algorithm for AG-unification with constants and a polynomial-time algorithm for syntactic unification, it follows that no polynomial-time general combination algorithm exists, unless #P is contained in FP. This implication of our main results holds not only for the combination of unification algorithms, but also for the combination of constraint solvers as well. We also show that the counting problem for Boolean ring unification is #P-hard; this gives a lower bound on the performance of all algorithms for general BR-unification
Automatic Acquisition of Search Control Knowledge from Multiple Proof Attempts

AbstractWe present two inference control heuristics for equational deduction that are based on the evaluation of previous successful proof attempts in domains of interest. The first evaluation function works by symbolic retrieval of generalized patterns from a knowledge base, and the second function compiles the knowledge into abstract term evaluation trees. Both heuristics have been implemented into the distributed equational proof system DISCOUNT. We analyze the performance of the heuristics on several sets of examples (including the subset of all unit-equality problems from the TPTP collection) and demonstrate their usefulness
On Terminating Lemma Speculations

AbstractThe improvement of theorem provers by reusing previously computed proofs is investigated. A method for reusing proofs is formulated as an instance of the problem reduction paradigm such that lemmata are speculated as proof obligations, being subject for subsequent reuse attempts. We motivate and develop a termination requirement, prove its soundness, and show that the reusability of proofs is not spoiled by the termination requirement imposed on the reuse procedure. Additional evidence for the general usefulness of the proposed termination order is given for lemma speculation in induction theorem proving
Partitioning Methods for Satisfiability Testing on Large Formulas

AbstractMethods for partitioning large propositional formulas are investigated, with the goal of producing a set of smaller formulas whose satisfiability can be determined within reasonable time frames by known algorithms. CNF formula partitioning can be viewed as hypergraph partitioning, which has been studied extensively in VLSI design. Although CNF formulas have been considered as hypergraphs before, we found that this viewpoint was not productive for partitioning, and we introduce a new viewpoint in the dual hypergraph. Hypergraph partitioning technology from VLSI design is adapted to this problem. The overall goal of satisfiability testing requires criteria different from those used in VLSI design. Several heuristics are described and investigated experimentally. Some formulas from circuit applications that were extremely difficult or impossible for existing algorithms have been solved. However, the method is not useful on formulas with little or no structure, such as randomly generated formulas
Practically Useful Variants of Definitional Translations to Normal Form

AbstractIn this paper, we compare different normal form translations from a practical point of view. The usual translation of a closed first-order formula to a disjunctive normal form has severe drawbacks, namely the disruption of the formula's structure and an exponential worst case complexity. In contrast, definitional translations avoid these drawbacks by introducing some additional new predicates yielding a moderate increase of the length of the normal form. In implementations, the standard translation is preferred, possibly because the theorem prover has to cope with some additional redundancy introduced by the new predicates. We show that definitional translations can excellently compete with the usual translation by providing run-time measurements with our theorem prover KoMeT. Moreover, for some problems, proofs can only be obtained in reasonable time if definitional translations are used
Optimal Axiomatizations of Finitely Valued Logics

AbstractWe investigate the problem of finding optimal axiomatizations for operators and distribution quantifiers in finitely valued first-order logics. We show that the problem can be viewed as the minimization of certain propositional formulas. We outline a general procedure leading to optimized operator and quantifier rules for the sequent calculus, for natural deduction, and for clause formation. The main tools are variants of two-valued and many-valued propositional resolution, as well as a novel rule called combination. In the case of operators and quantifiers based on semilattices, rules with a minimal branching degree can be obtained by instantiating a schema, which can also be used for optimal tableaux with sets-as-signs
Efficient Model Generation through Compilation

AbstractWe present a collection of simple but powerful techniques for enhancing the efficiency of tableau-based model generators such as Satchmo. The central ideas are to compile a clausal first order theory into a procedural Prolog program and to avoid redundant work of a naı&#x0308;ve implementation. We have compared various combinations of our techniques among each other and with theorem provers based on various calculi, using the TPTP problem library as a benchmark. Our implementation has turned out to be the most efficient for range-restricted problems and for a class of problems we call nonnesting
A Timed Concurrent Constraint Language

AbstractWe study a timed concurrent constraint language, called tccp, which is obtained by a natural timed interpretation of the usual ccp constructs: action-prefixing is interpreted as the next-time operator and the parallel execution of agents follows the scheduling policy of maximal parallelism. Additionally, tccp includes a simple primitive which allows one to specify timing constraints. We define the operational semantics of tccp by means of a transition system and we define a denotational model which is fully abstract with respect to the usual notion of observables (that is, the results of terminating computations). Moreover, we study the semantics and expressive power of the notion of maximal parallelism underlying the computational model of tccp: We define a fully abstract semantics for a sublanguage of tccp, called ccpm, which essentially is concurrent constraint programming, provided that we interpret the parallel operator in terms of maximal parallelism rather than of interleaving. We show that tccp is strictly more expressive than ccpm which, in its turn, is strictly more expressive than ccp
Structuring Metatheory on Inductive Definitions

AbstractWe examine a problem for machine supported metatheory. There are true statements about a theory that are true of some (but only some) extensions; however, standard theory-structuring facilities do not support selective inheritance. We use the example of the deduction theorem for modal logic and show how a statement about a theory can explicitly formalize the closure conditions extensions should satisfy for it to remain true. We show how metatheories based on inductive definitions allow theories and general metatheorems to be organized this way and report on a case study using the theory FS0
Communication Protocols for Secure Distributed Computation of Binary Functions

AbstractA common task in parallel processing is the distributed computation of a function by a number of processors, each of which possesses partial information relevant to the value of that function. In this paper we develop communication protocols which allow for such computation to take place while maintaining the value of the function secret to an eavesdropper. Of interest is the communication complexity of such protocols. We begin by considering two processors and two channels, one secret and one public, and present a protocol which minimizes the number of bits exchanged over the secret channel, while maintaining ε-uncertainty about the value of the function for the eavesdropper. We show that all binary functions can be kept ε-secret using a constant number of bits independent of the size of their domain. We then generalize our results to N processors communicating over a network of arbitrary topology
On designing optimal parallel triangular solvers

AbstractThis paper explores the problem of solving triangular linear systems on parallel distributed-memory machines. Working within the LogP model, tight asymptotic bounds for solving these systems using forward/backward substitution are presented. Specifically, lower bounds on execution time independent of the data layout, lower bounds for data layouts in which the number of data items per processor is bounded, and lower bounds for specific data layouts commonly used in designing parallel algorithms for this problem are presented in this paper. Furthermore, algorithms are provided which have running times within a constant factor of the lower bounds described. One interesting result is that the popular two-dimensional block matrix layout necessarily results in significantly longer running times than simpler one-dimensional schemes. Finally, a generalization of the lower bounds to banded triangular linear systems is presented
Decoding Choice Encodings

AbstractWe study two encodings of the asynchronous π-calculus with input-guarded choice into its choice-free fragment. One encoding is divergence-free, but refines the atomic commitment of choice into gradual commitment. The other preserves atomicity, but introduces divergence. The divergent encoding is fully abstract with respect to weak bisimulation, but the more natural divergence-free encoding is not. Instead, we show that it is fully abstract with respect to coupled simulation, a slightly coarser—but still coinductively defined—equivalence that does not enforce bisimilarity of internal branching decisions. The correctness proofs for the two choice encodings introduce a novel proof tech- nique exploiting the properties of explicit decodings from translations to source terms
Type Reconstruction for Linear π-Calculus with I/O Subtyping

AbstractPowerful concurrency primitives in recent concurrent languages and thread libraries provide great flexibility about implementation of high-level features like concurrent objects. However, they are so low-level that they often make it difficult to check global correctness of programs or to perform nontrivial code optimization, such as elimination of redundant communication. In order to overcome those problems, advanced type systems for input-only/output-only channels and linear (use-once) channels have been recently studied, but the type reconstruction problem for those type systems remained open, and therefore, their applications to concurrent programming languages have been limited. In this paper, we develop type reconstruction algorithms for variants of Kobayashi, Pierce, and Turner's linear channel type system with Pierce and Sangiorgi's subtyping based on input-only/output-only channel types and prove correctness of the algorithms. To our knowledge, no complete type reconstruction algorithm has been previously known for those type systems. We have implemented one of the algorithms and incorporated it into the compiler of the concurrent language HACL. This paper also shows some experimental results on the algorithm and its application to compile-time optimizations
Induction=I-Axiomatization+First-Order Consistency

AbstractIn the early 1980s, there was a number of papers on what should be called proofs by consistency. They describe how to perform inductive proofs, without using an explicit induction scheme, in the context of equational specifications and ground-convergent rewrite systems. The method was explicitly stated as a first-order consistency proof in the case of pure equational, constructor-based specifications. In this paper, we show how, in general, inductive proofs can be reduced to first-order consistency and hence be performed by a first-order theorem prover. Moreover, we extend previous methods, allowing nonequational specifications (even non-Horn specifications) and designing some specific strategies. Finally, we also show how to drop the ground convergence requirement (which is called Saturatedness for general clauses)
Descendants and Origins in Term Rewriting

AbstractIn this paper we treat various aspects of a notion that is central in term rewriting, namely that of descendants or residuals. We address both first-order term rewriting and λ-calculus, their finitary as well as their infinitary variants. A recurrent theme is the parallel moves lemma. Next to the classical notion of descendant, we introduce an extended version, known as origin tracking. Origin tracking has many applications. Here it is employed to give new proofs of three classical theorems: the genericity lemma in λ-calculus, the theorem of Huet and Lévy on needed reductions in first-order term rewriting, and Berry's sequentiality theorem in (infinitary) λ-calculus
On the Undecidability of Second-Order Unification

AbstractThere is a close relationship between word unification and second-order unification. This similarity has been exploited, for instance, in order to prove decidability of monadic second-order unification and decidability of linear second-order unification when no second-order variable occurs more than twice. The attempt to prove the second result for (nonlinear) second-order unification failed and led instead to a natural reduction from simultaneous rigid E-unification to this second-order unification. This reduction is the first main result of this paper, and it is the starting point for proving some novel results about the undecidability of second-order unification presented in the rest of the paper. We prove that second-order unification is undecidable in the following three cases: (1) each second-order variable occurs at most twice and there are only two second-order variables; (2) there is only one second-order variable and it is unary; (3) the following conditions (i)–(iv) hold for some fixed integer n: (i) the arguments of all second-order variables are ground terms of size <n, (ii) the arity of all second-order variables is <n, (iii) the number of occurrences of second-order variables is ⩽5, (iv) there is either a single second-order variable or there are two second-order variables and no first-order variables
Ordering Constraints over Feature Trees Expressed in Second-Order Monadic Logic

AbstractThe language FT⩽ of ordering constraints over feature trees has been introduced as an extension of the system FT of equality constraints over feature trees. While the first-order theory of FT is well understood, only few decidability results are known for the first-order theory of FT⩽. We introduce a new method for proving the decidability of fragments of the first-order theory of FT⩽. This method is based on reduction to second order monadic logic that is decidable according to Rabin's famous tree theorem. The method applies to any fragment of the first-order theory of FT⩽ for which one can change the model towards sufficiently labeled feature trees—a class of trees that we introduce. As we show, the first order-theory of ordering constraints over sufficiently labeled feature trees is equivalent to second-order monadic logic (S2S for infinite and WS2S for finite feature trees). We apply our method for proving that entailment of FT⩽ with existential quantifiers ϕ1⊨∃x1…∃xnϕ2 is decidable. Previous results were restricted to entailment without existential quantifiers which can be solved in cubic time. Meanwhile, entailment with existential quantifiers has been shown to be PSPACE-complete (for finite and infinite feature trees, respectively)
On the Impossibility of Interaction-Free Quantum Sensing for Small I/O Bandwidth

AbstractA method for (nearly) interaction-free measurement (IFM) specifies the design of a quantum optical sensing system that is able to determine with arbitrarily high likelihood if an obstructing body has been inserted into the system, without moving or modifying its optical components, and uses at most an arbitrarily small multiplicative factor of the input intensity to do the sensing when the obstructing body is present. Kwiat et al. (1995, Phys. Rev. Lett.74, 4763–4766) have given a method for IFM. We give a precise mathematical formulation of IFM and as an example, we use this formulation to specify the IFM method of Kwiat et al. We similarly define (nearly) interaction-free sensing (IFS), except that we impose an upper bound on the intensity to do the sensing (which again is an arbitrarily small multiplicative factor of the input intensity) whether or not the obstructing body is present. A quantum optical method for IFS (but not IFM) may be used to do I/O with bandwidth reduced by an arbitrarily small multiplicative factor of the bandwidth required for conventional optical or electronic I/O methods (i.e., without using quantum effects). We prove that there is no method for IFS with unitary transformations. Hence we conclude that I/O bandwidth can not be significantly reduced by such quantum methods for sensing. This is one of relatively few known proofs of the non-existence of a class of quantum devices (e.g., for instantaneous communication and EPR) and apparently the first for a quantum device relevant to computational I/O bandwidth. We use an interesting proof method, where we first show that no unitary transformation can do quantum amplification detection: that is, significantly increase the amplitude on detection of a small amplitude basis state. Then we show that the existence of a method for IFS implies a unitary quantum amplification detection method, which is impossible
Robust Threshold DSS Signatures

AbstractWe present threshold DSS (digital signature standard) signatures where the power to sign is shared by n players such that for a given parameter t<n/2 any subset of 2t+1 signers can collaborate to produce a valid DSS signature on any given message, but no subset of t corrupted players can forge a signature (in particular, cannot learn the signature key). In addition, we present a robust threshold DSS scheme that can also tolerate n/3 payers who refuse to participate in the signature protocol. We can also endure n/4 maliciously faulty players that generate incorrect partial signatures at the time of signature computation. This results in a highly secure and resilient DSS signature system applicable to the protection of the secret signature key, the prevention of forgery, and increased system availability. Assuming that secret communication between the players is available, we prove the security of our protocols solely based on the hardness of forging a regular DSS signature
Equivalence and Normal Forms for the Restricted and Bounded Fixpoint in the Nested Algebra

AbstractThe nested model is an extension of the traditional, “flat” relational model in which relations can also have relation-valued entries. Its “default” query language, the nested algebra, is rather weak, unfortunately, since it is only a conservative extension of the traditional, flat relational algebra, and thus can express only a small fraction of the polynomial-time queries. Therefore, it was proposed to extend the nested algebra with a fixpoint construct, but the resulting language turned out to be too powerful: many inherently exponential queries could also be expressed. Two polynomial-time restrictions of the fixpoint closure of the nested algebra were proposed: the restricted fixpoint closure (by Gyssens and Van Gucht) and the bounded fixpoint closure (by Suciu). Here, we prove two results. First we show that both restrictions are equivalent in expressive power. The proof technique relies on known encodings of nested relations into flat ones, and on a novel technique, called type substitution, by which we reduce the equivalence of the two restrictions to its obvious counterpart in the flat relational model. Second we prove that both the bounded fixpoint queries and the restricted fixpoint queries admit normal forms, in which the fixpoint occurs exactly once. The proof technique relies on a novel encoding method of nested relations into flat ones