Abstract 1 Introduction 2 Preliminaries 3 Outline of the quantifier elimination procedure 4 Efficient bounded quantifier elimination in PrA[t] 5 Elimination of polynomially bounded quantifiers 6 Solving satisfiability, universality and finiteness References

One-Parametric Presburger Arithmetic
Has Quantifier Elimination

Alessio Mansutti ORCID IMDEA Software Institute, Madrid, Spain Mikhail R. Starchak ORCID St. Petersburg State University, Russia
Abstract

We give a quantifier elimination procedure for one-parametric Presburger arithmetic, the extension of Presburger arithmetic with the function xtx, where t is a fixed free variable ranging over the integers. This resolves an open problem proposed in [Bogart et al., Discrete Analysis, 2017]. As conjectured in [Goodrick, Arch. Math. Logic, 2018], quantifier elimination is obtained for the extended structure featuring all integer division functions xxf(t), one for each integer polynomial f.

Our algorithm works by iteratively eliminating blocks of existential quantifiers. The elimination of a block builds on two sub-procedures, both running in non-deterministic polynomial time. The first one is an adaptation of a recently developed and efficient quantifier elimination procedure for Presburger arithmetic, modified to handle formulae with coefficients over the ring [t] of univariate polynomials. The second is reminiscent of the so-called “base t division method” used by Bogart et al. As a result, we deduce that the satisfiability problem for the existential fragment of one-parametric Presburger arithmetic (which encompasses a broad class of non-linear integer programs) is in NP, and that the smallest solution to a satisfiable formula in this fragment is of polynomial bit size.

Keywords and phrases:
decision procedures, quantifier elimination, non-linear integer arithmetic
Funding:
Alessio Mansutti: Funded by the Madrid Regional Government (César Nombela grant 2023-T1/COM-29001), and by MCIN/AEI (grant PID2022-138072OB-I00).
Mikhail R. Starchak: Supported by the Russian Science Foundation, project 23-71-01041.
Copyright and License:
[Uncaptioned image] © Alessio Mansutti and Mikhail R. Starchak; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Computing methodologies Symbolic and algebraic algorithms
; Theory of computation Logic
Related Version:
Full Version: https://doi.org/10.48550/arXiv.2506.23730
Editors:
Paweł Gawrychowski, Filip Mazowiecki, and Michał Skrzypczak

1 Introduction

The first-order theory of the integers  with addition and order, which is also known as Presburger arithmetic (PrA) or linear integer arithmetic, has been intensively studied during almost a century [26]. It is a textbook fact that Presburger arithmetic admits quantifier elimination when the structure ; 0, 1,+, is extended with the predicates (d|())d for divisibilities by fixed integers d: in the theory of this extended structure, for every quantifier-free formula φ(x,𝒚) there is a quantifier-free formula ψ(𝒚) that is equivalent to x:φ(x,𝒚). The construction of ψ is effective, which implies the decidability of Presburger arithmetic. The algorithm to decide PrA is the canonical example for the notion of quantifier elimination procedure. The computational complexity of the many variants of this procedure has a long history, beginning with Oppen’s proof [25] that Cooper’s procedure [12] runs in triply exponential time, and followed by refinements from Reddy and Loveland [27], and later Weispfenning [30], which enable handling formulae with fixed quantifier alternations in doubly exponential time. Recent research on quantifier elimination aims at narrowing the complexity gap for the existential fragment (only last year it was discovered that quantifier elimination can be performed in exponential time in this case [11, 20]) and on extending the procedure to handle additional predicates and functions [28, 3, 11, 22], or other forms of quantification [10, 21, 4]. The reader can find an extensive bibliography on Presburger arithmetic, and quantifier elimination, in the survey papers by Haase [19] and Chistikov [9].

This paper addresses the open problem raised in the papers [6] and [15] regarding the existence of a quantifier elimination procedure for the theory Th; 0, 1,+,xtx,, known as one-parametric Presburger arithmetic (PrA[t]). In this theory, the structure of Presburger arithmetic is extended with the function xtx for multiplication by a single parameter t ranging over . Every PrA[t] formula φ(𝒙) defines a parametric Presburger family 𝕊(φ){φk:k}​, where φk is the set of (integer) solutions of the Presburger arithmetic formula obtained from φ by replacing the parameter t with the integer k.

Example 1.

Consider the statement “for every two successive positive integers t and t+1, and for all integers a and b, there is an integer x in the interval [0,t(t+1)1] that is congruent to a modulo t, and to b modulo t+1”. The truth of this sentence follows from the Chinese remainder theorem together with the fact that successive positive integers are always coprime. We can encode this statement in PrA[t] with the formula ab:χ(a,b), where

χt1x: 0xxt2+t1(y:xa=ty)(z:xb=(t+1)z).

From the validity of the statement, we find χk=2 for every k. That is to say, for every instantiation of t, both φ and χ are tautologies of PrA. ∎

There are many natural decision problems regarding PrA[t] (all taking a formula φ as input):

  • satisfiability: Is φ satisfiable for an instantiation of the parameter (i.e., 𝕊(φ){}) ?

  • universality: Is φ satisfiable for all instantiations of the parameter (i.e., 𝕊(φ)) ?

  • finiteness: Is φ satisfiable for only finitely many instantiations of the parameter t ?

In [6], Bogart, Goodrick, and Woods consider a search problem that generalises all the problems above: they show how to compute, from an input formula φ, a closed expression for the function f(k)#φk, where #S stands for the cardinality of a set S. By relying on properties of this function, one can solve satisfiability, universality, and finiteness. In their proof, the first ingredient is given by Goodrick’s bounded quantifier elimination procedure [15]. In contrast to the quantifier elimination procedures for PrA, in this procedure every quantified variable x is not completely eliminated from the formula φ, but acquires instead a bound 0xf(t), for some univariate polynomial f(t). An example of this is given by the variable x in Example 1, which is bounded in [0,t(t+1)1]. Closely related bounded quantifier elimination procedures were also developed in [23, 31]. The second ingredient of the construction is given by a method developed by Chen, Li, and Sam for the study of parametric polytopes [8], and dubbed “base t division method” in [6]. This method produces a quantifier-free PrA[t] formula ψ satisfying #ψk=#φk for every k.

The combination of the two ingredients has a drawback: the equivalence of the initial formula φ with the quantifier-free formula ψ over is not preserved. In [6, p. 13], the authors ask whether this issue can be fixed: “one might try to show that any formula [ of PrA[t] ] is logically equivalent to a quantifier-free formula in a slightly larger language with additional “well-behaved” function and relation symbols [ … ] But we already know that quantifier elimination in the original language [ of the structure ; 0, 1,+,xtx, ] is impossible, and finding a reasonable language for quantifier elimination seems difficult”. A candidate for the extended structure was suggested by Goodrick in [15, Conjecture 2.6]: PrA[t] must be extended with all integer division functions xx|f(t)|, one for each integer polynomial f(t) (these functions are assumed to occur in a formula only under the proviso that f(t)0). This is a rather tight conjecture, as all added functions are trivially definable in PrA[t]: the equality y=x|f(t)| holds if and only if f(t)0|f(t)|yxx<|f(t)|y+|f(t)|.

We give a positive answer to Goodrick’s conjecture:

Theorem 2.

One-parametric Presburger arithmetic admits effective quantifier elimination in the extended structure ; 0, 1,+,xtx,xx|f(t)|,.

Above, the adjective “effective” reflects the fact that there is a quantifier elimination procedure for constructing, given an input formula φ, an equivalent quantifier-free formula ψ. The main contribution towards the proof of Theorem 2 is a procedure for removing bounded quantifiers while preserving formula equivalence; hence obtaining ψk=φk for all k, instead of the weaker #ψk=#φk obtained with the “base t division method” from [6].

As mentioned above, an active area of research in quantifier elimination focuses on existential Presburger arithmetic (PrA) and its extensions. This interest is motivated, on the one hand, by the goal of improving both the performance and expressiveness of SMT solvers, mostly targeting existential theories [2, 14]. On the other hand, recent work has revisited the computational complexity of quantifier elimination procedures. For many years, these procedures were regarded as inefficient when applied to PrA. Notably, Weispfenning’s classic approach [30] yields only a NExpTime upper bound for satisfiability, despite fundamental results from integer programming [7, 29] establishing that PrA is in NP. It was not until 2024 that two independent works [11, 20] provided quantifier elimination procedures with matching NP upper bounds. The approach in [20] builds on the geometric ideas from [29], while [11] adapts Bareiss’ fraction-free Gaussian elimination procedure [1] to PrA. Starting from the fact that Bareiss’ algorithm works in any integral domain, we show that the second approach extends naturally to PrA[t]. By analysing the runtime of our procedure, we derive:

Theorem 3.

For the class of all existential formulae of PrA[t], the following holds:

Satisfiability Universality Finiteness
NP-complete coNExp-complete coNP-complete

Our result on the satisfiability problem generalises the feasibility in NP of non-linear integer programs A𝒙𝒃(t), where 𝒃(t) is a vector of quotients of integer polynomials in t, proved by Gurari and Ibarra [17]. We remark that both problems are NP-hard in fixed dimension: solvability of systems x0at2+bx=c is a well-known NP-complete problem [24].

Future work.

This paper does not provide a complexity analysis for full PrA[t]. A back-of-the-envelope calculation of the runtime of the procedures in [6] and [15] suggests that the satisfiability problem for PrA[t] is in elementary time (potentially in 3ExpTime). However, these procedures do not yield an NP upper bound for the existential fragment. In contrast, the procedure we introduce shows PrA[t] in NP, but it may in principle run in non-elementary time on arbitrary formulae. Unifying these procedures into a single “optimal” one seems possible and will be addressed in a forthcoming extended version of this paper. This would also provide an extension to the 3ExpTime quantifier-elimination procedure for almost linear arithmetic proposed by Weispfenning in [30].

Most of the literature on PrA[t] focuses on computing the function f(k)#φk, as introduced in [6]. Not much is known regarding the complexity of computing this function. To our knowledge, the most significant result in this direction is the one in [5], where Bogart, Goodrick, Nguyen, and Woods show that f(k) can be computed in polynomial time (in the bit-length of k given as part of the input) whenever φ is a fixed PrA[t]-formula. We believe Theorem 3 to be a good starting point for further research in this direction.

While our work shows that the feasibility problem for integer programs in which a single variable occurs non-linearly is in NP, the paper does not discuss related optimisation problems of minimisation/maximisation. From our quantifier elimination procedure, we can show that if there are optimal solutions to a linear polynomial with coefficients in [t] subject to a formula in PrA[t], then one is of polynomial bit size. Generalising this result to other non-convex objectives is an interesting avenue for future research.

2 Preliminaries

We write for the non-negative integers, and [t] for the set of univariate polynomials f(t)=i=0daiti, where the coefficients a1,,ad and the constant a0 are over the integers . The height h(f), degree deg(f) and bit size f of f are defined as h(f)max{|ai|:i[0,d]}, deg(f)max{0,i[0,d]:ai0}, and f(deg(f)+1)(log2(h(f)+1)+1), respectively. For example, f(t)=2t23 has degree 2, height 3 and bit size 9. Vectors of variables are denoted by 𝒙,𝒚,𝒛, etc.; we write for the floor function.

On extending the structure of PrA[t].

As discussed in Section 1, the paper concerns the extension of the first-order theory of ; 0, 1,+,xtx, by all integer division functions xx|f|, where f[t]. However, in the context of our quantifier elimination procedure, it is more natural to work within the (equivalent) first-order theory of the structure:

; 0, 1,+,xtx,{xxtd}d,{x(xmodf)}f[t],{f|x}f[t],=,

where:

  • The integer division xxtd is only defined for t0, with the obvious interpretation.

  • The integer remainder function x(xmodf(t)) is defined following the equivalence

    (xmodf(t)=y)(f(t)=0y=x)(f(t)0y=x|f(t)|x|f(t)|).

    We remark that whenever f(t)0 the result of (xmodf(t)) belongs to [0,|f(t)|1].

    (Also note that the absolute value function |.| is easily definable in Presburger arithmetic.)

  • The divisibility relation f(t)|x is a unary relation, and is defined following the equivalence

    (f(t)|x)(f(t)=0x=0)(f(t)0(xmodf(t)=0)).

    We remark that the divisibility relations and integer remainder functions are defined to satisfy the equivalence f(t)|xf(t)|(xmodf(t)) also when f(t) evaluates to 0.

For simplicity, we still denote this first-order theory with PrA[t]. Observe that we have ultimately defined (f(t)|) and x(xmodf(t)) in terms of xx|f|. As a result, every formula in this first-order theory can be translated into a formula from the theory in Theorem 2. This translation can be performed in polynomial time by introducing new existential quantifiers, or in exponential time without adding quantifiers (the blow-up is only due to the disjunctions in the definitions of (f(t)|) and x(xmodf(t))).

The terms of PrA[t] are built from the constants 0,1, integer variables, and the functions of the structure. Without loss of generality, we restrict ourselves to (finite) terms of the form

τf0(t)+i=1nfi(t)xi+i=n+1mfi(t)τitdi+i=m+1kfi(t)(τimodgi(t)), (1)

where all fi and gi belong to [t], all di belong to , and each τi is another term of this form. The term τ is said to be linear, if fi(t)=0 for i[n+1,k] (i.e., it does not contain integer division, nor integer remainder functions), and non-shifted whenever f0(t)=0. Above, the terms τitdi and (τimodgi(t)) are linear occurrences of the integer division functions and integer remainder functions, and are said to occur linearly in τ. When every fi is an integer (a degree 0 polynomial), we define 1-norm of τ as τ1i=0k|fi|.

Moving to the atomic formulae of the theory, it is easy to see that equalities, inequalities and divisibility relations can be rewritten (in polynomial time) to be of the form τ=0, τ0 and f(t)|τ, respectively, where τ is a term of the form given in Equation 1. Syntactically, we will only work with atomic formulae of these forms, which we call PrA[t] constraints. However, for readability, we will still sometimes write (in)equalities featuring non-zero terms on both sides (i.e., τ1τ2), and strict inequalities τ1<τ2 and τ2>τ1; both are short for τ1τ2+10. A PrA[t] constraint is said to be linear if the term τ featured in it is linear.

We restrict ourselves to formulae in prenex normal form 𝒙1𝒙2𝒙n:φ where φ is a positive Boolean combination of PrA[t] constraints; that is, the only Boolean connectives featured in φ are conjunctions  and disjunctions . This restriction is without loss of generality, as De Morgan’s laws allow to push all negations at the level of literals, which can then be removed with the equivalences ¬(τ=0)τ<0τ>0,  ¬(τ0)τ>0 and ¬(f(t)|τ)(f(t)=0(τ<0τ>0))(τmodf(t)>0).

For two terms τ1 and τ2, we write [τ2/τ1] for a term substitution. We see these substitutions as functions from terms to terms or from formulae to formulae: τ[τ2/τ1] is the term obtained by replacing, in the term τ, every occurrence of τ1 with τ2. Analogously, φ[τ2/τ1] is the formula obtained from φ by replacing the term τ with τ[τ2/τ1] in every atomic formula τ=0, τ0, or f(t)|τ. In Section 4 we will also need a stronger notion of substitution, called vigorous substitution in [11]; we defer its definition to that section.

3 Outline of the quantifier elimination procedure

In this section, we provide a high-level overview of our quantifier elimination procedure, highlighting the interactions among its various components. A detailed analysis of the two main components will be provided in the subsequent sections of the paper.

Let us consider a formula ψ(𝒙0)𝒙1𝒙2𝒙n:φ(𝒙0,,𝒙n), where φ is a positive Boolean combination of PrA[t] constraints. Our quantifier elimination procedure will work under the assumption that the parameter t is greater than or equal to 2. This simplifying assumption is without loss of generality, as the general problem is then solved as follows:

  • For every k{1,0,1}, call a quantifier elimination procedure for Presburger arithmetic (e.g., the one in [30]) on the formula ψ[k/t], obtaining ψk. Let ψkψk(t=k).

  • Call our procedure on ψ, obtaining a formula ψ+. Let ψ2ψ+t2.

  • Call our procedure on ψ[t/t], obtaining ψ. Let ψ2ψ[t/t]t2.

Then, the formula ψ2ψ1ψ0ψ1ψ2 is quantifier-free, and equivalent to ψ.

As a second assumption, we only consider the case where ψ has a single block of existential quantifiers: ψ(𝒙0)=𝒙1:φ(𝒙0,𝒙1). A procedure for this type of formulae can be iterated bottom-up to eliminate arbitrarily many blocks of quantifiers (rewriting 𝒙 as ¬𝒙¬).

Algorithm 1 PrA[t]-QE: A quantifier elimination procedure for PrA[t].

The pseudocode of our procedure is given in Algorithm 1 (PrA[t]-QE). It describes a non-deterministic algorithm: for an input 𝒙:φ, each non-deterministic execution of PrA[t]-QE returns a positive Boolean combination of PrA[t] constraints ψ(𝒛). The disjunction obtained by aggregating all output formulae is equivalent to 𝒙:φ; so it is this disjunction that must ultimately be used to perform quantifier elimination. The choice to present the procedure in this manner is not merely stylistic: it automatically implements Reddy and Loveland’s optimisation for Presburger arithmetic [27]. In quantifier elimination procedures for PrA, eliminating a single variable x from an existential block 𝒚x produces a formula iγi with a DNF-like structure. Reddy and Loveland observed that pushing the remaining existential quantifiers 𝒚 inside the scope of the disjunctions, i.e., rewriting 𝒚iγi into i𝒚γi, and then performing quantifier elimination locally to each disjunct leads to a faster procedure. By keeping variables local to a non-deterministic branch, one achieves the same effect.

We now describe the four components that make up PrA[t]-QE, which can be summarized under the following titles: pre-processing (lines 111), bounded quantifier elimination (call to BoundedQE), elimination of divisibility constraints (call to ElimDiv), and elimination of all bounded quantifiers (call to ElimBounded). For the rest of the section, let 𝒙:φ(𝒙,𝒛) be the input to PrA[t]-QE, where φ is a positive Boolean combination of PrA[t] constraints.

Pre-processing (lines 111).

These lines remove all occurrences of the integer division functions xxtd and of the integer remainder functions x(xmodf(t)), at the expense of adding new existentially quantified variables that are later eliminated. After this step, the formula is a positive Boolean combination of linear constraints. For the integer division function, the algorithm simply adds to the sequence of variables 𝒙 to be eliminated a fresh variable x to proxy a term τtd (line 2). It then relies on the equivalence x=τtdtdxττ<td(x+1) to replace τtd with x (line 3). The removal of integer remainder functions is performed differently. First, let us observe that the following equivalence holds:

y=(τmodf(t))(f(t)=0y=τ)(0yy<|f(t)|1f(t)|τy).

The formula f(t)=0y=τ on the right-hand side of the equivalence is considered in line 8. This line is executed conditionally to a non-deterministic branching (line 6). If it is not executed, then lines 911 are executed instead; these correspond to the formula 0yy<|f(t)|1f(t)|τy. The interesting property of this formula is that the variable y appears bounded by 0 from below, and by either f(t)1 or f(t)1 from above (following the sign of f(t)). Instead of quantifying y using standard existential quantifiers (as done for the variables replacing τtd), in line 10 we use a bounded quantifier:

Definition 4.

A block of bounded quantifiers 𝐰B is given by a sequence of variables 𝐰=(w1,,wm) and a map B assigning to each variable in 𝐰 a polynomial in [t]. Its semantics is given by the equivalence 𝐰B:ψ𝐰:i=1m(0wiB(wi))ψ.

Let us write 𝒙β,𝒚β,Bβ and φβ for the values taken by 𝒙, 𝒚, B and φ in the non-deterministic branch β, when the control flow of the program reaches line 12. The following equivalence holds, where the disjunction β ranges across all non-deterministic branches:

𝒙:φ(𝒙,𝒛)β𝒚βBβ𝒙β:φβ(𝒙β,𝒚β,𝒛). (2)

Bounded quantifier elimination.

Once reaching line 12, the algorithm proceeds by calling the procedure BoundedQE. We will discuss this procedure in Section 4. In a nutshell, its role is to replace the quantifiers 𝒙β on the right-hand side of Equation 2 with bounded quantifiers, that are merged with the already existing block of bounded quantifiers 𝒚βBβ. The formal specification of BoundedQE is given in the next lemma.

Lemma 5.

There is a non-deterministic procedure with the following specification:

The algorithm ensures that the disjunction β𝐰βBβ:ψβ of output formulae ranging over all non-deterministic branches is equivalent to 𝐱:φ.

As stated, the lemma above is also proved by Goodrick in [15], who introduced the first bounded quantifier elimination procedure specifically for PrA[t]. When applied to existential formulae, that procedure requires doubly-exponential time, making it unsuitable for establishing Theorem 3. In contrast, BoundedQE runs in non-deterministic polynomial time. Due to this difference, we cannot rely directly on [15] and must thus re-establish Lemma 5.

Algorithm 2 ElimDiv: Elimination of divisibility constraints.

Removing divisibility constraints: more bounded quantifiers.

BoundedQE introduces divisibility constraints f(t)|τ. The next step, detailed in Algorithm 2 (ElimDiv), eliminates all divisibility constraints in favour, once more, of bounded quantifiers.

The idea behind Algorithm 2 is as follows. Let f(t)|σ(𝒘)+τ(𝒛) be a constraint from the input formula, where 𝒘 are the variables in the block of bounded quantifiers (these correspond to the variables 𝒚β from Equation 2 and those introduced by BoundedQE), and 𝒛 are the free variables. Notice that this constraint is equivalent to f(t)|σ(𝒘)+(τ(𝒛)modf(t)), which is in turn equivalent to the existential formula y:f(t)y+σ(𝒘)+(τ(𝒛)modf(t))=0, where y is a fresh variable ranging over . Since 𝒘 is constrained by bounded quantifiers, we can upper-bound the number of digits in the base t encoding of the linear term σ(𝒘) (recall: t2). When f(t)0, the same applies to (τ(𝒛)modf(t)), which ranges between 0 and f(t)1; and this in turn imposes a bound on the base t representation of y. When f(t)=0 instead, the truth of f(t)y+σ(𝒘)+(τ(𝒛)modf(t))=0 only depends on whether σ(𝒘)+(τ(𝒛)modf(t))=0, and we can thus restrict y to any non-empty interval. This allows us to replace the quantifier y with a bounded quantifier (lines 3 and 4). Since y ranges over , whereas bounded quantifiers use non-negative ranges, the algorithm explicitly guesses the sign of y in line 5, allowing y to only range over instead. Formalising these arguments yields the following lemma.

Lemma 6.

Algorithm 2 (ElimDiv) complies with its specification.

Elimination of all bounded quantifiers.

From the output of ElimDiv, the final operation by PrA[t]-QE is a call to ElimBounded, which removes all bounded quantifiers. This algorithm is detailed in Section 5. Its specification is given in the next lemma.

Lemma 7.

There is a non-deterministic procedure with the following specification:

The algorithm ensures that the disjunction βψβ of output formulae ranging over all non-deterministic branches is equivalent to 𝐰B:φ.

Together, Equation 2 and Lemmas 5, 6, and 7 show that PrA[t]-QE meets its specification; thus showing Theorem 2 conditionally to the correctness of BoundedQE and ElimBounded.

4 Efficient bounded quantifier elimination in PrA[t]

This section outlines the arguments leading to the procedure BoundedQE. Its pseudocode is given in Algorithm 3. We start with an example demonstrating the key idea used to develop a version of bounded quantifier elimination in PrA[t]. These arguments are sufficient for establishing Lemma 5; although they do not result in an optimal procedure complexity-wise. We will then recall the main arguments used in [11] to obtain an optimal procedure, which, when implemented, yield BoundedQE.

Let us consider a formula x:φ(x,𝒛) where, for simplicity, φ is of the form:

τ(𝒛)axbxρ(𝒛)(m|cx+σ(𝒛))a>0b>0m>0,

where a, b, c and m are polynomials from [t], and τ, ρ and σ are linear PrA[t] terms. For the time being, we invite the reader to pick some values for t and the free variables 𝒛, so that the formula φ becomes a formula from Presburger arithmetic in a single variable x. The standard argument for eliminating x in PrA goes as follows (see, e.g., [30]). We first update the inequalities to ensure that all coefficients of x are equal; this results in the inequalities bτabx and abxaρ. The quantification x expresses that there is g such that (i) g is a multiple of ab that belongs to the interval [bτ,aρ]; and (ii) m divides cgab+σ. The key observation is that such an integer (if it exists) can be found by only looking at elements of [bτ,aρ] that are “close” to bτ. More precisely, the properties (i) and (ii) must be simultaneously satisfied by bτ+r, for some r[0,abm]. We can thus restrict x to satisfy an additional constraint abx=bτ+r. A small refinement: since this equality is unsatisfiable when the shift r is not a multiple of b>0, we can rewrite it as ax=τ+s, where the shift s now ranges in [0,am]. Observe that s lies in an interval that is independent of the values picked for 𝒛; as a and m were originally polynomials in t.

Let us keep assigning a value to the parameter t (so, a and m are still integers), but reinstate the variables 𝒛. From the above argument, the formula x:φ(x,𝒛) is equivalent to s=0amx(φ(x,𝒛)ax=τ+s). It is now straightforward to eliminate x from each disjunct x(φ(x,𝒛)ax=τ+s): we simply “apply” the equality ax=τ+s, substituting x for τ+ra, and add a divisibility constraint forcing τ+s to be a multiple of a. After this substitution, both ax=τ+s and τ(𝒛)ax become . The resulting disjunct is

ψ(s,𝒛)b(τ+s)aρ(ma|c(τ+s)+aσ)(a|τ+s)a>0b>0m>0,

and s=0amψ(s,𝒛) is equivalent to x:φ(x,𝒛). (For PrA, this concludes the quantifier elimination procedure.) When restoring the parameter t, these two formulae are still equivalent, but the number of disjunctions s=0am now depends on t. We replace them with a bounded quantifier, rewriting s=0amψ(s,𝒛) as sB:ψ(s,𝒛), where B(s)a(t)m(t). This is, in a nutshell, the bounded quantifier elimination procedure from [15, 31].

When the signs of a, b, and m are unknown (i.e., φ does not feature the constraints a>0, b>0 and m>0), we must perform a “sign analysis”: we write a disjunction (or guess) over all possible signs of the three polynomials. In Algorithm 3, the lines marked in yellow are related to this analysis; e.g., line 16 guesses the sign of the (non-zero) coefficient a of x.

Algorithm 3 BoundedQE: A bounded quantifier elimination procedure for PrA[t].

Taming the complexity of the procedure.

Problems arise when looking at the complexity of the procedure outlined above. To understand this point, consider the inequality b(τ+s)aρ, which was derived by substituting τ+sa for x in bxρ, and suppose τ=cy+τ and ρ=dy+ρ, for some variable y. This inequality can be rewritten as (bcad)y+bτaρ+bs0. When looking at the coefficient (bcad) of y one deduces that, if quantifier elimination is performed carelessly on a block 𝒙 of multiple existential quantifiers, the coefficients of the variables in the formula will grow quadratically with each eliminated variable. Then, by the end of the procedure, their binary bit size will be exponential in the number of variables in 𝒙. However, this explosion can be avoided by noticing that coefficients are updated following the same pattern as in Bareiss’ polynomial-time Gaussian elimination procedure [1]. This insight was highlighted in [11], building upon an earlier observation from [31]. In Bareiss’ algorithm, the key to keeping coefficients polynomially bounded is given by the Desnanot–Jacobi identity. Consider an m×d matrix A. Let us write A[i1,,ir;j1,,j] for the r× sub-matrix of A made of the rows with indices i1,,ir[1,m] and columns with indices j1,,j[1,d]. For i,j, with 0min(m,d), 1im and 1jd, we define ai,j()detA[1,,,i;1,,,j].

Proposition 8 (Desnanot–Jacobi identity).

For every i,j, with 2, <im and <jd, we have (a,(1)ai,j(1)a,j(1)ai,(1))=a,(2)ai,j().

The Desnanot–Jacobi identity is true for all matrices with entries over an integral domain (a non-zero commutative ring in which the product of non-zero elements is non-zero), and therefore we can take the entries of A to be polynomials in [t].

Returning to our informal discussion, we now see that the coefficient (bcad) of y is oddly similar to the left-hand side of the Desnanot–Jacobi identity. Suppose that the elements ai,j(1) are the coefficients of the variables in the formula currently being processed by the quantifier elimination procedure, and we are eliminating the -th quantifier. Proposition 8 tells us that all coefficients produced by the naïve elimination (left-hand side of the identity) have a,(2) as a common factor. By dividing through by this common factor, we obtain smaller coefficients for the next step of variable elimination – namely, ai,j(). When eliminating the first variable (=1), the common factor is 1. Otherwise, it is the coefficient a that the (1)-th eliminated variable x has in the equality ax=τ+s used for the elimination. In Algorithm 3, the lines marked in blue implement Bareiss’ optimisation: line 8 initialises the common factor (t) and its sign, line 15 updates it, and line 22 performs the division.

Some details on BoundedQE.

Lines 14 handle the divisibility constraints f(t)|τ with the divisor f(t) equal to 0. Such constraints are equalities in disguise, and the procedure replaces them with τ=0. When the procedure reaches line 5, all divisors in the divisibility constraints are assumed non-zero. Following the example from the previous paragraph, recall that the shifts s belong to intervals that depend on these divisors; when multiple divisors occur, the procedure for PrA takes their lcm (instead of just m as in our example). For simplicity, instead of lcm, BoundedQE considers the absolute value m(t) of their product (line 6). After guessing the sign ± of this product, the procedure enforces m(t)>0 in line 7. This information is stored in the formula χ, which accumulates all sign guesses made by the algorithm; these are conjoined to φ when the procedure returns.

Line 9 replaces all inequalities with equalities by introducing slack variables ranging over . (This step is inherited from [11].) Slack variables represent the shifts s from the quantifier elimination procedure for PrA. Line 12 covers the corner cases of x not appearing in equalities, or t being such that all the coefficients f(t) of x evaluate to zero. After guessing an equality f(t)x+τ=0 to perform the substitution (line 14), line 19 checks whether τ features a slack variable y (i.e., the equality was originally an inequality). If so, the procedure generates a bounded quantifier for y. The elimination of x (line 21) is performed with the vigorous substitution φ[[τf(t)/x]] which works as follows: 1: Replace every equality ρ=0 with f(t)ρ=0, and every divisibility g(t)|ρ with f(t)g(t)|f(t)ρ; this is done also for constraints where x does not occur. 2: Replace every occurrence of f(t)x with τ (from step 1, each coefficient of x in the system can be factored as f(t)h(t) for some h[t]).

After applying the vigorous substitution, the procedure divides all coefficients of the inequalities and divisibility constraints in φ by the common factor of the Bareiss’ optimisation (line 22). In the case of divisibility constraints, divisors are also affected. Proposition 8 ensures that these divisions are all without remainder. In practice, the traditional Euclidean algorithm for polynomial division can be used to construct the quotient in polynomial time. As a result of these divisions, throughout the procedure all polynomials f(t) guessed in line 14 have polynomial bit sizes in the size of the input formula.

After the foreach loop of line 10 completes, all variables from 𝒙 have been eliminated (line 21) or bounded (line 12). A benefit of translating inequalities into equalities in line 9 is that x can be eliminated independently of the sign of its coefficient f(t); inequalities would need to flip for f(t) negative instead. The final step (lines 24 and 25) drops all slack variables for which no bound was assigned in line 20, reintroducing the inequalities (the sign stored in ± tells us the direction of these inequalities). This step is also inherited from [11].

By fully developing the arguments above, one shows that BoundedQE is correct:

Lemma 9.

Algorithm 3 (BoundedQE) complies with its specification.

This lemma implies Lemma 5. In the sequel we will also need the next lemma, discussing properties of the outputs of BoundedQE for “Presburger-arithmetic-like” inputs.

Lemma 10.

Let 𝐱:φ(𝐱,𝐳) be a formula input of Algorithm 3, in which all coefficients of the variables in 𝐱, and all divisors f(t) in relations (f(t)|), are integers. The map Bβ in the output of each non-deterministic branch β ranges over the integers.

5 Elimination of polynomially bounded quantifiers

Algorithm 4 ElimBounded: Elimination of polynomially bounded quantifiers.

We move to Algorithm 4 (ElimBounded), which eliminates the bounded quantifiers in three steps: replacement of bounded variables by their t-ary expansions; “divisions by t” until all t-digits have integer coefficients; elimination of t-digits via BoundedQE.

Base 𝒕 expansion (lines 16).

Following the semantics of bounded quantifiers, line 1 adds to φ the bounds 0wwB(w), for each bounded variable w. The subsequent lines “bit blast” w into its t-ary expansion tMyM++ty1+y0, where M is the largest bit size of the bounds in B (line 2). All added variables 𝒚 are t-digits, i.e., they range in [0,t1].

Example 11.

Let us see this step in action on a bounded version of the formula in Example 1:

(x,y,z)B:(ty=x+(amodt))((t+1)z=x+(bmodt+1)),

where B(x)=t2+t1, and B(y)=B(z)=t+2. By “bit blasting” the bounded variables into t-digits 𝐱=(x0,x1,x2), 𝐲=(y0,y1,y2), and 𝐳=(z0,z1,z2), we obtain the formula

𝒙,𝒚,𝒛:w{x,y,z}(0(w2t2+w1t+w0)B(w) i{0,1,2}0wi<t)
t(y2t2+y1t+y0)=(x2t2+x1t+x0) +(amodt)
(t+1)(z2t2+z1t+z0)=(x2t2+x1t+x0) +(bmodt+1).
Lemma 12.

Let φ(𝐲,𝐳) be the formula obtained from φ by performing lines 16 of Algorithm 4. Then, the input formula 𝐰B:φ(𝐰,𝐳) is equivalent to 𝐲:φ(𝐲,𝐳) and every (t-digit) variable in 𝐲 has only linear occurrences in φ.

The coefficients of the 𝒕-digits become integers (lines 717).

This step is defined by the while loop of line 7, whose goal is to transform the formula φ into an equivalent positive Boolean combination of equalities and inequalities in which all coefficients of 𝒚 are integers.

Example 13.

Before delving into the details, let us illustrate the transformation on the equality (t+1)(z2t2+z1t+z0)=(x2t2+x1t+x0)+(bmodt+1) from Example 11. Grouping terms according to powers of t, we obtain:

z2t3+(x2z1z2)t2+(x1z0z1)t+(x0z0)+(bmodt+1)=0.

We symbolically perform a division with remainder on the sub-term (bmodt+1) concerning the free variables, rewriting it as bmodt+1tt+((bmodt+1)modt). In the resulting equality, we notice that (x0z0)+((bmodt+1)modt) must be divisible by t. Since both x0 and z0 belong to [0,t1], only two multiples of t are possible: 0 and t. Consider the latter case: we can rewrite the equality as the conjunction of t=(x0z0)+((bmodt+1)modt) and z2t3+(x2z1z2)t2+(x1z0z1)t+bmodt+1tt+t=0. By dividing the second equality by t, the variables x0, x1 and z0 end up appearing with integer coefficients only. Repeating this process guarantees that all quantified variables satisfy this property: the second iteration “frees” x2 and z1, and the third iteration handles the variable z2. ∎

The while loop guesses some integers in line 11. Let Ri be the (finite) set of all sequences 𝒔 of guesses from the first i iterations of the loop (so, 𝒔 has length i), and let φ𝒔 be the unique formula obtained from φ after iterating the loop i times, using 𝒔 as the sequence of guesses. (The subscript corresponds to the empty sequence of guesses; the only element in R0.)

Together with proving that the while loop preserves formula equivalence (across non-deterministic branches), the critical parameter to track during the execution of the loop is the degrees of all coefficients of the t-digits 𝒚. Showing that this parameter reaches 0 implies loop termination, and correctness of this step of the procedure. More formally, we inductively define the 𝒚-degree deg(𝒚,φ) of a positive Boolean combination of PrA[t] constraints φ(𝒚,𝒛), where the variables 𝒚=(y1,,y) occur only linearly, as follows (below, {,=}):

  • deg(𝒚,φ)=max{deg(fi):i[1,]}

    if φ is an (in)equality i=1fi(t)yi+τ(𝒛)0;

  • deg(𝒚,φ)=deg(𝒚,φ1)+deg(𝒚,φ2)

    if φ is either (φ1φ2) or (φ1φ2).

Then, the defining property of the while loop of line 7 can be stated as follows:

Lemma 14.

Consider 𝐬Ri with deg(𝐲,φ𝐬)>0, and the set G{𝐬rRi+1:r}. Then, (i) φ𝐬 is equivalent to 𝐫Gφ𝐫, and (ii) deg(𝐲,φ𝐬)>deg(𝐲,φ𝐫) for every 𝐫G.

Proof sketch..

The while loop considers an (in)equality η0 from φ𝒔 (line 7); inequalities are transformed into strict inequalities η1<0 in line 8, as in this case the latter are easier to work with. Line 9 represents the term of the (in)equality as σ(𝒚)t+ρ(𝒚)+τ(𝒛), where σ is linear, ρ is a linear term with coefficients in , and τ(𝒛) is non-shifted.

 Remark.

Observe that line 17 will later replace η0 with σ+r+τt0. If the latter (in)equality is considered again by the while loop at a later iteration, this replacement will produce the term τtt, which can be rewritten as τt2. We assume the algorithm to implicitly perform this rewriting, so that the term above can in fact be written as

σ(𝒚)t+ρ(𝒚)+τ(𝒛)tk, where k0, such that τt0τ. (3)

Let us define η=σ(𝒚)+τ(𝒛)tk+1 and ρ=ρ(𝒚)+(τ(𝒛)tkmodt), so that the term in Equation 3 is then equal to ηt+ρ. (Note: ρ is exactly the term in line 10.) We are now ready to perform the symbolic division by t. Indeed, since all variables in 𝒚, as well as the term (τ(𝒛)tkmodt), belong to [0,t1], we conclude that ρ[tN,tN] where Nρ1. Line 11 guesses an integer r from the segment [N,N], which stands for the quotient of the division of ρ by t. Each guess corresponds to a disjunct from the following two equivalences:
ηt+ρ=0r=NN(η+r=0rt=ρ),ηt+ρ<0r=NN(η+r+10trρρ<t(r+1)).quotient of the divisionformula γ in the pseudocode
These equivalences “perform” the symbolic division by t. In line 17, the algorithm substitutes the constraint η0 with the result of the division, that is, the conjunction of the quotient and the remaining part that is stored the formula γ (lines 1216). Observe a key property of γ: in it, all the coefficients of the t-digits 𝒚 only have integer coefficients, i.e., deg(𝒚,γ)=0.

Let χr be the formula obtained from φ by performing the replacement in line 17. This formula belongs to Ri+1 and, moreover, φ𝒔r=NNχr. We have G={𝒔r:r[N,N]}, and Item 14 is proved. To prove Item 14, observe that

deg(𝒚,χr) =deg(𝒚,φ𝒔)deg(𝒚,η0)+deg(𝒚,η0)+deg(𝒚,γ)
=deg(𝒚,φ𝒔)deg(𝒚,σt0)+deg(𝒚,σ0)=deg(𝒚,φ𝒔)1.

Elimination of 𝒕-digits (lines 1826).

By inductively applying Lemma 14, we deduce that the while loop performs at most deg(𝒚,φ) iterations, and that the disjunction (over all non-deterministic branches) of formulae φ𝒓 obtained at the end of this loop is equivalent to φ. The constraints in each φ𝒓 are (in)equalities f(t)+τ(𝒛)+i=1aiyi0, where a1,,a, f[t], all y1,,y are t-digits, and τ is a non-shifted term of PrA[t].

The last step is to remove the t-digits 𝒚 by appealing to BoundedQE (line 22). Recall that this algorithm requires all PrA[t] constraints in the input to be linear, while terms τ(𝒛) in φ𝒓 may contain (nested) occurrences of the functions td and (modf(t)). In order to respect this specification, ElimBounded first replaces each non-shifted term τ(𝒛) in φ𝒓 with a fresh variable z, storing the substitution [τ(𝒛)/z] in the map S (line 20). These terms are restored at the end of the procedure (line 26). Since the variables 𝒛 occur free in the formula in input to BoundedQE, and this procedure preserves formula equivalence (Lemma 9), the overall process remains sound.

The formula in input of BoundedQE has no divisibility constraints, and the eliminated variables 𝒚 have integer coefficients. By Lemma 10 the output of each non-deterministic branch is a formula 𝒘B:ψ(𝒘,𝒛) where, for every variable w in 𝒘, the bound B(w) is an integer. We can thus replace w with a (guessed) integer g[0,B(w)] (lines 2325). After restoring the terms stored in S, the resulting formula is quantifier-free and the disjunction over all outputs of ElimBounded is equivalent to the input formula.

Lemma 15.

Algorithm 4 (ElimBounded) complies with its specification.

This lemma implies Lemma 7, which was the last missing piece required to complete the proof of Theorem 2. To simplify the complexity arguments in the next section, we make use of the two observations in the following lemma, concerning the output of ElimBounded.

Lemma 16.

In every output of ElimBounded, all functions td and (modf(t)) are applied to non-shifted terms. In divisibility relations (f(t)|), the divisor f(t) is an integer.

6 Solving satisfiability, universality and finiteness

Now that we have established that PrA[t] admits quantifier elimination, let us discuss the decision problems of satisfiability, universality and finiteness defined in Section 1. Without loss of generality, we add to the formula φ in input to these problems a prefix of existential quantifiers over all its free variables; thus assuming that φ is a sentence.

Applying our quantifier elimination procedure to the sentence φ results in a variable-free formula ψ whose truth only depends on the value taken by the parameter t. Furthermore, from Lemma 16, all occurrences of the functions td and (modf(t)) are applied to the constant 0 (the only variable-free non-shifted term) and can thus be replaced with 0; and all divisibility relations (f(t)|) are such that f(t) is an integer. That is to say, ψ is a positive Boolean combination of univariate polynomial inequalities g(t)0, equalities g(t)=0 and divisibility constraints d|g(t), where g[t] and d.

We study the solutions to such a univariate formula ψ(t). First, recall that computing the set of all integer roots of a polynomial in [t] can be done in polynomial time:

Theorem 17 (​​[13, Theorem 1]).

There is a polynomial time algorithm that returns the set of integer roots of an input polynomial f[t].

This theorem implies that the every integer root of f[t] has bit size polynomial in f. Let r1<<rn be the roots of all the polynomials occurring in (in)equalities of ψ. These roots partition in 2n+1 regions (,r11],{r1},[r1+1,r21],{r2},,{rn},[rn+1,). The truth of all (in)equalities in ψ remains invariant for integers within the same region. Furthermore, the solutions to the divisibility constraints in ψ are periodic with period plcm{d:(d|) occurs in ψ}>0, i.e., setting t=b satisfies the same divisibility constraints as t=b+p, for every integer b. Then, a solution to ψ (if it exists) can be found in the interval [r1p,rn+p]. Moreover, ψ has infinitely many solutions if and only if one solution lies in intervals [r1p,r11] or [rn+1,rn+p]. To recap:

Lemma 18.

Let ψ be a positive Boolean combination of polynomial inequalities g0, equalities g=0 and divisibility constraints d|g, where g[t] and d. Then,

  1. 1.

    If ψ has a solution, then it has one of bit size polynomial in the size of ψ.

  2. 2.

    If ψ has a polynomial bit size solution that is either larger or smaller than all roots of the polynomials in (in)equalities of ψ, then ψ has infinitely many solutions, and vice versa.

The complexity of the existential fragment.

Lemma 18 implies decidability of all the decision problems of satisfiability, universality and finiteness. We now analyse their complexity for the existential fragment of PrA[t], establishing Theorem 3. For simplicity of the exposition, we keep assuming t2. Our reasoning can be extended in a straightforward way to all t, following the discussion given at the beginning of Section 3.

First and foremost, we study the complexity of our quantifier elimination procedure.

Lemma 19.

Algorithm 1 (PrA[t]-QE) runs in non-deterministic polynomial time.

Proof idea..

For the proof we track the evolution of the following parameters as Algorithm 1 executes, where φ is a formula, and B is a map used for the bounded quantification:

  • atom(φ)(number of occurrences of atomic formulae in φ),

  • vars(φ)(number of variables in φ),

  • func(φ)(number of occurrences of td and (modf(t)) in an atomic formula of φ),

  • const(φ)max{f:f[t] occurs in φ},

  • Bmax{0,B(w):w is in the domain of B}.

For example, for the formula γ(g|f1x+f2x+f3yt+f4t+f5), we have atom(γ)=1, vars(γ)=2, func(γ)=2 (two occurrences of t), const(γ)=max{g,f1,,f5,t}. The bit size of φ is polynomial in the values of these parameters.

One can show that throughout the procedure each of these parameters remain polynomially bounded with respect to all the parameters of the input formula. For instance, during the first two steps of ElimBounded, the number of variables in the manipulated formulae (φ and γ) increases at most polynomially in B, due to the bit blasting of the bounded variables. However, by the end of the procedure, it reduces to the number of free variables – as expected by a quantifier elimination procedure.

While tedious, this proof is not dissimilar to the other complexity analyses of quantifier elimination procedures for PrA; see, e.g., [30]. Once the evolution of the parameters is known, it is simple to show that Algorithm 1 runs in non-deterministic polynomial time.

Our results on decision problems for existential formulae of PrA[t] follow.

Proof of Theorem 3.

Satisfiability.

By Lemma 19 and Lemma 18.1, if the input sentence γ𝒙:φ(𝒙) is satisfiable (equivalently, valid), then γk for some k of bit size polynomial in the size of γ. Observe that replacing t for k in γ yields an existential sentence of Presburger arithmetic of size polynomial in the size of γ. Checking satisfiability for PrA is a well-known NP-complete problem [29]. We conclude that the satisfiability problem for existential formulae of PrA[t] is also NP-complete.

Universality.

By Lemma 19, Algorithm 1 can be implemented by a deterministic exponential time Turing machine T: given an input sentence γ, T computes an equivalent disjunction ψβψβ of exponentially many polynomial-size formulae ψβ. By Lemma 16, each ψβ is a positive Boolean combination of (in)equalities g(t)0 and divisibility constraints d|g(t), with g[t] and d{0}. From Theorem 17, all roots r1<<rn of polynomials in (in)equalities of ψ are of bit size polynomial in the size of γ. However, the period plcm{d:(d|) occurs in ψ} may be of exponential bit size.

As a certificate asserting that γ is a negative instance, we can take ψ, the sequence of configurations reached by T when computing ψ from γ, and a number k[r1p,rn+p]. The certificate is verified in polynomial time (in its size) by checking that the sequence of configurations is a valid run of T computing ψ from γ, and that k is not a solution to ψ(t). Since the certificate has exponential size, universality is in coNExp. (coNExp-hardness follows from the coNExp-hardness of the fragment of PrA [16, 18].)

Finiteness.

Equivalently, we show that the problem of checking whether a sentence γ is satisfiable for infinitely many instantiations of t is NP-complete. The proof of NP-hardness is trivial: for sentences without t, this problem is equivalent to the satisfiability problem for PrA. For the NP membership, let us consider the formula βψβ computed from an input sentence γ via Algorithm 1. If γ is satisfied by infinitely many values of t, then the same holds for least one of the formulae ψβ. By Lemma 18.2, ψβ has infinitely many solutions if and only if it has a solution k of bit size polynomial in the size of γ, such that k is either larger or smaller than all roots of polynomials appearing in (in)equalities of ψβ. Then, as a certificate asserting that γ has infinitely many solutions we can provide ψβ, the sequence of non-deterministic guesses made by Algorithm 1 to compute ψβ from γ, and the value k. This certificate can be verified in polynomial time: first, run Algorithm 1 using the provided sequence of guesses, and check that the output is ψβ. Then, compute (in polynomial time) all roots of the polynomials appearing in the (in)equalities of ψβ, and verify that k is a solution to ψβ that is either larger or smaller than all of them.

References

  • [1] Erwin H. Bareiss. Sylvester’s identity and multistep integer-preserving Gaussian elimination. Math. Comput., 1968. doi:10.1090/S0025-5718-1968-0226829-0.
  • [2] Clark W. Barrett and Cesare Tinelli. Satisfiability modulo theories. In Handbook of Model Checking. 2018. doi:10.1007/978-3-319-10575-8_11.
  • [3] Michael Benedikt, Dmitry Chistikov, and Alessio Mansutti. The complexity of Presburger arithmetic with power or powers. In ICALP, 2023. doi:10.4230/LIPICS.ICALP.2023.112.
  • [4] Pascal Bergsträßer, Moses Ganardi, Anthony W. Lin, and Georg Zetzsche. Ramsey quantifiers in linear arithmetics. In POPL, 2024. doi:10.1145/3632843.
  • [5] Tristram Bogart, John Goodrick, Danny Nguyen, and Kevin Woods. Parametric Presburger arithmetic: complexity of counting and quantifier elimination. Math. Logic Quart., 2019. doi:10.1002/malq.201800068.
  • [6] Tristram Bogart, John Goodrick, and Kevin Woods. Parametric Presburger arithmetic: logic, combinatorics, and quasi-polynomial behavior. Discrete Analysis, 2017. doi:10.19086/da.1254.
  • [7] Itshak Borosh and Leon B. Treybig. Bounds on positive integral solutions of linear Diophantine equations. Proc. Am. Math. Soc., 55(2):299–304, 1976. doi:10.2307/2041711.
  • [8] Sheng Chen, Nan Li, and Steven V. Sam. Generalized Ehrhart polynomials. Trans. Amer. Math. Soc., 2012. doi:10.1090/S0002-9947-2011-05494-2.
  • [9] Dmitry Chistikov. An introduction to the theory of linear integer arithmetic. In FSTTCS, 2024. doi:10.4230/LIPIcs.FSTTCS.2024.1.
  • [10] Dmitry Chistikov, Christoph Haase, and Alessio Mansutti. Quantifier elimination for counting extensions of Presburger arithmetic. In FoSSaCS, 2022. doi:10.1007/978-3-030-99253-8_12.
  • [11] Dmitry Chistikov, Alessio Mansutti, and Mikhail R. Starchak. Integer linear-exponential programming in NP by quantifier elimination. In ICALP, 2024. (Full version of this paper: arXiv:2407.07083). doi:10.4230/LIPICS.ICALP.2024.132.
  • [12] David C. Cooper. Theorem proving in arithmetic without multiplication. Machine Intelligence, 1972.
  • [13] Felipe Cucker, Pascal Koiran, and Steve Smale. A polynomial time algorithm for diophantine equations in one variable. J. Symb. Comput., 1999. doi:10.1006/jsco.1998.0242.
  • [14] Florian Frohn and Jürgen Giesl. Satisfiability modulo exponential integer arithmetic. In IJCAR, 2024. doi:10.1007/978-3-031-63498-7_21.
  • [15] John Goodrick. Bounding quantification in parametric expansions of Presburger arithmetic. Arch. Math. Logic, 2018. doi:10.1007/s00153-017-0593-0.
  • [16] Erich Grädel. Dominoes and the complexity of subclasses of logical theories. Ann. Pure Appl. Log., 1989. doi:10.1016/0168-0072(89)90023-7.
  • [17] Eitan M. Gurari and Oscar H. Ibarra. An NP-complete number-theoretic problem. J. ACM, 26(3):567–581, 1979. doi:10.1145/322139.322152.
  • [18] Christoph Haase. Subclasses of Presburger arithmetic and the weak EXP hierarchy. In CSL-LICS, pages 47:1–47:10, 2014. doi:10.1145/2603088.2603092.
  • [19] Christoph Haase. A survival guide to Presburger arithmetic. ACM SIGLOG News, 2018. doi:10.1145/3242953.3242964.
  • [20] Christoph Haase, Shankara Narayanan Krishna, Khushraj Madnani, Om Swostik Mishra, and Georg Zetzsche. An efficient quantifier elimination procedure for Presburger arithmetic. In ICALP, 2024. doi:10.4230/LIPIcs.ICALP.2024.142.
  • [21] Peter Habermehl and Dietrich Kuske. On Presburger arithmetic extended with non-unary counting quantifiers. Log. Methods Comput. Sci., 2023. doi:10.46298/lmcs-19(3:4)2023.
  • [22] Toghrul Karimov, Florian Luca, Joris Nieuwveld, Joël Ouaknine, and James Worrell. On the decidability of presburger arithmetic expanded with powers. In SODA, 2025. doi:10.1137/1.9781611978322.89.
  • [23] Aless Lasaruk and Thomas Sturm. Effective quantifier elimination for Presburger arithmetic with infinity. In CASC, 2009. doi:10.1007/978-3-642-04103-7_18.
  • [24] Kenneth L. Manders and Leonard Adleman. NP-complete decision problems for binary quadratics. Journal of Computer and System Sciences, 16(2):168–184, 1978. doi:10.1016/0022-0000(78)90044-2.
  • [25] Derek C. Oppen. A 222pn upper bound on the complexity of Presburger arithmetic. J. Comput. Syst. Sci., 1978. doi:10.1016/0022-0000(78)90021-1.
  • [26] Mojżesz Presburger. Über die Vollständigkeit eines gewissen Systems der Arithmetik ganzer Zahlen, in welchem die Addition als einzige Operation hervortritt. In Comptes Rendus du I Congrès des Mathématiciens des Pays Slaves, pages 92–101. 1929.
  • [27] Cattamanchi R. Reddy and Donald W. Loveland. Presburger arithmetic with bounded quantifier alternation. In STOC, 1978. doi:10.1145/800133.804361.
  • [28] Mikhail R. Starchak. Positive existential definability with unit, addition and coprimeness. In ISSAC, 2021. doi:10.1145/3452143.3465515.
  • [29] Joachim von zur Gathen and Malte Sieveking. A bound on solutions of linear integer equalities and inequalities. Proc. Am. Math. Soc., 1978. doi:10.1090/S0002-9939-1978-0500555-0.
  • [30] Volker Weispfenning. The complexity of almost linear Diophantine problems. J. Symb. Comput., 1990. doi:10.1016/S0747-7171(08)80051-X.
  • [31] Volker Weispfenning. Complexity and uniformity of elimination in Presburger arithmetic. In ISSAC, pages 48–53, 1997. doi:10.1145/258726.258746.