pinecone/core-2020-05-10-deduplication huggingface dataset:
Recording and Analysing Knowledge-Based Distributed Deduction Processes

AbstractDistributed models for deduction allow for more powerful proof systems, but also lead to new problems. In particular, the analysis of the deduction process becomes harder, as a number of largely independent agents may contribute to the proof. In a system including cooperating agents, timing considerations can lead to further problems. In this paper we first introduce the TEAMWORK method and the DISCOUNT system for distributed equational reasoning. We point out the difficulties in obtaining a detailed representation of the proofs generated by a distributed system with completely distributed memory and present our solution for the TEAMWORK approach. Using this solution we are able to explain some of the speed-ups DISCOUNT was able to obtain in distributed mode. We also show how the representation of an equational proof as a listing of inferences can be transformed into a proof easily readable by human beings. Finally, pruned proof protocols (containing only facts contributing to the proof) also enable us to develop new, adaptive strategies for the proof search
PSATO: a Distributed Propositional Prover and its Application to Quasigroup Problems

AbstractWe present a distributed/parallel prover for propositional satisfiability (SAT), called PSATO, for networks of workstations. PSATO is based on the sequential SAT prover SATO, which is an efficient implementation of the Davis –Putnam algorithm. The master–slave model is used for communication. A simple and effective workload balancing method distributes the workload among workstations. A key property of our method is that the concurrent processes explore disjoint portions of the search space. In this way, we use parallelism without introducing redundant search. Our approach provides solutions to the problems of (i) cumulating intermediate results of separate runs of reasoning programs; (ii) designing highly scalable parallel algorithms and (iii) supporting “fault-tolerant” distributed computing. Several dozens of open problems in the study of quasigroups have been solved using PSATO. We also show how a useful technique called the cyclic group construction has been coded in propositional logic
Parallelizing Imperative Functional Programs: the Vectorization Monad

AbstractTraditionally a vectorizing compiler matches the iterative constructs of a program against a set of predefined templates. If a loop contains no dependency cycles then amaptemplate can be used; other simple dependencies can often be expressed in terms offoldorscantemplates. This paper addresses the template matching problem within the context of functional programming. A small collection of program identities are used to specify vectorizable for-loops. By incorporating these program identities within a monad,allwell-typed for-loops in which the body of the loop is expressed using thevectorization monadcan be vectorized. This technique enables the elimination of template matching from a vectorizing compiler, and the proof of the safety of vectorization can be performed by a type inference mechanism
Shared Memory Implementation of the Gamma-Operation

AbstractThe Gamma scheme allows the specification of an application without introducing unnecessary sequentiality. The main idea is to simulate a chemical reaction on multisets, also called bags. Some elements of a bag which fulfil a certain predicate (also called reaction condition) may be taken from the multiset and replaced by new elements which are generated by combining the selected elements using the so-called reaction function. In the present paper, we investigate the efficient parallel implementation of the Gamma scheme. In particular, the reaction condition can be split into parts which are tested as early as possible. Possible atomic conditions are arithmetic comparisons. We use the properties of the arithmetic comparisons in order to restrict the range of bag elements which has to be considered. Reconsiderations of the same bag elements are avoided. Moreover, a sophisticated protocol is needed in order to avoid deadlocks when several processes compete for the same bag elements. Experimental results show the impact of our improvements
A Semi-Automatic Multiple-Strategy Approach To Mapping Tree-Structured Symbolic Processing Programs

AbstractSymbolic applications such as expert systems, theorem provers, and computer algebra exhibit dynamic, tree-structured behavior with respect to control and data structures. This is why it is difficult to parallelize a program and get it running efficiently on a parallel computer, especially one with distributed memory. This paper introduces a semi-automatic mapping environment providing a set of support tools, intended for application to large, real-life programs. Mapping can perform adaptive granularity control, dynamic load balancing, and scheduling on parallel programs with dynamic data and control behavior, providing a set of strategies for all components. A set of mapping rules are extracted, describing when which strategy is appropriate. The approach systematically selects and configures its strategies to suit the characteristics of the application and is thus superior to a universal heuristic
The Constraint-Based Knowledge Broker Model: Semantics, Implementation and Analysis

AbstractImagine distributed knowledge processing with autonomous activities and decentralized control where the handling of partial knowledge does not result in unclear semantics or failure-prone behavior. In this paper, a modular approach is taken where concurrent agents, calledconstraint-based knowledge brokers(CBKBs), process and generate new knowledge in the presence of partial information. CBKBs apply constraint solving techniques to the domain of information gathering in distributed environments. Constraints are exploited to allow partial specification of the requested information, and to relate information requests from multiple sources. We present a mathematical model where the semantics of the knowledge system is described using a standard fixed-point procedure. A basic execution model is then provided. This is incrementally refined to tackle problems of inter-argument dependencies (that arise with constraints relating information requests from different sources), of knowledge reuse inside the knowledge generators, and of recursion control. The model refinements are illustrated by a detailed complexity analysis in terms of the number of agents needed and of the number of messages sent, distinguished by requests and answers of the involved broker agents. A detailed example shows a broker-based chart-parser for unification grammars with feature terms implemented using CBKBs. As we shall point out, this apparently abstract example can be easily generalized to full-fledged information gathering
Extending the μLog Framework with Local and Conditional Blackboard Operations

AbstractThis paper discusses two extensions of the kernel μLog framework presented by Jacquet and De Bosschere (1994): local blackboards and conditional access primitives. The former are needed to alleviate the blackboard communication bottleneck and to solve message naming conflicts whereas the latter improve the message selection power of pattern matching or unification. We propose a syntax for both extensions, give their operational semantics, provide a declarative semantics and prove the soundness and completeness properties in our setting. Moreover,we discuss a specialization of this framework using Prolog astarget language. An implementation is presented and the applicability of the proposed framework and language is argued through the coding of a reactive system
Constraint Satisfaction in Distributed Concurrent Logic Programming

AbstractIn constraint logic programming, unification is replaced by more general constraint satisfaction. To support constraint solving in a committed-choice concurrent logic programming language, the constraint solver also needs to determine the status of the ‘ask’-constraints with respect to the current constraint store. In a distributed system, in which ‘ask’- and ‘tell’-constraints are generated incrementally and concurrently on different nodes,the constraint solver needs to face a distributed constraint store. When some constraints are ‘local’ to a node, it is most desirable that they are solved ‘locally’ In this paper we first describe a prototype distributed concurrent constraint logic programming languageD/C-Parlogwhich allows incremental and concurrent generation of constraints on different nodes in a distributed system. Then we describe, in the framework ofD/C-Parlog, algorithms for distributed constraint satisfaction problems in the domains of Real numbers and Boolean rings. When the number of nodes reduces to one, these algorithms degenerate to existing centralised constraint satisfaction algorithms such as those used in CLP (R) and CHIP. The algorithm supports both ‘ask’-constraints that appear in the guard and ‘tell’-constraints in the body. Some implementation issues are discussed
The Ideal Membership Problem in Non-Commutative Polynomial Rings

AbstractLetXbe a non-commutative monoid with term order; letRbe a commutative, unital ring; letIbe an ideal in the non-commutative polynomial ringR〈X〉 and let ƒ ∈R〈X〉. In this setting the problem of determining whether ƒ ∈Iis studied. In a manner analogous to the commutative case, see Möller (1989), weak Gröbner bases are defined and their basic properties are studied. We will see that in the non-commutative setting, when the coefficient ring is not a field, and when we enlarge the polynomial ring by adding more variables, weak Gröbner bases may exhibit unpleasant behavior that has no analog in the commutative case. Quite in general for ƒ ∈R〈X〉, it is undecidable whether ƒ ∈I. This follows from the fact that the word problem for free semigroups is undecidable. IfIis generated by a recursively enumerable set, then we give a semi-decision procedure that halts if and only if ƒ∈I. Finally we examine a class of nicely behaved ideals for which weak Gröbner bases can be easly computed
AC Complement Problems: Satisfiability and Negation Elimination

AbstractIn general, functional programs are assumed to be non-ambiguous. A simple way to handle ambiguous definitions is to replace them by non-ambiguous ones containing complement problems, which in turn have to be transformed into explicit expressions. Finding an explicit formulation for a complement problem is the same as eliminating negation from the corresponding equational formula. This problem was already shown decidable for complement problems interpreted inT(F), and inT(F)/=EwhenEis a permutative theory of Mal'cev. Here, we show that negation elimination is also decidable for linear complement problems interpreted inT(F)/=AC, whereACis a set of associative and commutative axioms. We present a system of rules that transforms any linear complement problem into simple formulae, and we give a decision test for simple formulae which serves as a basis for the development of a negation elimination algorithm. In the case of non-linearAC-complement problems even satisfiability is an open problem, but we will show, using the previous results, that satisfiability is decidable for a particular class of non-linear problems: when variables do not occur directly belowAC-function symbols. Finally, we generalize the negation elimination results to a wider class of equational formulae moduloAC
Applying Quantifier Elimination to the Birkhoff Interpolation Problem

AbstractThis paper is devoted to show how to use Computer Algebra and Quantifier Elimination to solve some particular instances of the Birkhoff Interpolation Problem. In particular, this problem is completely solved for degrees less than or equal to 3 and any number of nodes and several instances of degree 4 and 5 by computing all the incidence normal poised matrices with such characteristics. The used Computer Algebra and Quantifier Elimination includes manipulation of multivariate polynomials, computation of determinants of matrices with polynomial entries and the formal manipulation of univariate polynomial inequalities by using Sturm—Habicht sequences and the Sign Determination Scheme
Symbolic Finite Element Modeling of Structural Systems

AbstractThe application of light materials to space structures, aircraft, robots and automobiles has increased the demand for effective algorithms to model and predict the response of structural multibody systems. The understanding of mechanics can assist in developing better design and control strategies. Formulation of mathematical models of a multibody system using manual approaches is a difficult task and prone to errors. For non-linear and/or time-varying systems, numerical formulation provides limited information about physical insight. In this study, a computer-aided symbolic method is used to generate the equations of motion from Lagrange's method. Equations are converted into FORTRAN form ready for simulations and control synthesis. The 4–5th order Runge–Kutta–Fehlberg method (RKF45) was used to numerically solve the system of equations. Two examples, namely a slider–crank mechanism and an aircraft model are presented
On Different Structure-preserving Translations to Normal Form

AbstractIn this paper, we compare different definitional transformations into normal form with respect to the Herbrand complexity of the resulting normal forms. Usually, such definitional transformations introduce labels defining subformulae. An obvious optimization is to use implications instead of equivalences, if the subformula occurs in one polarity only, in order to reduce the length of the resulting normal form. We identify a sequence of formulaeH1,H2,..., for which the difference of the Herbrand complexity of the different translations ofHκ is bounded from below by a non-elementary function in κ. If the optimized translation is applied instead of the unoptimized one, the length of any resolution or cut-free LK-proof ofHκ is non-elementary in κ instead of exponential in κ
On the Modularity of Normal Forms in Rewriting

AbstractThe last open problem regarding the modularity of the fundamental properties of Term Rewriting Systems concerns the property of uniqueness of normal forms w.r.t. reduction (UN→). In this article we solve this open problem, showing that UN→is modular for left-linear Term Rewriting Systems. The novel “pile and delete” technique here introduced allows for quite a short proof, and is of independent interest in the study of modular properties. Moreover, we also study the modularity of consistency w.r.t. reduction (CON→), showing its modularity for left-linear Term Rewriting Systems
For Groups the Property of Having Finite Derivation Type is equivalent to the Homological Finiteness ConditionFP3

AbstractThe homological finiteness propertyFP3and the combinatorial property of having finite derivation type are both necessary conditions for finitely presented monoids to admit finite convergent presentations. For monoids in general, the property of having finite derivation type implies the propertyFP3, and there even exist finitely presented monoids that areFP3, but that do not have finite derivation type (Cremanns and Otto, 1994). Here, contrasting this result, we show that for groups these two properties are equivalent. The proof is based on the result that a groupG, which is given through a finite presentation 〈X; R〉 has finite derivation type if and only if the ZG-module of identities among relations that is associated with 〈X; R〉 is finitely generated. This result, which was announced in (Cremanns and Otto, 1994), is proved in a conceptually simple manner, greatly improving upon the original proof that was only outlined in (Cremanns and Otto, 1994). Then, using elementary algebraic arguments we derive our main result without using much of homology theory, thus making the proof easily accessible to computer scientists and mathematicians with some background in algebra and rewriting theory
Note on Kovacic's Algorithm

AbstractAlgorithms exist to find Liouvillian solutions of second order homogeneous linear differential equations (Kovacic, 1986, Singer and Ulmer, 1993b). In this paper, we show how, by carefully combining the techniques of those algorithms, one can find the Liouvillian solutions of an irreducible second order linear differential equation by computing only rational solutions of some associated linear differential equations. The result is an easy-to-implement simplified version of the Kovacic algorithim, based as much on the computation of rational solutions of linear differential equations
Decomposition of Algebraic Functions

AbstractFunctional decomposition—whether a functionf(x) can be written as a composition of functionsg(h(x)) in a non-trivial way—is an important primitive in symbolic computation systems. The problem of univariate polynomial decomposition was shown to have an efficient solution by Kozen and Landau (1989). Dickerson (1987) and Gathen (1990a) gave algorithms for certain multivariate cases. Zippel (1991) showed how to decompose rational functions. In this paper, we address the issue of decomposition of algebraic functions. We show that the problem is related to univariate resultants in algebraic function fields, and in fact can be reformulated as a problem ofresultant decomposition. We characterize all decompositions of a given algebraic function up to isomorphism, and give an exponential time algorithm for finding a non-trivial one if it exists. The algorithm involves genus calculations and constructing transcendental generators of fields of genus zero
Symbolic Computation on Complex Polynomial Solution of Differential Equations

AbstractA symbolic computation scheme, based on the Lanczos τ-method, is proposed for obtaining exact polynomial solutions to some perturbed differential equations with suitable boundary conditions. The automated τ-method uses symbolic Faber polynomials as the perturbation terms for arbitrary circular sections of the complex plane and has advantages of avoiding rounding error and easy manipulation over the numerical counterpart. The method is illustrated by applying it to the modified Bessel function of the first kindI0(z) and the quality of the approximation is discussed
Hilbert Functions and the Buchberger Algorithm

AbstractIn this paper we show how to use the knowledge of the Hilbert–Poincaré series of an idealIto speed up the Buchberger algorithm for the computation of a Gröbner basis. The algorithm is useful in the change of ordering and in the validation of modular computations, also with tangent cone orderings; speeds the direct computation of a Gröbner basis if the ideal is a complete intersection, e.g. in the computation of cartesian from parametric equations, can validate or disprove a conjecture that an ideal is a complete intersection, and is marginally useful also when the conjecture is false. A large set of experiments is reported
Modular Higher-Order Equational Preunification

AbstractPreunification of simply typed λ-terms with respect to the equivalence relation induced by α-, β- and η-conversion and an arbitrary first-order equational theory is useful in higher-order proof and logic programming systems. In this paper we present a procedure for such preunification, which is based on three transformations and parameterized by a first-order equational unification procedure that admits free function symbols. The procedure is proved to be sound and complete, provided that the parameterizing procedure is
On the Resolution of Index Form Equations in Sextic Fields with an Imaginary Quadratic Subfield

AbstractWe give an efficient algorithm for the resolution of index form equations, especially for determining power integral bases, in sextic fields with an imaginary quadratic subfield. The method reduces the problem to the resolution of acubic relative Thue equationover the quadratic subfield. At the end of the paper we give a table containing the generators of all power integral bases in the first 25 fields of this type with smallest discriminant (in absolute value).1991 Mathematics Subject Classification:primary 11Y50, secondary 11Y40, 11D5
Symbolic Solutions for a Class of Partial Differential Equations

AbstractAn algorithm to generate solutions for members of a class of completely integrable partial differential equations has been derived from a constructive proof of Frobenius' Theorem. The algorithm is implemented as a procedure in the computer algebra system Maple. Because the implementation uses the facilities of Maple for solving sets of ordinary differential equations and for sets of nonlinear equations, and these facilities are limited, the problems that actually can be solved are restricted in size and complexity. Several examples, some derived from industrial practice, are presented to illustrate the use of the algorithm and to demonstrate the advantages and shortcomings of the implementation
Timed Default Concurrent Constraint Programming

AbstractSynchronous programming (Berry, 1989) is a powerful approach to programming reactive systems. Following the idea that “processes are relations extended over time” (Abramsky, 1993), we propose a simple but powerful model for timed, determinate computation, extending the closure-operator model for untimed concurrent constraint programming (CCP). In Saraswatet al. (1994a) we had proposed a model for this called tcc—here we extend the model of tcc to express strong time-outs: if an eventAdoes not happen through timet, cause eventBto happen at timet. Such constructs arise naturally in practice (e.g. in modeling transistors) and are supported in synchronous programming languages. The fundamental conceptual difficulty posed by these operations is that they are non-monotonic. We provide compositional semantics to the non-monotonic version of concurrent constraint programming (Default cc) obtained by changing the underlying logic from intuitionistic logic to Reiter's default logic. This allows us to use the same construction (uniform extension through time) to develop Default cc as we had used to develop tcc from cc. Indeed the smooth embedding of cc processes into Default cc processes lifts to a smooth embedding of tcc processes into Default cc processes. We identify a basic set of combinators (that constitute the Default cc programming framework), and provide constructive operational semantics (implemented by us as an interpreter) for which the model is fully abstract. We show that the model is expressive by defining combinators from the synchronous languages. We show that Default cc is compositional and supports the properties of multiform time, orthogonal pre-emption and executable specifications. In addition, Default cc programs can be read as logical formulae (in an intuitionistic temporal logic)—we show that this logic is sound and complete for reasoning about (in)equivalence of Default cc programs. Like the synchronous languages, Default cc programs can be compiled into finite state automata. In addition, the translation can be specified compositionally. This enables separate compilation of Default cc programs and run-time tradeoffs between partial compilation and interpretation. A preliminary version of this paper was published as Saraswatet al. (1995). Here we present a complete treatment of hiding, along with a detailed treatment of the model