Superposition and Chaining for Totally Ordered Divisible Abelian Groups

In the theory of abelian groups, the study of relations between an abelian group and its endomorphism group is an important problem. The question arises on conditions under which an abelian group and its endomorphism group are isomorphic ([1], Problem 31). The answer to this question has been obtained in the classes of completely decomposable abelian groups [2], vector groups [3], in the classes of periodic abelian groups, divisible abelian groups, nonreduced abelian groups, reduced algebraically compact abelian groups [4]. A group A is called an E+-group if it is isomorphic to its endomorphism group End(A). Clearly, if an abelian group A is an E+-group, then its endomorphism group End(A) is also an E+-group. In this paper, we show that the converse statement holds not always. A group A is called an End-group if the following implication takes place:

In the paper, necessary and sufficient conditions for an Abelian group A to be isomorphic to the endomorphism group End(A) are obtained. The classes of periodic Abelian groups, divisible Abelian groups, nonreduced Abelian groups, and reduced algebraically compact Abelian groups are considered. For certain classes of Abelian groups, the isomorphism problem for a group and its endomorphism group is solved under the assumption that the endomorphism group itself has the corresponding property.

The above question is considered, in the categories ShL of sheaves on a local lattice L and MEns of sets acted upon by a monoid M, for either all divisible abelian groups or all torsionfree divisible abelian groups, the aim being to characterize those L and M for which these types of abelian groups are Injective. Typical results: All divisible abelian groups are injective (i) in ShL iff L is Boolean, (ii) in MEns, M left or right cancellative, iff M is trivial, and (iii) in MEns, M commutative iff M is finite and idempotent.

This paper introduces a new technique for reasoning with quantifiers and theories. Traditionally, first-order theorem provers (ATPs) are well suited to reasoning with first-order problems containing many quantifiers and satisfiability modulo theories (SMT) solvers are well suited to reasoning with first-order problems in ground theories such as arithmetic. A recent development in first-order theorem proving has been the AVATAR architecture which uses a SAT solver to guide proof search based on a propositional abstraction of the first-order clause space. The approach turns a single proof search into a sequence of proof searches on (much) smaller sub-problems. This work extends the AVATAR approach to use a SMT solver in place of the SAT solver, with the effect that the first-order solver only needs to consider ground-theory-consistent sub-problems. The new architecture has been implemented using the Vampire theorem prover and Z3 SMT solver. Our experimental results, and the results of recent competitions, show that such a combination can be highly effective.

In this chapter, we discuss several special types of modules that will make frequent appearances later. These include semisimple modules, artinian modules, and torsionfree modules, which have prototypes in vector spaces, finite abelian groups, and torsionfree abelian groups, respectively. That special types of modules have useful roles in the study of arbitrary modules may be seen already in the case of abelian groups (i.e., ℤ-modules). In studying an arbitrary abelian group, an almost reflexive first step is to look at its torsion part (i.e., the torsion subgroup) and its torsionfree part (i.e., the factor group modulo the torsion subgroup), since entirely different techniques are available (and needed) for dealing with torsion groups and torsionfree groups. On the torsionfree side, vector spaces make an appearance due to the facts that the torsionfree divisible abelian groups are exactly the vector spaces over ℚ and that every torsionfree abelian group can be embedded in a divisible one. On the torsion side, many questions can be reduced to the case of finite abelian groups, since every torsion abelian group is a directed union of finite subgroups. In studying torsion abelian groups, one also reduces to the case of p -groups for various primes p . Vector spaces make another appearance here, since in an abelian p -group the set of elements of order p (together with 0) forms a vector space over ℤ/ p ℤ.

It is claimed in [45] that first-order theorem provers are not efficient for reasoning with ontologies based on description logics compared to specialised description logic reasoners. However, the development of more expressive ontology languages requires the use of theorem provers able to reason with full first-order logic and even its extensions. So far, theorem provers have extensively been used for running experiments over TPTP containing mainly problems with relatively small axiomatisations. A question arises whether such theorem provers can be used to reason in real time with large axiomatisations used in expressive ontologies such as SUMO. In this paper we answer this question affirmatively by showing that a carefully engineered theorem prover can answer queries to ontologies having over 15,000 first-order axioms with equality. Ontologies used in our experiments are based on the language KIF, whose expressive power goes far beyond the description logic based languages currently used in the Semantic Web.KeywordsTheorem ProverDescription LogicPredicate SymbolOntology LanguageQuery AnsweringThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Automated theorem provers for first-order logic usually operate on sets of first-order clauses. It is well-known that the translation of a formula in full first-order logic to a clausal normal form (CNF) can crucially affect performance of a theorem prover. In our recent work we introduced a modification of first-order logic extended by the first class boolean sort and syntactical constructs that mirror features of programming languages. We called this logic FOOL. Formulas in FOOL can be translated to ordinary first-order formulas and checked by first-order theorem provers. While this translation is straightforward, it does not result in a CNF that can be efficiently handled by state-of-the-art theorem provers which use superposition calculus. In this paper we present a new CNF translation algorithm for FOOL that is friendly and efficient for superposition-based first-order provers. We implemented the algorithm in the Vampire theorem prover and evaluated it on a large number of problems coming from formalisation of mathematics and program analysis. Our experimental results show an increase of performance of the prover with our CNF translation compared to the naive translation.

The Replacement Rule Theorem Prover (RRTP) is an instance-based, refutational, first-order clausal theorem prover. The prover is motivated by the idea of selectively replacing predicates by their definitions, and operates by selecting relevant instances of the input clauses. The relevant instances are grounded, if necessary, and tested for unsatisfiability by using a fast propositional calculus decision procedure.

Efficient proof techniques are vital for the success of formal verification of hardware. First-Order Logic theorem provers satisfy this requirement. This paper deals with experiences in applying such a tool, OTTER, to the verification of correctness of combinational logic. Several proof methodologies are here discussed: a rewrite rules and a resolution based approach are compared.

We introduce a heuristic for automatically checking the validity of first-order formulas of the form forallalpham existbetan middot Psi(alpham,betan) that are encountered in inductive proofs of hardware correctness. The heuristic introduced in this paper is used to automatically check the validity of k-step induction formulas needed to verify hardware designs. The heuristic works on word-level designs that can have data and address buses of arbitrary widths. Our refinement heuristic relies on the idea of predicate instantiation introduced in (H. Abu-Haimed et al., 2003). The heuristic proves quantified formulas by the use of a validity checker, CVC (A. Stump et al., 2002), and a first-order theorem prover, Otter (W.W. McCune, 1994). Our heuristic can be used as a stand-alone technique to verify word-level designs or as a component in an interactive theorem prover. We show the effectiveness of this heuristic for hardware verification by verifying a number of hardware designs completely automatically. The large size of the quantified formulas encountered in these examples shows the effectiveness of our heuristic as a component of a theorem prover

Encoding TLA+ into unsorted and many-sorted first-order logic

JProver is a first-order intuitionistic theorem prover that creates sequent-style proof objects and can serve as a proof engine in interactive proof assistants with expressive constructive logics. This paper gives a brief overview of JProver's proof technique, the generation of proof objects, and its integration into the Nuprl proof development system.

On the torsion rank of divisible multiplicative groups of fields

Satisfiability Modulo Theories (SMT) solvers are used in many modern program verification, analysis and testing tools. They owe their scale and efficiency thanks to advances in search algorithms underlying modern SAT solvers and first-order theorem provers. They owe their versatility in software development applications thanks to specialized algorithms supporting theories, such as numbers and algebraic data-types, of relevance for software engineering. This lecture introduces algorithmic principles of SMT solving, taking as basis modern SAT solvers and integration with specialized theory solvers and quantifier reasoning. We detail some of the algorithms used for main theories used in current SMT solvers and survey newer theories and approaches to integrating solvers. The lectures also outline some application scenarios where SMT solvers have found use, including program verification, network analysis, symbolic model checking, test-case generation, and white-box fuzzing.

The Schur multiplier of central product of groups