pinecone/core-2020-05-10-deduplication huggingface dataset:
Deriving Liveness Goals from Temporal Logic Specifications

AbstractA propositional temporal logic is briefly introduced and its use for reactive systems specification is motivated and illustrated. G-automata are proposed as a new operational semantics domain designed to cope with fairness/liveness properties. G-automata are a class of labelled transition systems with an additional structure of goal achievement which forces the eventual fulfilment of every pending goal. An algorithm is then presented, that takes a finite system specification as input and that, by a stepwise tableaux analysis method, builds up a canonical G-automaton matching the specification. Eventuality formulae correspond to goals of the automaton their satisfaction being thus assured. The direct execution of G-automata, and consequently of specifications, is then discussed and suggested as an alternative approach to the execution of propositional temporal logic. A short overview of the advantages of applying the techniques to the specific field of database monitoring is presented
Temporal Annotated Constraint Logic Programming

AbstractWe introduce a family of logics and associated programming languages for representing and reasoning about time. The family is conceptually simple while allowing for different models of time. Formulae can be labelled with temporal information using annotations. In this way we avoid the proliferation of variables and quantifiers as encountered in first order approaches. Unlike temporal logic, both qualitative and quantitative (metric) temporal reasoning about definite and indefinite information with time points (instants) and time periods (temporal intervals) in different models of time are supported. Our temporal annotated logic can be made an instance of annotated constraint logic, which is also presented in this paper. Given a logic in this framework, there is a systematic way to make a clausal fragment executable as a constraint logic program. We show this for the generic case and for the specific case of temporal annotated logic. In both cases we give an interpreter and a compiler that can be implemented in standard constraint logic programming languages
Dense Time Logic Programming

AbstractIn this paper, we describe a dense temporal logic programming (DTLP) framework based on infinite binary trees calledomega trees. We then look at an important subset of omega trees calledordinal treesthat represent only meaningful dense time models. Ordinal trees have the properties ofstabilityandrecurrence, which allow them to be represented finitely. The finite representations calledordinal structurescan be used as temporal data structures and its nodes can be labelled with formulae, giving us the basis for modeling temporally located information. In this paper, we label ordinal structure nodes with Prolog clauses to gettemporal horn clausesthat represent temporal facts, rules and queries. Temporal resolution tries to prove temporal queries from a set of temporal facts and rules using a process calledaligningwhich provides the counterpart of the conventional unification algorithm. Aligning restructures ordinal trees to facilitate the transfer of temporal information between them. We present theoretical results to show that aligning is computable, and that the procedures for aligning and resolution are correct
Temporal Semantics for Concurrent METATEM

AbstractConcurrentMetateMis a programming language based on the notion of concurrent, communicating objects, where each object directly executes a specification given in temporal logic, and communicates with other objects using asynchronous broadcast message-passing. Thus, ConcurrentMetateMrepresents a combination of the direct execution of temporal specifications, together with a novel model of concurrent computation. In contrast to the notions of predicates as processes and stream parallelism seen in concurrent logic languages, ConcurrentMetateMrepresents a more coarse-grained approach, where an object consists of a set of logical rules and communication is achieved by the evaluation of certain types of predicate. Representing concurrent systems as groups of such objects provides a powerful tool for modelling complex reactive systems. In order to reason about the behaviour of ConcurrentMetateMsystems, we requir a suitable semantics. Being based upon executable temporal logic, objects in isolation have an intuitive semantics. However, the addition of both operational constraints upon the object's execution and global constraints provided by the asynchronous model of concurrency and communication, complicates the overall semantics of networks of objects. It is this, more complex, semantics that we address here, where temporal semantics for varieties of ConcurrentMetateMare provided
A Non-standard Temporal Deductive Database System

AbstractA new temporal deductive database system supporting a non-standard model of time is introduced. It consists of Non-standard Temporal DATALOG(NSTL) and Non-standard Temporal Relational Algebra (NSTRA). The time line consists of non-standard reals that are of the form 〈r, z〉, wherer∈ R andz∈ Z using the natural order. Each realrdetermines a macro-instant, and each pair 〈r, z〉 defines a micro-instant. The set of macro-instants forms a dense order, thereby allowing different relations to be valid at different moments, with independent rates of evolution. The micro-instants ensure that all intervals are closed, thereby simplifying the semantics.At the same time, it becomes possible to define a discrete memory operator. TheNSTLlanguage is an extension of DATALOGin which the fact base is augmented with interval time-stamps and in which rules are an extension of generalized Horn clauses that allow a memory operator ”;“ and allow time-stamped atoms in the body. TheNSTRAlanguage is a pointwise extension of the relational algebra over the time line. To do this, three temporal operators are added to the relational algebra
NatureTime: Temporal Granularity in Simulation of Ecosystems

AbstractGranularity of time is an important issue for the understanding of how actions performed at coarse levels of time interact with others, working at finer levels. However, it has not received much attention from most AI work on temporal logic. In simpler domains of application we may not need to consider it a problem but it becomes important in more complex domains, such as ecological modelling. In this domain, aggregation of processes working at different time granularities (and sometimes cyclically) is very difficult to achieve reliably. We have proposed a new time granularity theory based onmodular temporal classes, and have developed a temporal reasoning system to specify cyclical processes of simulation models in ecology at many levels of time
Dealing with Multiple Granularity of Time in Temporal Logic Programming

AbstractChronolog(MC) is an extension of logic programming based on a linear-time temporal logic with multiple granularity of time calledTLC. A Chronolog(MC) program consists of a clock definition, a clock assignment and a program body. Each predicate symbol appearing in the program body is associated with a local clock through the clock definition and assignment. This paper investigates the logical basis of the language, presents a clocked temporal resolution where time-matching is essential, and in particular proposes three algorithms for time-matching. The paper also discusses the declarative semantics of Chronolog(MC) programs in terms of clocked temporal Herbrand models. It is shown that Chronolog(MC) programs also satisfy the minimum model semantics. The language can be used to model a wide range of simulation systems and other relevant tasks where the notion of dynamic change is central
Paramodulation with Built-in AC-Theories and Symbolic Constraints

AbstractComplete paramodulation strategies are developed for clauses with symbolic constraints and built-in associativity and commutativity (AC) properties for a subset of the function symbols. Apart from the reduced search space due to the inherited ordering and unification restrictions of the inferences (cf. Nieuwenhuis and Rubio, 1995), symbolic constraints turn out to be especially useful in the context of built-in equational theoriesE. In every inference, instead of producing as many conclusions as minimalE-unifiers of two termssandt, one single conclusion is generated with an additionalE-unification problems=tkept in its constraint. In the AC-case developed here (the most extensively studied built-in theory), the computation of the (doubly exponentially many) AC-unifiers can thus be completely avoided. These results are also applied here to more efficient strategies (sometimes decision procedures) in theories expressed by finitesaturatedsets of clauses and, in particular, to rewriting and Knuth–Bendix completion modulo AC
Oriented Equational Logic Programming is Complete

AbstractWe show the completeness of an extension of SLD-resolution to the equational setting. This proves a conjecture of Laurent Fribourg and shows the completeness of an implementation of his. It is the first completeness result for superposition of equational Horn clauses which reduces to SLD resolution in the non-equational case. The inference system proved complete is actually more general than the one of Fribourg, because it allows for a selection rule on program clauses. Our completeness result also has implications for Conditional Narrowing and Basic Conditional Narrowing
Automated Theorem Proving by Test Set Induction

AbstractTest set induction is a goal-directed proof technique which combines the full power of explicit induction and proof by consistency. It works by computing an appropriate explicit induction scheme calleda test set, to trigger the induction proof, and then applies a refutation principle using proof by consistency techniques. We present a general scheme for test set induction together with a simple soundness proof. Our method is based on new notions of test sets,induction variables, andprovable inconsistency, which allow us to refute false conjectures even in the case where the functions are not completely defined. We show how test sets can be computed when the constructors are not free, and give an algorithm for computing induction variables. Finally, we present a procedure for proof by test set induction which is refutationally complete for a larger class of specifications than has been shown in previous work. The method has been implemented in the proverSPIKE. Based on computer experiments dealing with mutual induction,SPIKEappears to be more practical and efficient than explicit induction based systems
Solving a Unification Problem under Constrained Substitutions Using Tree Automata

AbstractA unification problem under constrained substitutions, a generalization of the usual unification problems, is a useful formalization of a practical problem in which there are some constraints on operations and objects that we can use. In this paper, a procedure to solve the problem under some linearity conditions is introduced. Since the problem is undecidable in general, the procedure falls into an infinite loop for some instances. We clarify a decidable sufficient condition under which our procedure terminates, and review known classes of term rewriting systems that satisfy the condition. The procedure uses tree automata to solve the problem, which is quite a new and promising approach to unification problems
Implicitizing Rational Curves by the Method of Moving Algebraic Curves

AbstractA functionF(x,y,t)that assigns to each parametertan algebraic curveF(x,y,t)=0is called a moving curve. A moving curveF(x,y,t)is said to follow a rational curvex=x(t)/w(t),y=y(t)/w(t)ifF(x(t)/w(t), y(t)/w(t),t)is identically zero. A new technique for finding the implicit equation of a rational curve based on the notion of moving conics that follow the curve is investigated. For rational curves of degree 2nwith no base points the method of moving conics generates the implicit equation as the determinant of ann×nmatrix, where each entry is a quadratic polynomial inxandy, whereas standard resultant methods generate the implicit equation as the determinant of a 2n× 2nmatrix where each entry is a linear polynomial inxandy. Thus implicitization using moving conics yields more compact representations for the implicit equation than standard resultant techniques, and these compressed expressions may lead to faster evaluation algorithms. Moreover whereas resultants fail in the presence of base points, the method of moving conics actually simplifies, because when base points are present some of the moving conics reduce to moving lines
Parametrization of Algebraic Curves over Optimal Field Extensions

AbstractIn this paper we investigate the problem of determining rational parametrizations of plane algebraic curves over an algebraic extension of least degree over the field of definition. This problem reduces to the problem of finding simple points with coordinates in the field of definition on algebraic curves of genus 0. Consequently we are also able to decide parametrizability over the reals. We generalize a classical theorem of Hilbert and Hurwitz about birational transformations. An efficient algorithm for computing such optimal parametrizations is presented
Rational Parametrizations of Algebraic Curves using a Canonical Divisor

AbstractFor an algebraic curveCwith genus 0 the vector spaceL(D) whereDis a divisor of degree 2 gives rise to a bijective morphismgfromCto a conicC2in the projective plane. We present an algorithm that uses an integral basis for computingL(D) for a suitably chosenD. The advantage of an integral basis is that it contains all the necessary information about the singularities, so once the integral basis is known theL(D) algorithm does not need work with the singularities anymore. If the degree ofCis odd, or more generally, if any odd degree rational divisor onCis known then we show how to construct a rational point onC2. In such cases a rational parametrization, which means defined without algebraic extensions, ofC2can be obtained. In the remaining cases a parametrization ofC2defined over a quadratic algebraic extension can be computed. A parametrization ofCis obtained by composing the parametrization ofC2with the inverse of the morphismg
Real Reparametrizations of Real Curves

AbstractIn this paper we study the following two problems: first, given a rational parametrizationP(z)=(p1(z),p2(z))∋ʗ(z)2of a complex curve ʗ in ʗ2, to determine algorithmically, if ʗ has an infinite number of real points (i.e. if the trace of ʗ in R2is a real curve). If this is the case, then we would like to find another parametrization mapping of the same curve, but this time with real rational functions. The solution to both problems is given here by a simple algorithm, requiring essentially just a gcd computation and a parametrization of a real line or circle. On the other hand, the theoretical foundation for the algorithm seems more involved, relying on factorization properties of conjugate harmonic polynomials. The case of space curves or curves over a higher dimensional space follows by a direct generalization of our results or by considering the primitive element theorem
Parametric Generalized Offsets to Hypersurfaces

AbstractIn this paper we extend the classical notion of offset to the concept of generalized offset to hypersurfaces. In addition, we present a complete theoretical analysis of the rationality and unirationality of generalized offsets. Characterizations for deciding whether the generalized offset to a hypersurface is parametric or it has two parametric components are given. As an application, an algorithm to analyse the rationality of the components of the generalized offset to a plane curve or to a surface, and to compute rational parametrizations of its rational components, is outlined
Conic Approximation of Conic Offsets

AbstractA scheme for error-boundedG1conic approximation of offsets to conic Bézier segments is presented. The initial step involves segmentation of the conic at points inducing cusps on the offset, ensuring that each subsegment has a smooth offset amenable to conic approximation. The approximation scheme is based on interpolating the end points and tangents, and parametric midpoint, of the exact offset. Conditions for the existence of real interpolants to such data are derived, and a sufficient condition for unambiguous definition of a distance function between the conic and its approximate offset is identified in terms of the control polygon. It is shown that extrema of this function occur along common normal lines to the conic and approximate offset, a condition satisfied at the real roots on (0,1) of a degree 10 polynomial in the conic parameter. These roots may be isolated and approximated using the Bernstein form, yielding a sharp geometric bound on the approximation error. Under subdivision the scheme produces rapidly converging approximations, satisfying any desired accuracy, for precision engineering applications
Spline Approximations of Real Algebraic Surfaces

AbstractWe use a combination of both symbolic and numerical techniques to construct several degree boundedG0andG1continuous, piecewise spline approximations of real implicit algebraic surfaces for both computer graphics and geometric modeling. These approximations are based upon an adaptive triangulation (aG0planar approximation) of the real components of the algebraic surface, and include both singular points and singular curves on the surface. A curvilinear wireframe is also constructed using minimum bending energy, parametric curves with additionally normals varying along them. The spline approximations over the triangulation or curvilinear wireframe could be one of several forms: either low degree, implicit algebraic splines (triangular A-patches) or multivariate functional B-splines (B-patches) or standardized rational Bernstein–Bézier patches (RBB), or triangular rational B-Splines. The adaptive triangulation is additionally useful for a rapid display and animation of the implicit surface
Some Algorithms for Nilpotent Permutation Groups

AbstractLetG,HandEbe subgroups of a finite nilpotent permutation group of degreen. We describe the theory and implementation of an algorithm to compute the normalizerNG(H) in time polynomial inn, and we give a modified algorithm to determine whetherHandEare conjugate underGand, if so, to find a conjugating element ofG. Other algorithms produce the intersectionG∩Hand the centralizerCG(H). The underlying method uses the imprimitivity structure of 〈G,H〉 and an associated canonical chief series to reduce computation to linear operations. Implementations in GAP and Magma are practical for degrees large enough to present difficulties for general-purpose methods
Interactive Theorem Proving with Temporal Logic

AbstractIn this paper, we present a theorem prover for linear temporal logic. Our goal is to extend the capabilities of existing interactive and automatic systems for verifying temporal properties of software and hardware systems. We focus on increasing the effectiveness of user interaction in such systems. In particular, we extend the techniques ofproof by pointingandpoint and shootfor mouse-driven proof construction in first-order logic to temporal logic. In addition, we show how to generate text from proofs by extending a previously given translation for first-order logic to the temporal operators. Our theorem prover implements an inference system for temporal logic that we have defined. The inference rules of this system are more intuitive than the rules commonly given for temporal logics and thus they are better suited to our goals. We present this inference system and prove that it is sound and complete with respect to a known system
Two Perturbation Calculations in Fluid Mechanics using Large-expression Management

AbstractTwo fluid-flow problems are solved using perturbation expansions, with special emphasis on the reduction of intermediate expression swell. This is done by developing tools in Maple that contribute to the efficient representation and manipulation of large expressions. The tools share a common basis, which is the creation of a hierarchy of representation levels such that expressions located at higher levels are expressed using entries from lower levels. The evaluation of higher-level expressions by the algebra system does not proceed recursively to the lowest level, as would ordinarily be the case, but instead can be directly controlled by the user.The first fluid-flow problem, arising in lubrication theory, is solved by implementing a technique of switch-controlled evaluation. The processes of simplification and evaluation are controlled at each level by user-manipulated switches. A perturbation solution is derived semi-interactively with the switch-controlled evaluation being used to reduce the size of intermediate expressions. The second fluid problem, in convection, is solved by extending a perturbation series in several variables to high order by implementing techniques for the automatic generation of hierarchical expression sequences
Visualizations for Mathematics Courses Based on a Computer Algebra System

AbstractThis paper discusses the introduction of a computer-algebra system to perform visualizations in mathematics education.With theIllustrated Mathematicsproject, we provide a comprehensive collection of graphics and animations for various topics in mathematics, which can directly be used for teaching. Because the programs (written inMathematica) we used for the creation of this collection are included, it is easy to design new examples by modifying parameters in existing examples. Therefore,Illustrated Mathematicscan be used as a first step of the introduction of a computer-algebra system in mathematics education.In the second part, we report on the development of a workbench and learning environment, with which the students can discover the mathematical concepts by themselves. For that, the given examples have to be didactically enriched and processed. By creating their own visualizations of increasing complexity, the students improve their knowledge about the underlying computer-algebra system
Using the Magma Computer Algebra System in Abstract Algebra Courses

AbstractStudents meeting their first serious course in abstract algebra commonly experience difficulty understanding many of the basic concepts. This makes it very hard for them to interpret and generate proofs. The first step in reaching an understanding of such concepts is often best achieved by constructing and manipulating instances in particular algebraic structures. Computer algebra systems open up the possibility of students being able to experiment rapidly and conveniently with such concepts in a variety of structures having non-trivial size and complexity. The new Magma computer algebra system has a syntax and semantics based directly on fundamental algebraic notions, and consequently should provide an appropriate learning environment for those branches of mathematics that are heavily algebraic in nature. This paper describes the development of Magma-based exercises and a course methodology that utilizes Magma as a key learning tool in a Pass-level Rings and Fields course given at the University of Sydney
Applications of the Differential Algebra Packagediffgrob2to Classical Symmetries of Differential Equations

AbstractWe show how the MAPLE packagediffgrob2can be used to analyse overdetermined systems of PDE. The particular application discussed here is to find classical symmetries of differential equations of mathematical and physical interest. Symmetries of differential equations underly most of the methods of exact integration known; the use and calculation of such symmetries is often introduced at advanced undergraduate level. Examples include cases where heuristics give incomplete information or fail in the integration of the determining equations for the group infinitesimals. The ideas presented here are thus an alternative method of attacking this important problem. The discussion is at a “hands on” level suitable as resource material for undergraduate instruction