# SCL(FOL) Revisited

Martin Bromberger, Simon Schwarz, Christoph Weidenbach

► To cite this version:

Martin Bromberger, Simon Schwarz, Christoph Weidenbach. SCL(FOL) Revisited. Max-Planck-Institut für Informatik, Saarbrücken, Germany. 2023. [hal-04314223](https://hal-04314223)

HAL Id: hal-04314223

https://inria.hal.science/hal-04314223v1

Submitted on 29 Nov 2023

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
SCL(FOL) Revisited

Martin Bromberger, Simon Schwarz, Christoph Weidenbach

Max Planck Institute for Informatics

Saarland Informatics Campus

Saarbrücken, Germany

{mbromber,sschwarz,weidenb}@mpi-inf.mpg.de

February 14, 2023

This paper presents an up-to-date and refined version of the SCL calculus for first-order logic without equality. The refinement mainly consists of the following two parts: First, we incorporate a stronger notion of regularity into SCL(FOL). Our regularity definition is adapted from the SCL(T) calculus. This adapted definition guarantees non-redundant clause learning during a run of SCL. However, in contrast to the original presentation, it does not require exhaustive propagation. Second, we introduce trail and model bounding to achieve termination guarantees. In previous versions, no termination guarantees about SCL were achieved. Last, we give rigorous proofs for soundness, completeness and clause learning guarantees of SCL(FOL) and put SCL(FOL) into context of existing first-order calculi.

# 1 Introduction

First-order automated theorem proving is currently a core topic in automated reasoning. Over the recent years, the development of first-order theorem provers has been very fruitful and had great impact in computer science and mathematics. For instance, automation of first-order theorem proving provided powerful, fully automated tactics for interactive theorem provers. For example, the “Sledgehammer” automation tactic [20,28] provides a link between the interactive prover Isabelle and multiple first-order provers. With this automation tactic, a significant percentage of nontrivial goals can be proven without interaction. Further research [8] employs model-based automated reasoning to not only search for proofs, but also extract counterexamples in case of falsifiable goals. Moreover, automated first-order theorem proving has many use cases in software verification. For instance, progress has been made in the verification of so-called “supervisor code” [11, 12] by translating properties directly to fragments of first-order logic. The
resulting first-order formula is then automatically checked for validity by a first-order
theorem prover.

First-order logic is an important subject of research in automated theorem proving
due to multiple beneficial properties of the logic: First, the logic is very expressive.
In particular, computable problems can always be translated to first-order logic. Sec-
ond, despite its expressiveness, reasoning in first-order logic can be automated. Last,
first-order logic is fairly well-understood and intuitive. Hence, many problems can be
naturally encoded in first-order logic. Note that, in this work, we focus on first-order
logic without equality. SCL for first-order logic with equality is presented in [26].

Overall, the wide applications of automated theorem proving and the advantages of first-order logic explain the demand for efficient first-order automated theorem provers. This led to a multitude of different methods for first-order reasoning:

*Resolution* and *Superposition* are the two traditional methods for first-order reason-
ing and both are semi-decision procedures for this logic. However, they usually employ
unguided learning. Hence, sophisticated heuristics need to be used in addition. Further-
more, resolution and superposition can learn redundant clauses, e.g., clauses that are
subsumed by existing clauses. Thus, explicit and costly checks for non-redundancy need
to be implemented.

More recent approaches, such as the model-evolution calculus [5,6] and model-driven
conflict searches in general [9], build a candidate model. Conflicts to this candidate
model then guide resolution steps, until either a (partial) model or a refutation is found.
This approach is motivated by the success of propositional model-building approaches
in practice, such as DPLL [17] and CDCL (conflict-driven clause learning) [23,27,35]. In
particular, the practical success of propositional CDCL motivates lifting this approach
to first-order logic.

The SCL calculus (“Clause Learning from Simple Models” or short “Simple Clause
Learning”) [12, 14, 16, 22, 26] lifts a conflict-driven clause learning approach to first-
order logic. In its first, original version [22], the focus of the calculus is deciding the
Bernays-Schoenfinkel class without equality. By extending this approach, however, SCL
even yields a decision procedure for any class that enjoys the finite model property.
Moreover, SCL provides a sound and refutationally complete semi-decision procedure
for general first-order logic without equality. Subsequently, SCL has been extended to
handle theories [13,14] and first-order logic with equality [26]. This paper will revisit
classical SCL without equality or theories.

SCL builds a partial ground candidate model on the trail with the *model-building*
rules. Those rules make use of ground literal decisions and ground literal propagations.
If a conflict between the ground trail and an instantiation of a clause is found, the *conflict*
*resolution* process starts. During this process, resolution and factoring is applied to the
conflict. Finally, a backtracking step learns a new non-redundant clause.

Even though all propagations and decisions on the trail are ground, learned clauses
are non-ground in general. Furthermore, it is guaranteed that a newly learned clause is
non-redundant. We call a clause redundant with respect to a clause set if it is already
implied by smaller clauses, where the literal ordering induced by the trail literal ordering
is used to compare clauses. In SCL, all learned clauses are always non-redundant with
respect to our input clause set and previously learned clauses. In practice, this implies that learned clauses do not need to be checked for forward redundancy when adding them to the learned clause set. This makes clause learning in SCL a powerful primitive.

Overall, SCL interleaves the trail-building and conflict resolution rules until either a refutation or a model is found. Similarly to resolution, a clause set is refuted if the empty clause can be learned. The refutational completeness of SCL guarantees that the empty clause is eventually learned for unsatisfiable inputs. For satisfiable clause sets, SCL will build a model on the trail. In general, the bounded model on the trail will be only *partial*. This is in particular the case if the clause set has only infinite models. Such a bounded partial model is not necessarily extendable to a complete model, a challenge that motivates yet another extension of SCL, called HSCL [16]. However, in this work, we present a version of SCL that either proves unsatisfiability or constructs a single partial model on the trail.

In the original work on SCL [22], two measures of regularity were defined, namely “regular runs” and “weakly-regular runs”. In a regular run, exhaustive propagation was required. However, in combination with the ground trail of SCL, this can already lead to exponentially many propagations. For example, consider the following clause set:

$$N = \{R(x_1, \dots, x_n, a, b), P \lor Q, P \lor \neg Q, \neg P \lor Q, \neg P \lor \neg Q\}$$

In the case of exhaustive unit propagation, this example requires propagating $2^n$ different ground instances of $R(x_1, \dots, x_n, a, b)$ before being able to refute the propositional logic clauses. In this example, it is clear that all ground instances of $R(x_1, \dots, x_n, a, b)$ may be ignored. In general, however, this may be not the case. Hence, this motivates a calculus without mandatory propagation in order to learn non-redundant clauses.

The original paper [22] addressed this issue by defining weakly-regular runs. In such runs, unit propagation is treated differently and is not required to be exhaustive. However, all non-unit propagations still need to be applied before any decision can be made. While this mitigates the exponential growth in the above example, more complex examples still exhibit unnecessary exponential trail growth.

This motivates the use of a different regularity measure. The measure used in this work was first presented in [13]. As a key idea, regularity does no longer require exhaustive propagation. Instead, decisions are limited in a way that does not allow conflicts to arise directly after a decision is made. We will show that this regularity, although weaker as the previous definition, is still sufficient to guarantee non-redundant learning (see Lemma 11). Our contribution is to adapt the new regularity definition [13] to the SCL calculus, which includes refining the proofs to the weaker definition of regularity. Furthermore, the variant of the Backtracking rule, Section 4, used in this paper is more explicit compared to [13] because it jumps to the minimal trail where the finally learned clause propagates.

In the original SCL paper [22], no trail bounding was employed at all. Hence, termination is only guaranteed in the case of the underlying logic enjoying the finite model property. Consequently, in the original version, the analysis focused on the impact of SCL for the Bernays-Schoenfinkel fragment, since problems from this fragment are guaranteed to have a finite model.
A contribution of this paper is to use a well-founded ordering $\prec_B$ and a limiting literal $\beta$ instead of a fixed set $B$. We require only finitely many literals to be $\prec_B$-smaller than $\beta$ (a formal definition is in Section 3). Now, as an invariant, we will prove that all considered literals are $\prec_B$-smaller than $\beta$. Hence, only finitely many literals can occur during a SCL run. Thus, we obtain guarantees about finite trails and model sizes, while avoiding the problems of a fixed set of constants. Overall, this definition is used to guarantee termination for the bounded variant of SCL. Completeness is achieved via a new Grow rule that strictly increases $\beta$, see Section 4.

Lastly, this paper contains rigorous proofs that were omitted in the original papers [13, 22, 26] before, as well as some simplified proofs. In particular, this paper includes a full soundness proof of SCL (Theorem 6) and a rigorous correctness proofs (Theorem 10). Further proofs have been simplified, for example the complexity analysis in Theorem 15 and the termination proof (Theorem 16).

The paper is now organized as follows. First, in Section 2, we compare four different approaches to first-order reasoning and put SCL into context. To this end, we introduce classical resolution and superposition. Afterwards, we compare these with more recent approaches, namely the model-evolution search and model-driven conflict searches. In the preliminaries, Section 3, we then briefly introduce the formal notation and definitions used in the main part of this paper. Next, we formally describe the classical SCL calculus for first-order logic without equality in Section 4. First, we give the abstract rewrite rules for the calculus. These rules follow the ones presented in the original SCL paper [22]. However, the rules have been adapted to (i) respect a new clause size measure $\prec_B$ to limit the trail size and guarantee termination of the calculus (ii) directly incorporate our new definition of regularity. Then we give full proofs for the core properties of SCL with respect to the changed definition of the rules. In particular, this includes soundness (Theorem 6), termination (Theorem 16) and non-redundant learning (Theorem 13). Lastly, we will discuss our contributions and potential future work in Section 5.

## 2 Related Work

There has been intensive development on reasoning procedures for first-order logic without equality. In this section, we will compare four different approaches to first-order reasoning.

Traditionally, the work in first-order-logic automated reasoning has focused on proofs. From this perspective, we first introduce resolution and superposition, both of which are refutation-based algorithms which can produce (refutation) proofs, but yield no easily accessible model information in general. Hence, in a prover setting, extracting counterexamples from runs of those algorithms is not straight-forward.

Afterwards, we focus on model-based calculi. These introduce a candidate partial model. This model then guides reasoning, usually in the form of finding an ordering in which resolution inferences are made. As examples for model-bases calculi, we present the model-evolution calculus and the class of model-driven conflict searches. The SCL calculus, which will be detailed after this section, implements a model-driven conflict
search.

Resolution [18, 31, 36] is one of the classical approaches to first-order theorem proving. In the classical resolution calculus, two clauses can produce a new clause (called resolvent) by the resolution rule. For example, the clause $P(x) \lor Q(x)$ together with the clause $\neg P(g(y)) \lor R(y, y)$ produces the resolvent $Q(g(y)) \lor R(y, y)$. Furthermore, resolution requires the concept of factoring for completeness. For example, a clause $R(x, y) \lor P(x) \lor P(g(y))$ can be factorized to $R(g(y), y) \lor P(g(y))$ by unification of $P(x)$ and $P(g(y))$. Exhaustive application of resolution and factoring modulo certain redundancy criteria is called saturation. The most important redundancy criteria in the resolution context are tautology deletion, i.e., deletion of clauses like $R(x, y) \lor P(x) \lor \neg P(x)$, and the deletion of subsumed clauses. For example, the clause $P(x) \lor R(x, y)$ subsumes the clause $P(x) \lor R(x, g(z)) \lor P(z)$ via the substitution $\{y \mapsto g(z)\}$ because $(P(x) \lor R(x, y))\{y \mapsto g(z)\}$ is a subset of $P(x) \lor R(x, g(z)) \lor P(z)$. A clause set without equality can already be saturated by applying only the resolution and factoring rule. In a saturated clause set, no further non-redundant clause can be added. Resolution has refuted the clause set if the empty clause can be derived. In particular, a clause set is unsatisfiable iff the empty clause is in the saturated clause set.

As an example, consider the following (unsatisfiable) clause set:

$$ \{P(a) \lor Q(x), P(f(x)) \lor \neg Q(x), \neg P(x) \lor \neg Q(x), \neg P(f(a)) \lor \neg Q(x)\} $$

Here, a possible resolution refutation could look as follows:

$$
\begin{array}{l}
\begin{array}{l}
P(a) \lor Q(x) \text{ resolved with } \neg P(x) \lor Q(x) \rightsquigarrow Q(x) \lor Q(a) \\
P(f(x)) \lor \neg Q(x) \text{ resolved with } \neg P(f(a)) \lor \neg Q(x) \rightsquigarrow \neg Q(a) \lor \neg Q(x)
\end{array} \\
\text{Factoring on } Q(x) \lor Q(a)\{x \mapsto a\} \rightsquigarrow Q(a) \\
\text{Factoring on } \neg Q(a) \lor \neg Q(x)\{x \mapsto a\} \rightsquigarrow \neg Q(a) \\
Q(a) \text{ resolved with } \neg Q(a) \rightsquigarrow \perp
\end{array}
$$

Resolution is a refutation-based approach. Hence, to prove validity of a formula, a contradiction from the negation of the statement must be derived. By the compactness of first-order logic, for an unsatisfiable clause set such a contradiction is eventually found. This makes resolution a semi-decision procedure for first-order logic without equality. However, in satisfiable cases, no direct approach for extracting a model from the resolution calculus exists. This is a drawback compared to explicit model-building approaches, where (partial) models can be extracted easily.

Furthermore, resolution employs unguided learning. Multiple different inferences can be done at any step in the algorithm, and there are no limits with respect to generating new clauses. While this enables resolution to potentially find optimal inferences which yield very short resolution proofs, there are several downsides to this approach:

First, not limiting inferences leaves the burden of choice to the prover. Hence, resolution-based solvers need a sophisticated heuristic for prioritizing inferences. This is one of the reasons that led to the development of superposition, which is discussed in the next section.
Second and more importantly, redundant clauses may be generated by resolution inferences. For example, consider the same clause set as in the initial example. While we started with a reasonable inference in the initial example, a potential resolution run could also take the following inference:

$$P(x) \lor Q(x) \text{ resolved with } \neg P(x) \lor \neg Q(x) \rightsquigarrow Q(x) \lor \neg Q(x)$$

However, the generated clause does not contribute to any refutation, as it is a tautology. Later in this work, we will formalize a similar concept called *clause redundancy*. In the above example, resolution generated a redundant clause. In general, this can happen also for inferred clauses that are not tautological. Hence, resolution-based provers must check for redundancy whenever a new clause is generated. This can have a significant impact on the runtime of the prover, even though there is active development on efficient subsumption testing [15]. In contrast, SCL avoids this checking entirely by providing native non-redundant learning guarantees. Resolution can be extended to handle equality by adding the equality axioms [3]. Further improvements, subsequently, have been made to exploit the equality axioms for generating smaller clauses. One such example is superposition [2], which refines the idea of paramodulation [30]. With this approach, equalites are oriented and equal atoms in terms can be replaced.

Superposition approaches [2, 4, 7, 25] limit the possible inferences of resolution by employing a fixed *literal ordering*. They were defined originally for first-order logic with equality and their projection to first-order logic without equality considered here is called *ordered resolution*. With respect to the literal ordering, only resolution inferences on maximal literals are permitted. This severely limits the amount of possible inferences, which can significantly speed up saturation. In contrast to resolution there is an abstract concept of redundancy: a clause is redundant and can therefore be eliminated, if it is implied by smaller clauses with respect to the literal ordering. The restriction of resolving only on maximal literals preserves refutational completeness. However, even though there are fewer inferences possible, cases in which multiple inferences are available still occur frequently. Hence, a heuristic for priorization is still necessary. Overall, the order in which inferences are made has a significant impact on the runtime. Moreover, the performance of superposition heavily depends on the used term ordering [19, 33], as it dictates the order of possible inferences. This poses a challenge for an implementation, as such orderings usually must be fixed before starting a superposition run. Furthermore, the problem of inferring redundant clauses persists in superposition. Nonetheless, superposition-based solvers are state-of-the-art for first-order reasoning. During recent CASCs (CADE ATP System Competitions) [37] superposition-based provers have dominated the first-order tracks [21, 24, 32]. Similarly to resolution, superposition can be extended to handle first-order logic with equality. Most state-of-the-art provers include equational reasoning to support first-order logic with equality.

An alternative to resolution-based reasoning is formed by model-based approaches. This is motivated by the good practical performance of DPLL [17] in propositional logic. In DPLL, the resolution technique is replaced by splitting on literals. On the respective literal, a case analysis is then performed: the possibility of it being false or
true are investigated separately. This can also be understood as “guessing” or deciding
the specific literal. The model-evolution calculus [6] lifts this approach to first-order
logic. In the model-evolution calculus, contexts are introduced. A context always forms
a candidate model for the input clauses. On conflicts, the model is “evolved” by splitting
on conflicting literals. One key challenge is an efficient handling of clause splitting. In
particular, in contrast to propositional logic, a single first-order clause represents all its
ground instances. Hence, when splitting $P(x)$, both a branch $P(x)$ (for $\forall x P(x)$) and
a branch $\neg P(c)$ (for $\neg \forall x P(x)$) need to be produced. In particular, note that a new
(skolemized) variable is introduced in the existential case. The model-evolution calculus
introduces techniques to handle splitting efficiently, by storing additional information
about existential variables in a context.

Another instance of a model-building reasoning approach is NRCL (Non-Redundant Clause Learning) [1]. Actually, this is the predecessor of SCL with the main difference that model building in NRCL is more complex, because also non-ground literals are propagated. This then results in more complex algorithms for propagation or false clause detection, similar to [29].

Most propositional solvers currently use variants of propositional CDCL [23,35] instead
of DPLL. Motivated by the success of CDCL solvers in practice [34], there are approaches
of lifting such algorithms to the first-order case. Such a lifting preserves the general ideas
of CDCL: First, a *trail* of literals is built. The trail forms a candidate model and must
always be consistent in itself. The algorithm then assumes that all literals on the trail
are true, whereas literals not on the trail are undefined. Then, the trail is extended
until either a model is found, or a *conflict* arises. This happens when a clause becomes
false under the literals in the trail. Such a conflict is then *resolved* until a new clause is
learned. Compared to superposition, this approach allows choosing resolution inferences
without an a priori ordering. Instead, inferences are guided by the model assumptions
on the trail. In this approach, model extraction is straight-forward, as a (partial) model
is always present on the trail in case of a non-active conflict. This technique is employed
by the SCL calculus. Furthermore, there is active development on the first-order SGGS
calculus (Semantically-Guided Goal-Sensitive Reasoning) [10], which also implements a
model-driven search. However, the strong non-redundant clause learning guarantees of
SCL are not provided by SGGS. Another key difference in the design of both calculi is
that SCL employs a ground trail whereas SGGS can add non-ground literals to the trail.
While this makes the trail representation of SGGS more compact and powerful, this
comes at the cost of more expensive unification steps for propagation, conflict detection
and resolution.

# 3 Preliminaries

The general notation and definitions follow the original SCL paper [22]. We assume a
first-order language without equality where *N* denotes a clause set; *C*, *D* denote clauses;
*L*, *K*, *H* denote literals; *A*, *B* denote atoms; *P*, *Q*, *R* denote predicates; *t*, *s* terms; *f*, *g*, *h*
function symbols; *a*, *b*, *c* constants; and *x*, *y*, *z* variables. Atoms, literals, clauses and
clause sets are considered as usual, where in particular clauses are identified both with
their disjunction and multiset of literals. The complement of a literal is denoted by the
function comp. Semantic entailment $|=$ is defined as usual where variables in clauses
are assumed to be universally quantified. Substitutions $\sigma, \tau$ are total mappings from
variables to terms, where $dom(\sigma) := \{x | x\sigma \neq x\}$ is finite and $codom(\sigma) := \{t | x\sigma = t, x \in dom(\sigma)\}$. Their application is extended to literals, clauses, and sets of such objects
in the usual way. A term, atom, clause, or a set of these objects is ground if it does not
contain any variable. A substitution $\sigma$ is ground if $codom(\sigma)$ is ground. A substitution
$\sigma$ is grounding for a term $t$, literal $L$, clause $C$ if $t\sigma, L\sigma, C\sigma$ is ground, respectively.
The function mgu denotes the most general unifier of two terms, atoms, literals. We
assume that any mgu of two terms or literals does not introduce any fresh variables and
is idempotent. A closure is denoted as $C \cdot \sigma$ and is a pair of a clause $C$ and a grounding
substitution $\sigma$. The function gnd returns the set of all ground instances of a literal,
clause, or clause set with respect to the signature of the respective clause set.

Let $\prec$ denote a well-founded, total, strict ordering on ground literals. This ordering is then lifted to clauses and clause sets by its respective multiset extension. We overload $\prec$ for literals, clauses, clause sets if the meaning is clear from the context. The ordering is lifted to the non-ground case via instantiation: we define $C \prec D$ if for all grounding substitutions $\sigma$ it holds $C\sigma \prec D\sigma$. We define $\preceq$ as the reflexive closure of $\prec$ and $N^{\preceq C} := \{D \mid D \in N \text{ and } D \preceq C\}$.

**Definition 1 (Clause Redundancy).** A ground clause *C* is redundant *with respect to a ground clause set* *N* and an order $\prec$ if $N^{\prec C} \models C$ or $C \in N$. A clause *C* is redundant *with respect to a clause set* *N* and an order $\prec$ if for all $C' \in \text{gnd}(C)$ it holds that $C'$ is redundant *with respect to* $\text{gnd}(N)$.

For the sake of bounding, let $\prec_B$ denote a well-founded, total, strict ordering on ground atoms such that for any ground atom $A$ there are only finitely many ground atoms $B$ with $B \prec_B A$ [16]. For example, an instance of such an ordering could be KBO without zero-weight symbols. The ordering $\prec_B$ is lifted to literals by comparing the respective atoms. It is lifted to clauses by a multiset extension. Given an ordering $\prec_B$ and a ground literal $\beta$, the function $\text{gnd}^{\prec_B \beta}$ computes the set of all ground instances of a literal, clause, or clause set where the grounding is restricted to produce literals $L$ with $L \prec_B \beta$.

A ground clause *C* is true in a model *M*, denoted *M* |= *C*, if *C* ∩ *M* ≠ ∅, and false otherwise. A ground clause set *N* is true in *M*, denoted *M* |= *N* if all clauses from *N* are true in *M*.

4 SCL Rules and Properties

The presentation of the SCL rules and properties is following the original SCL pre-
sentation [22]. However, the SCL rules have been modified to incorporate a different
regularity measure, which was first presented in [13]. Furthermore, the rules of the given
SCL calculus are changed to support a bounding of the trail size. To this extent, we use
a limiting literal $\beta$ and a well-founded ordering $\prec_B$ which restricts all considered literals.
After the presentation of the SCL rules, we prove the key properties of SCL. These properties include soundness (Theorem 6), refutational completeness (Theorem 17), termination (Theorem 16) and non-redundant clause learning (Theorem 13). In particular, contributions of this paper are a full soundness proof, a rigorous correctness proofs (Theorem 10), as well as simplifications of the other proofs. Furthermore, all properties and proofs have been refined to adhere to the changed regularity definition as well as trail bounding.

The inference rules of SCL are represented by an abstract rewrite system. They operate on a problem state, a six-tuple $(\Gamma; N; U; \beta; k; D)$ where $\Gamma$ is a sequence of annotated ground literals, the *trail*; $N$ and $U$ are the sets of *initial* and *learned* clauses; $\beta$ is a ground literal limiting the size of the *trail*; $k$ counts the number of decisions; and $D$ is a status closure that is either true $\top$, false $\bot$, or $C \cdot \sigma$. Literals in $\Gamma$ are either annotated with a number, also called a level; i.e., they have the form $L^k$ meaning that $L$ is the $k$-th guessed decision literal, or they are annotated with a closure that propagated the literal to become true. A ground literal $L$ is of *level i* with respect to a problem state $(\Gamma; N; U; \beta; k; D)$ if $L$ or $comp(L)$ occurs in $\Gamma$ and the first decision literal left from $L$ ($comp(L)$) in $\Gamma$, including $L$, is annotated with $i$. If there is no such decision literal then its level is zero. A ground clause $D$ is of *level i* with respect to a problem state $(\Gamma; N; U; \beta; k; D)$ if $i$ is the maximal level of a literal in $D$. the level of the empty clause $\bot$ is 0. Recall $D$ is a non-empty closure or $\top$ or $\bot$. Similarly, a *trail* $\Gamma$ is of level $i$ if the maximal literal in $\Gamma$ is of level $i$.

A literal $L$ is *undefined* in $\Gamma$ if neither $L$ nor $comp(L)$ occur in $\Gamma$. We omit annotations to trail literals if they play no role in the respective context. Initially, the state for a first-order clause set $N$ is $(\epsilon; N; \emptyset; \beta; 0; \top)$.

The rules for conflict search are:

**Propagate** $(\Gamma; N; U; \beta; k; \top) \Rightarrow_{SCL} (\Gamma, L\sigma^{(C_0 \lor L)\delta \cdot \sigma}; N; U; \beta; k; \top)$

provided $C \lor L \in (N \cup U)$, $C = C_0 \lor C_1$, $C_1\sigma = L\sigma \lor \dots \lor L\sigma$, $C_0\sigma$ does not contain $L\sigma$, $\delta$ is the mgu of the literals in $C_1$ and $L$, $(C \lor L)\sigma$ is ground, $(C \lor L)\sigma \prec_B \{\beta\}$, $C_0\sigma$ is false under $\Gamma$, and $L\sigma$ is undefined in $\Gamma$

The rule Propagate applies exhaustive factoring to the propagated literal with respect to the grounding substitution $\sigma$ and annotates the factored clause to the propagation literal on the *trail*.

**Decide** $(\Gamma; N; U; \beta; k; \top) \Rightarrow_{SCL} (\Gamma, L\sigma^{k+1}; N; U; \beta; k+1; \top)$

provided $L \in C$ for a $C \in (N \cup U)$, $L\sigma$ is a ground literal undefined in $\Gamma$, and $L\sigma \prec_B \beta$

**Conflict** $(\Gamma; N; U; \beta; k; \top) \Rightarrow_{SCL} (\Gamma; N; U; \beta; k; D \cdot \sigma)$

provided $D \in (N \cup U)$, $D\sigma$ false in $\Gamma$ for a grounding substitution $\sigma$

These rules construct a (partial) model via the *trail* $\Gamma$ for $N \cup U$ until a conflict, i.e., a false clause with respect to $\Gamma$ is found. The above rules always terminate, because
there are only finitely many ground literals K with $K \prec_B \beta$. Choosing an appropriate $\beta$ is sufficient for completeness for certain first-order fragments, e.g. the BS fragment. In particular, for any fragment with the finite model property, completeness can be achieved with SCL for appropriate $\beta$. In general, a rule Grow [22], see below, increasing $\beta$ is needed for full first-order completeness. In the special case of a unit clause L, the rule Propagate actually annotates the literal L with a closure of itself. So the propagated literals on the trail are annotated with the respective propagating clause and the decision literals with the respective level. If a conflict is found, it is resolved by the rules below. Before any Resolve step, we assume that the respective clauses are renamed such that they do not share any variables and that the grounding substitutions of closures are adjusted accordingly.

**Skip** $(\Gamma, L; N; U; \beta; k; D \cdot \sigma) \Rightarrow_{SCL} (\Gamma; N; U; \beta; k - i; D \cdot \sigma)$

provided $comp(L)$ does not occur in $D\sigma$, if $L$ is a decision literal then $i = 1$, otherwise $i = 0$

**Factorize** $(\Gamma; N; U; \beta; k; (D \lor L \lor L') \cdot \sigma) \Rightarrow_{SCL} (\Gamma; N; U; \beta; k; (D \lor L)\eta \cdot \sigma)$

provided $L\sigma = L'\sigma$, $\eta = \text{rgu}(L, L')$

**Resolve** $(\Gamma, L\delta^{(C\lor L)\cdot\delta}; N; U; \beta; k; (D \lor L') \cdot \sigma) \Rightarrow_{SCL} (\Gamma, L\delta^{(C\lor L)\cdot\delta}; N; U; \beta; k; (D \lor C)\eta \cdot \sigma\delta)$

provided $L\delta = \text{comp}(L'\sigma)$, $\eta = \text{rgu}(L, \text{comp}(L'))$

**Backtrack** $(\Gamma_0, K, \Gamma_1, \text{comp}(L\sigma)^k; N; U; \beta; k; (D \lor L) \cdot \sigma) \Rightarrow_{SCL} (\Gamma_0; N; U \cup \{D \lor L\}; \beta; j; \top)$

provided $D\sigma$ is of level $i' < k$, and $\Gamma_0, K$ is the minimal trail subsequence such that there is a grounding substitution $\tau$ with $(D \lor L)\tau$ is false in $\Gamma_0, K$ but not in $\Gamma_0$, and $\Gamma_0$ is of level $j$

Please note that it is not always sufficient to backtrack to the smallest decision level from which $(D \lor L) \cdot \sigma$ can propagate (i.e., the case where $\tau = \sigma$ and $i' = j$). The reason is that there might be other groundings $\tau$ for which $(D \lor L) \cdot \tau$ is now conflicting at level $i'$ due to Resolve and Factorize steps. Therefore, SCL backtracks to the smallest decision level from which $(D \lor L)$ can propagate for any grounding $\tau$. The clause $D \lor L$ added by the rule Backtrack to $U$ is called a *learned clause*. The empty clause $\perp$ can only be generated by rule Resolve or be already present in $N$, hence, as usual for CDCL style calculi, the generation of $\perp$ together with the clauses in $N \cup U$ represent a resolution refutation.

**Example 2.** For example, consider the following clause set:

$$N = \left\{ \begin{array}{ll} C_1 = P(x) \lor Q(b), & C_2 = P(x) \lor \neg Q(y), \\ C_3 = \neg P(a) \lor Q(x), & C_4 = \neg P(x) \lor \neg Q(b) \end{array} \right\}$$
To refute this clause set, we choose $\beta = R(b)$ and $\prec_B$ is a LPO with precedence $a \prec b \prec P \prec Q \prec R$. Hence, it holds that $\{P(a), P(b), Q(a), Q(b)\} \prec_B \{\beta\}$. A possible SCL refutation for $N$ could look as follows:

$$
\begin{array}{l@{\quad}l@{\quad}l}
(\varepsilon; N; \emptyset; \beta; 0; \top) & \\
\Rightarrow^{\text{Decide}} & (\neg P(a)^1; N; \emptyset; \beta; 1; \top) & \\
\Rightarrow^{\text{Propagate}} & (\neg P(a)^1 \neg Q(b)^{C_2 \cdot \{x \mapsto a, y \mapsto b\}}; N; \emptyset; \beta; 1; \top) & \\
\Rightarrow^{\text{Conflict}} & (\neg P(a)^1 \neg Q(b)^{C_2 \cdot \{x \mapsto a, y \mapsto b\}}; N; \emptyset; \beta; 1; P(x) \lor Q(b) \cdot \{x \mapsto a\}) & \\
\Rightarrow^{\text{Resolve}} & (\neg P(a)^1 \neg Q(b)^{C_2 \cdot \{x \mapsto a, y \mapsto b\}}; N; \emptyset; \beta; 1; P(x) \lor P(x) \cdot \{x \mapsto a, y \mapsto b\}) & \\
\Rightarrow^{\text{Factorize}} & (\neg P(a)^1 \neg Q(b)^{C_2 \cdot \{x \mapsto a, y \mapsto b\}}; N; \emptyset; \beta; 1; P(x) \cdot \{x \mapsto a, y \mapsto b\}) & \\
\Rightarrow^{\text{Skip}} & (\neg P(a)^1; N; \emptyset; \beta; 1; P(x) \cdot \{x \mapsto a, y \mapsto b\}) & \\
\Rightarrow^{\text{Backtrack}} & (\varepsilon; N; \{P(x)\}; \beta; 0; \top) & \\
\Rightarrow^{\text{Propagate}} & (P(a)^{P(x) \cdot \{x \mapsto a\}}; N; \{P(x)\}; \beta; 0; \top) & \\
\Rightarrow^{\text{Propagate}} & (P(a)^{P(x) \cdot \{x \mapsto a\}} Q(b)^{C_3 \cdot \{x \mapsto b\}}; N; \{P(x)\}; \beta; 0; \top) & \\
\Rightarrow^{\text{Conflict}} & (P(a)^{P(x) \cdot \{x \mapsto a\}} Q(b)^{C_3 \cdot \{x \mapsto b\}}; N; \{P(x)\}; \beta; 0; \neg P(x) \lor \neg Q(b) \cdot \{x \mapsto a\}) & \\
\Rightarrow^{\text{Resolve}} & (P(a)^{P(x) \cdot \{x \mapsto a\}} Q(b)^{C_3 \cdot \{x \mapsto b\}}; N; \{P(x)\}; \beta; 0; \neg P(x) \lor \neg P(a) \cdot \{x \mapsto a\}) & \\
\Rightarrow^{\text{Skip}} & (P(a)^{P(x) \cdot \{x \mapsto a\}}; N; \{P(x)\}; \beta; 0; \neg P(x) \lor \neg P(a) \cdot \{x \mapsto a\}) & \\
\Rightarrow^{\text{Factorize}} & (P(a)^{P(x) \cdot \{x \mapsto a\}}; N; \{P(x)\}; \beta; 0; \neg P(a) \cdot \{x \mapsto a\}) & \\
\Rightarrow^{\text{Resolve}} & (P(a)^{P(x) \cdot \{x \mapsto a\}}; N; \{P(x)\}; \beta; 0; \bot \cdot \{x \mapsto a\}) & \\
\end{array}
$$

Note the resolution steps are guided by the trail, but always happen between the non-ground original clauses. This allows SCL to learn the non-ground unit clause $P(x)$ in this derivation.

The rules for SCL are applied in a don't-care style, hence, the calculus offers freedom with respect to factorization. Literals in the conflict clause can, but do not have to be factorized. In particular, the Factorize rule may remove duplicate literals. This freedom can result in different learned clauses, see Example 3. The rule Resolve does not remove the literal resolved upon from the trail. Actually, Resolve is applied as long as the rightmost propagated trail literal occurs in the conflict clause. This literal is eventually removed by rule Skip from the trail.

**Example 3.** For example, consider the clause set

$$
N = \left\{ \begin{array}{l} D = Q \lor R(a, y) \lor R(x, b) \\ C = Q \lor S(x, y) \lor P(x) \lor P(y) \lor \neg R(x, y) \end{array} \right\}
$$

and a problem state:

$$ ([\neg P(a)^1, \neg P(b)^2, \neg S(a, b)^3, \neg Q^4, \neg R(a, b)^{C \cdot \{x \mapsto a, y \mapsto b\}}]; N; \emptyset; \neg R(b, b); 4; \top) $$

derived by SCL. We assume $\neg R(b, b)$ to the largest literal among all ground instances of $P, S, Q, R$ literals over the constants $a, b$. The rule Conflict is applicable and yields
the conflict state

$$ (\neg P(a)^1, \neg P(b)^2, \neg S(a, b)^3, \neg Q^4, R(a, b)^{C \cdot \{x \mapsto a, y \mapsto b\}}; \\ N; \emptyset; \neg R(b, b); 4; D \cdot \{x \mapsto a, y \mapsto b\}) $$

from which we can either learn the clause

$$ C_1 = Q \lor S(x, b) \lor P(x) \lor P(b) \lor S(a, y) \lor P(a) \lor P(y) $$

or the clause

$$ C_2 = Q \lor S(a, b) \lor P(a) \lor P(b) $$

depending on whether we first resolve or factorize. Note that $C_2$ does not subsume $C_1$. Both clauses are non-redundant. In order to learn $C_1$ we need to resolve twice with $R(a, b)^{C \cdot \{x \mapsto a, y \mapsto b\}}$.

The first property we prove about SCL is soundness. We prove it via the notion of a sound state.

**Definition 4 (Sound States).** A state $(\Gamma; N; U; \beta; k; D)$ is sound if the following conditions hold:

1. $\Gamma$ is a consistent sequence of annotated ground literals, i.e. for a ground literal $L$ it cannot be that $L \in \Gamma$ and $\neg L \in \Gamma$

2. for each decomposition $\Gamma = \Gamma_1, L\sigma^{C \lor L \cdot \sigma}, \Gamma_2$ we have that $C\sigma$ is false under $\Gamma_1$ and $L\sigma$ is undefined under $\Gamma_1$, and $N \cup U \models C \lor L$,

3. for each decomposition $\Gamma = \Gamma_1, L^k, \Gamma_2$ we have that $L$ is undefined in $\Gamma_1$,

4. $N \models U$,

5. if $D = C \cdot \sigma$ then $C\sigma$ is false under $\Gamma$ and $N \models C$. In particular, $\text{gnd}^{<B\beta}(N) \models C\sigma$,

6. for any $L \in \Gamma$ we have $L <_B \beta$ and there is a $C \in N \cup U$, $L' \in C$, and a grounding $\sigma$ such that $L'\sigma = L$.

To show soundness of SCL, we first show soundness of the initial state. Then, we show that all SCL rule applications preserve soundness, which shows soundness of the overall calculus starting from the initial state.

**Lemma 5 (Soundness of the initial state).** The initial state $(\epsilon; N; \emptyset; \beta; 0; \top)$ is sound.

*Proof.* Criteria 1–3 and 6 are trivially satisfied by $\Gamma = \epsilon$. Furthermore, $N \models \emptyset$, fulfilling criterion 4. Lastly, criterion 5 is trivially fulfilled for $D = \top$. $\square$

**Theorem 6 (Soundness of SCL).** All SCL rules preserve soundness, i.e. they map a sound state onto a sound state.
*Proof.* As the hypothesis, assume that a state $(\Gamma; N; U; \beta; k; D)$ is sound. We show that any application of a rule results again in a sound state.

$\Rightarrow^{\text{Decide}}_{\text{SCL}}$. Assume Decide is applicable to $(\Gamma; N; U; \beta; k; D)$, yielding a resulting state $(\Gamma, L\sigma^{k+1}; N; U; \beta; k+1; D)$. Then there is a $L \in C$ for $C \in N \cup U$, $L\sigma$ is ground and undefined in $\Gamma$, and $L\sigma \prec_B \beta$. Also, there can be no active conflict, i.e. $D = \top$.

1, 3 By the precondition, $L\sigma$ is undefined in $\Gamma$ (3). Hence, adding $L\sigma$ does not make $\Gamma$ inconsistent (1).

2, 4 Trivially fulfilled by hypothesis.

5 Since $D = \top$, the rule is trivially satisfied.

6 For all literals $L'\sigma' \in \Gamma$, this holds by hypothesis. For $L\sigma$ this follows directly from the preconditions of the rule.

$\Rightarrow^{\text{Propagate}}_{\text{SCL}}$. Assume Propagate is applicable to $(\Gamma; N; U; \beta; k; D)$, yielding a resulting state $(\Gamma, L\sigma^{(C_0 \lor L)\delta \cdot \sigma}; N; U; \beta; k; D)$. Then, there is a $C \lor L \in (N \cup U)$ such that $C = C_0 \lor C_1$, $C_1\sigma = L\sigma \lor \dots \lor L\sigma$, $C_0\sigma$ does not contain $L\sigma$, $\delta$ is the mgu of the literals in $C_1$ and $L$, $(C \lor L)\sigma$ is ground, $(C \lor L)\sigma \prec_B \{\beta\}$, $C_0\sigma$ is false under $\Gamma$, and $L\sigma$ is undefined in $\Gamma$. Also, there can be no active conflict, i.e. $D = \top$.

1, 3 By the precondition, $L\sigma$ is undefined in $\Gamma$ (3). Hence, adding $L\sigma^{(C_0 \lor L)\delta \cdot \sigma}$ does not make $\Gamma$ inconsistent (1).

2 Consider any decomposition $\Gamma$, $L\sigma^{(C_0 \lor L)\delta \cdot \sigma} = \Gamma_1, L'\sigma' C'_0 \lor L' \cdot \sigma'$, $\Gamma_2$. In the case of $L'\sigma \neq L\sigma$, we can apply the hypothesis for the state $(\Gamma; N; U; \beta; k; D)$. Hence, only the case $\Gamma_1 = \Gamma$, $L'\sigma' = L\sigma$, and $C'_0\sigma = C_0\sigma$ is left to prove.

First, note that $C_0\sigma$ is false under $\Gamma_1 = \Gamma$ by the preconditions. Also, $L\sigma$ must be undefined in $\Gamma$ by the preconditions. Lastly, it needs to be shown that $N \cup U \models (C_0 \lor L)\delta$. Clearly, since $C \lor L \in (N \cup U)$, it holds that $N \cup U \models C \lor L$. Since $C = C_0 \lor C_1$ and $C_1\sigma = L\sigma \lor \dots \lor L\sigma$ it follows from the soundness of first-order factorization that $C \models (C_0 \lor L)$ and by this $N \cup U \models C_0 \lor L$.

4 Follows trivially from the induction hypothesis.

5 Since $D = \top$, this rule is trivially satisfied.

6 For all literals $L'\sigma' \in \Gamma$, this holds by hypothesis. For $L\sigma$, consider the precondition that $(C \lor L)\sigma \prec_B \{\beta\}$. By the definition of the multiset extension of $\prec_B$, it follows that $L\sigma \prec_B \beta$ must hold as well.

$\Rightarrow^{\text{Conflict}}_{\text{SCL}}$. Assume Conflict is applicable to $(\Gamma; N; U; \beta; k; D)$, yielding a resulting state $(\Gamma; N; U; \beta; k; C \cdot \sigma)$. Then, there is a $C \in (N \cup U)$ such that $C\sigma$ is false in $\Gamma$ for a grounding $\sigma$.

1-3 Trivially fulfilled by hypothesis, as the trail $\Gamma$ is not modified.
4 Follows trivially from the induction hypothesis, as neither $N$ nor $U$ are modified.

5 It holds that $D = C \cdot \sigma$. By the preconditions of Conflict, $C\sigma$ must be false under $\Gamma$. Furthermore, since $C \in (N \cup U)$ it holds that $N \cup U \models C$. Since $N \models U$ by soundness (4), it also holds that $N \models C$. Lastly, it remains to show that $\text{gnd}^{<B\beta}(N) \models C\sigma$. By soundness (6), we know that for all literals $L\mu \in \Gamma$ it holds that $L\mu <_B \beta$. Since $C\sigma$ is false in $\Gamma$, it must hold that all literals in $C\sigma$ are also <$_B \beta$. Combined with $N \models C$, this yields that $\text{gnd}^{<B\beta}(N) \models C\sigma$.

6 Fulfilled by the hypothesis, since no literal is added to $\Gamma$.

⇒<sub>SCL</sub><sup>Skip</sup>. Assume Skip is applicable to (Γ = Γ', L; N; U; β; k; D · σ), yielding a resulting state (Γ'; N; U; β; k − i; D · σ). By the preconditions of skip, it must hold that comp(L) does not occur in Dσ, and if L is a decision literal then i = 1 else i = 0.

1-3, 6 Directly fulfilled by hypothesis, as all prefixes of Γ still fulfil all properties. In particular, this holds for the prefix Γ' of Γ.

4 Follows trivially from the induction hypothesis, as $U$ is not modified.

5 After the application of Skip, $D \cdot \sigma$ is the current conflict. Since $D$ is not modified, $N \models D$ and $\text{gnd}^{<B\beta}(N) \models D\sigma$ by hypothesis. It is left to show that $D\sigma$ is false under the resulting $\Gamma'$, given the assumption that $D\sigma$ is false under $\Gamma$. However, since $\text{comp}(L) \notin D\sigma$, this is trivially fulfilled, as the removal of $\text{comp}(L)$ from the trail $\Gamma$ cannot make $D\sigma$ undefined. Hence, $D\sigma$ must be false under $\Gamma'$ as well.

⇒<sub>SCL</sub><sup>Factorize</sup>. Assume Factorize is applicable to (Γ; N; U; β; k; (D ∨ L ∨ L') · σ), yielding a resulting state (Γ; N; U; β; k; (D ∨ L)η · σ). Then, Lσ = L'σ and η = mgu(L, L').

1-3, 6 Trivially fulfilled by hypothesis, as the trail $\Gamma$ is not modified.

4 Follows trivially from the induction hypothesis, as $U$ is not modified.

5 After the application of Factorize, $(D \lor L)\eta \cdot \sigma$ is the current conflict. By the hypothesis $N \models (D \lor L \lor L')$. From the preconditions of Factorize, $L\sigma = L'\sigma$ and $\eta = \text{mgu}(L, L')$. Thus, $(D \lor L \lor L')\eta$ is an instance of $(D \lor L \lor L')$ and $N \models (D \lor L \lor L')\eta$. Since $L\eta = L'\eta$, $(D \lor L \lor L')\eta \models (D \lor L')\eta$. Thus, $N \models (D \lor L)\eta$. By the preconditions, $\text{gnd}^{<B\beta}(N) \models \text{gnd}^{<B\beta}((L \lor L \lor L')\sigma)$. Hence, $(D \lor L \lor L')\sigma <_B \{\beta\}$. Thus, $(D \lor L)\eta\sigma = (D \lor L)\sigma <_B \{\beta\}$. From this, it follows that $\text{gnd}^{<B\beta}(N) \models \text{gnd}^{<B\beta}((D \lor L)\sigma)$.

Furthermore, $(D \lor L)\eta\sigma$ is false under $\Gamma$, since $(D \lor L)\eta\sigma = (D \lor L)\sigma$ by the definition of an mgu, and $(D \lor L \lor L')\sigma$ is already false under $\Gamma$.

⇒<sub>SCL</sub><sup>Resolve</sup>. Assume the rule Resolve is applicable to an SCL state of the shape (Γ = Γ', Lδ<sup>(C<sub>\L\D</sub>)·δ</sup>; N; U; β; k; (D ∨ L') · σ), yielding a resulting state (Γ; N; U; β; k; (D ∨ C)η · σδ). By the preconditions of Resolve, it holds that Lδ = comp(L'σ) and η = mgu(L, comp(L')).
1-3, 6 Trivially fulfilled by hypothesis, as the trail Γ is not modified.

4 Follows trivially from the induction hypothesis, as $U$ is not modified.

5 After the application of Resolve, $(D \lor C)\eta \cdot \sigma\delta$ is the current conflict.

By the hypothesis, $(D \lor L')\sigma$ is false under $\Gamma$. In particular, $D\sigma$ is false under $\Gamma$. By soundness (2), we know that $C\delta$ must be false under $\Gamma$ as well. Hence, $(D \lor C)\eta\sigma\delta$ is false under $\Gamma$.

Furthermore, by the hypothesis, $N \models (D \lor L')$. Since $(D \lor L')\eta$ is an instance of $(D \lor L')$, it holds that $N \models (D \lor L')\eta$. Furthermore, by soundness (2) we know that $N \cup U \models (C \lor L)$ and by soundness (4) this implies that $N \models (C \lor L)\eta$. With similar argumentation, also $N \models (C \lor L)\eta$. By the soundness of resolution, this implies $N \models (D \lor C)\eta$.

Lastly, since $(D \lor L')\sigma$ is false in $\Gamma$, all occuring literals in $\{(D \lor L')\sigma\} \prec_B \{\beta\}$. With similar argumentation, $\{(C \lor L)\delta\} \prec_B \{\beta\}$. Hence, in particular, $(D \lor C)\eta\sigma\delta \prec_B \{\beta\}$ and, thus, $\text{gnd}^{<B\beta}(N) \models \text{gnd}^{<B\beta}((D \lor C)\eta\sigma\delta)$.

$\Rightarrow_{\text{SCL}}^{\text{Backtrack}}$. Assume the rule Backtrack is applicable to a SCL state of shape $(\Gamma = \Gamma_0, K, \Gamma_1; N; U; \beta; k; (D \lor L) \cdot \sigma)$, yielding the resulting SCL state $(\Gamma_0, K; N; U \cup \{D \lor L\}; \beta; k'; \top)$.

1-3, 6 Directly fulfilled by hypothesis, as all prefixes of $\Gamma$ still fulfil all properties. In particular, this holds for the prefix $\Gamma_0, K$ of $\Gamma$.

4 By the hypothesis, we know that $N \models U$. By soundness (5) we know that $N \models (D \lor L)$. Overall, $N \models U \cup \{D \lor L\}$

5 Since after an application of Backtrack the conflict is resolved, i.e. $D = \top$, the rules are trivially satisfied. □

<figure><img src="image_2.png" /></figure>

**Corollary 7.** The rules of SCL are sound, hence SCL starting with an initial state is sound.

*Proof.* Follows by induction over the size of the run. The base case is handled by Lemma 5, the induction step is contained in Theorem 6. □

<figure><img src="image_3.png" /></figure>

Next we introduce reasonable and regular runs. Note that the following definitions are now changed. The new definitions have been adapted from [13] to fit the classical SCL calculus. As an overall goal, we will show that regular runs always generate non-redundant clauses

**Definition 8 (Reasonable Runs).** A sequence of SCL rule applications is called a reasonable run if the rule Decide does not enable an immediate application of rule Conflict.
**Definition 9 (Regular Runs).** A sequence of SCL rule applications is called a regular run if it is a reasonable run and the rule Conflict has precedence over all other rules.

**Theorem 10 (Correct Termination).** If in a regular run no rules are applicable to a state $(\Gamma; N; U; \beta; k; D)$ then either $D = \perp$ and $N$ is unsatisfiable or $D = \top$ and $\text{gnd}(N)^{<B\beta}$ is satisfiable and $\Gamma \models \text{gnd}(N)^{<B\beta}$.

*Proof.* For a state $(\Gamma; N; U; \beta; k; D)$ where $D \notin \{\top, \perp\}$, one of the rules Resolve, Skip, Factorize or Backtrack is applicable. If the top level literal is a propagated literal then either Resolve or Skip are applicable. If the top level literal is a decision then one of the rules Skip, Backtrack, or Factorize is applicable. In the case $D = \top$ and Decide is not applicable by regularity, Propagate can always be applied instead. If $D = \top$ and all Propagate, Decide, and Conflict are not applicable it means that there are no undefined ground literals $L <_B \beta$ in $\Gamma$, so $\Gamma \models \text{gnd}(N)^{<B\beta}$.

□

**Lemma 11 (Resolve in regular runs).** Consider the derivation of a conflict state $(\Gamma, L; N; U; \beta; k; \top) \Rightarrow_{\text{Conflict}} (\Gamma, L; N; U; \beta; k; D)$. In a regular run, during conflict resolution $L$ is not a decision literal and at least the literal $L$ is resolved.

*Proof.* There are three ways how a reasonable run can reach a state $(\Gamma, L; N; U; \beta; k; \top)$: either by an application of the rule Decide, Backtrack, or Propagate. In a reasonable run, if the rule Decide has produced the SCL state $(\Gamma, L; N; U; \beta; k; \top)$, the rule Conflict is not immediately applicable. In case the rule Backtrack produced the state $(\Gamma, L; N; U; \beta; k; \top)$ there is the sequence of rule applications

$$ \begin{array}{l} (\Gamma, L, L', \Gamma_1, K^{k+1}, \Gamma_2, \text{comp}(L''\sigma)^{k'}; N; U'; \beta; k'; (D \lor L'') \cdot \sigma) \\ \Rightarrow_{\text{SCL}} (\Gamma, L; N; U' \cup (D \lor L''); \beta; k; \top) \end{array} $$

Then, by the definition of Backtrack, the newly learned clause $(D \lor L'')$ cannot be false with respect to $\Gamma, L$. This also means that any clause in $N \cup U'$ can also not be false with respect to $\Gamma, L$: (i) either it would have been present the last time when the run visited a state with trail $\Gamma, L$ and in a reasonable run this means that the rule Conflict should have been applied at that point and prevented any further exploration of the trail prefix $\Gamma, L$ or (ii) it was learned afterwards via the rule Backtrack in a state with the trail prefix $\Gamma, L$; however, this would contradict the previously proven fact that Backtrack always jumps to a trail prefix where the newly learned clause cannot be false anymore. Hence, in a reasonable run the rules Decide and Backtrack are never applied right before the rule Conflict. In summary, $L$ must be a propagated literal if Conflict is applicable to $(\Gamma, L; N; U; \beta; k; \top)$ from a regular run.

Backtrack is not directly applicable to $(\Gamma, L; N; U; \beta; k; D)$, as it requires $L$ to be a decision literal. Furthermore, $L$ must occur in the conflict clause $D$. Otherwise, Conflict could have been applied earlier to $(\Gamma; N; U; \beta; k; \top)$, contradicting regularity. Hence, Skip is not applicable to our state. Overall, only Factorize and Resolve can possibly be applied to our state. After an application of Factorize, the two invariants still hold:
First, the trail is not modified. Second, $L$ must still occur in the conflict clause $D$, as Factorize cannot remove all instances of $L$ from $D$. Hence, Factorize cannot enable any of the rules Skip or Backtrack. Following from that, at least one application of Resolve must take place in conflict resolution. □

**Definition 12** (State Induced Ordering). Let $(L_1, L_2, \dots, L_n; N; U; \beta; k; D)$ be a sound state of SCL. The trail induces a total well-founded strict order on the defined literals by
$$L_1 \prec_{\Gamma} \text{comp}(L_1) \prec_{\Gamma} L_2 \prec_{\Gamma} \text{comp}(L_2) \prec_{\Gamma} \dots \prec_{\Gamma} L_n \prec_{\Gamma} \text{comp}(L_n).$$

We extend $\prec_{\Gamma}$ to a strict total order on all literals where all undefined literals are larger than $\text{comp}(L_n)$. We also extend $\prec_{\Gamma}$ to a strict total order on ground clauses by multiset extension and also on multisets of ground clauses and overload $\prec_{\Gamma}$ for all these cases. With $\preceq_{\Gamma}$ we denote the reflexive closure of $\prec_{\Gamma}$.

**Theorem 13** (Learned Clauses in Regular Runs). Let $(\Gamma; N; U; \beta; k; C_0 \cdot \sigma_0)$ be the state resulting from the application of Conflict in a regular run and let $C$ be the clause learned at the end of the conflict resolution, then $C$ is not redundant with respect to $N \cup U$ and $\prec_{\Gamma}$.

*Proof.* Consider the following fragment of a derivation learning a clause:

$$ \begin{align*} & \Rightarrow_{\text{SCL}}^{\text{Conflict}} (\Gamma; N; U; \beta; k; C_0 \cdot \sigma_0) \\ & \Rightarrow_{\text{SCL}}^{\{\text{Skip, Fact., Res.}\}^*} (\Gamma'; N; U; \beta; k; C \cdot \sigma) \\ & \Rightarrow_{\text{SCL}}^{\text{Backtrack}} \end{align*} $$

By soundness $N \cup U \models C$ and $C\sigma$ is false under both $\Gamma$ and $\Gamma'$. We prove that $C\sigma$ is non-redundant to $N \cup U$ with respect to $\prec_{\Gamma}$.

Assume there is an $S \subseteq \text{gnd}(N \cup U)^{\preceq_{\Gamma} C\sigma}$ s.t. $S \models C\sigma$. There must be a clause $D \in S$ false under $\Gamma$, since all clauses in $S$ have a defined truth value (as all undefined literals are greater in $\prec_{\Gamma}$ than all defined literals) and if $\Gamma \models S$ then $\Gamma \models C\sigma$ by transitivity of entailment, a contradiction.

By regularity, $\Gamma$ must be of the shape $\Gamma = \Gamma'', L\delta^{C \lor L \cdot \delta}$, since no application of Decide can lead to an application of the rule Conflict. Thus, the last applied rule must have been Propagate. Furthermore, by Lemma 11, Resolve must have resolved at least the rightmost literal $L\delta$ from $\Gamma$. Thus, $L\delta \notin C\sigma$ and $\text{comp}(L\delta) \notin C\sigma$.

Since $D \prec_{\Gamma} C\sigma$, neither $L\delta$ nor $\text{comp}(L\delta)$ may occur in $D$. However, this is a contradiction, since $D$ is then already false under $\Gamma''$ and, thus, must have been chosen as a Conflict instance earlier in a regular run. □

Of course, in a regular run, the ordering of foreground literals on the trail will change, i.e., the ordering of Definition 12 will change as well. Thus the non-redundancy property of Lemma 13 reflects the situation at the time of creation of the learned clause. A non-redundancy property holding for an overall run must be invariant against changes on the ordering. However, the ordering of Definition 12 also entails a fixed subset ordering $\prec \subseteq$ that is invariant against changes on the overall ordering. This means that our dynamic ordering entails non-redundancy criteria based on subset relations including
forward subsumption. From an implementation perspective, this means that learned clauses need not to be tested for forward redundancy. Current resolution or superposition based provers spent a reasonable portion of their time in testing forward redundancy of newly generated clauses. In addition, also tests for backward reduction can be restricted knowing that learned clauses are not redundant.

**Theorem 14 (FOL Non-Redundancy is Undecidable).** *Deciding non-redundancy of a first-order clause C with respect to a finite first-order clause set $N \preceq^C$ is undecidable.*

*Proof.* We reducae the problem to unsatisfiability of an arbitrary first-order clause set $N$. Let $N = \{C_1, \dots, C_n\}$ be an arbitrary, finite first-order clause set. We consider an LPO ordering $\prec_{LPO}$. Next, we add a fresh predicate $P$ of arity zero, where $P$ is $\prec_{LPO}$ larger than any clause in $N$. Now, in the finite first-order clause set $N \cup \{P\}$ the clause $P$ is redundant iff $N$ is unsatisfiable. $\square$

**Theorem 15 (BS Non-Redundancy is NEXPTIME-Complete).** *Deciding non-redundancy of a BS clause C with respect to a finite BS clause set $N \preceq^C$ is NEXPTIME-Complete.*

*Proof.* We only show hardness, because containment of the problem in NEXPTIME is obvious. To this end, let $N = \{C_1, \dots, C_n\}$ be an arbitrary, finite BS clause set. We consider an LPO ordering $\prec_{LPO}$. Next, we add a fresh predicate $P$ of arity zero, where $P$ is $\prec_{LPO}$ larger than any clause in $N$. Now, in the finite BS clause set $N \cup \{P\}$ the clause $P$ is redundant iff $N$ is unsatisfiable. $\square$

**Theorem 16 (Termination).** *Any regular run of $\Rightarrow_{SCL}$ terminates.*

*Proof.* Any infinite run learns infinitely many clauses. Firstly, for a regular run, by Theorem 13, all learned clauses are non-redundant. Those clauses are also non-redundant under the fixed subset ordering $\prec_{\subseteq}$, which is well-founded. Due to the restriction of all clauses to be smaller than $\{\beta\}$, the overall number of non-redundant ground clauses is finite. So there is no infinite regular run. $\square$

**Theorem 17 (SCL Refutational Completeness).** *If $N$ is unsatisfiable, such that some finite $N' \subseteq \text{gnd}(N)$ is unsatisfiable and $\beta$ is $\prec_B$ larger than all literals in $N'$ then any regular run from $(\epsilon; N; \emptyset; \beta; 0; \top)$ of SCL derives $\bot$.*

*Proof.* By Theorem 16 and Theorem 10. $\square$

Of course, for a given, unsatisfiable clause set $N$, a sufficiently large $\beta$ cannot be effectively computed in advance, in general. Then the calculus is extended with a different rule that increases $\beta$. The below rule grow has to be applied in a fair way together with the other SCL calculus resulting then in a semi-decision procedure.

**Grow** $(\Gamma; N; U; \beta; k; \top) \Rightarrow_{SCL} (\epsilon; N; U; \beta'; 0; \top)$
provided $\beta \prec_B \beta'$

**Example 18.** For example, consider a SCL run on the following clause set:
$$N = \left\{ \begin{array}{ll} (1) & \neg P(x) \lor P(g(x)) \\ (2) & P(a) \\ (3) & \neg P(g(a)) \end{array} \right\}$$

First, we choose $\prec_B$ as a KBO, where all symbols have weight one and with precedence $a \prec g \prec P$. In the beginning of the run, we set $\beta = P(g(g(a)))$.

$$\begin{array}{l} (\varepsilon; N; \emptyset; \beta; 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; \emptyset; \beta; 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; P(g(a))^{(1)}; \{x \mapsto a\}; N; \emptyset; \beta; 0; \top) \\ \Rightarrow_{SCL} (\varepsilon; N; \emptyset; \beta' = P(g(g(a)))); 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; \emptyset; \beta; 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; P(g(a))^{(1)}; \{x \mapsto a\}; N; \emptyset; \beta; 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; P(g(a))^{(1)}; \{x \mapsto a\}, P(g(g(a)))^{(1)}; \{x \mapsto g(a)\}; N; \emptyset; \beta'; 0; \top) \\ \Rightarrow_{SCL} (P(a)^{(2)}; P(g(a))^{(1)}; \{x \mapsto a\}, P(g(g(a)))^{(1)}; \{x \mapsto g(a)\}; N; \emptyset; \beta'; 0; (3) \cdot \{\}) \\ \Rightarrow_{SCL} (P(a)^{(2)}; P(g(a))^{(1)}; \{x \mapsto a\}; N; \emptyset; \beta'; 0; \neg P(g(a)) \cdot \{x \mapsto g(a)\}) \\ \Rightarrow_{SCL} (P(a)^{(2)}; N; \emptyset; \beta'; 0; \neg P(a) \cdot \{x \mapsto g(a)\}) \\ \Rightarrow_{SCL} (P(a)^{(2)}; N; \emptyset; \beta'; 0; \bot \cdot \{x \mapsto g(a)\}) \end{array}$$

Note that after the second Propagate, no other rule except Grow is applicable to our state. In particular, note that after this step, $\Gamma = \{P(a), P(g(a))\} \models \text{gnd}^{\prec_B \beta}(N)$. Hence, no further literal can be added to the trail and no conflict can be detected. Thus, the only option here is to use Grow to consider more literals. Only with these additional literals, a refutation is eventually found.

**Theorem 19 (SCL decides the BS fragment).** SCL restricted to regular runs decides satisfiability of a BS clause set if $\beta$ is set appropriately.

*Proof.* Let $B$ be the set of constants in the BS clause set $N$. Then define $\prec_B$ and $\beta$ such that $L\sigma \prec_B \beta$ for all $L \in N$ and for all groundings $\sigma$ of $L$ with codom($\sigma$) $\subseteq B$. Following the proof of Theorem 16, any SCL regular run will terminate on a BS clause set. $\square$

# 5 Conclusion

The main contribution of this paper revisiting the SCL calculus for first-order are: (i) the incorporation of the regularity definition of [13] to classical SCL. This enables SCL to guarantee non-redundant learning even without requiring exhaustive propagation, (ii) the introduction of a new trail bounding measure, which guarantees termination by limiting the size of considered literals. Still, for proper bounds, SCL remains a decision procedure for any logic that enjoys the finite model property. Moreover, this paper contains formal, rigorous proofs for the SCL calculus, including a full soundness proof
which was omitted before [13,22]. Moreover, the proofs of the original paper have been
adapted and, in some cases, simplified.

This paper, hence, forms part of an overall development of the SCL calculus. The
overall goal of this process is to provide an efficient, powerful algorithm for proving
first-order formulae or providing counterexamples.

References

[1] Alagi, G., Weidenbach, C.: NRCL – A model building approach to the Bernays-Schönfinkel fragment. In: Lutz, C., Ranise, S. (eds.) Frontiers of Combining Systems – 10th International Symposium, FroCoS 2015, Wroclaw, Poland, September 21-24, 2015. Proceedings. Lecture Notes in Computer Science, vol. 9322, pp. 69–84. Springer (2015)

[2] Bachmair, L., Ganzinger, H.: On restrictions of ordered paramodulation with simplification. In: Stickel, M.E. (ed.) 10th International Conference on Automated Deduction, Kaiserslautern, FRG, July 24-27, 1990, Proceedings. Lecture Notes in Computer Science, vol. 449, pp. 427–441. Springer (1990), https://doi.org/10.1007/3-540-52885-7_105

[3] Bachmair, L., Ganzinger, H.: Equational reasoning in saturation-based theorem proving (1998)

[4] Bachmair, L., Ganzinger, H., Waldmann, U.: Refutational theorem proving for hierarchic first-order theories. Appl. Algebra Eng. Commun. Comput. **5**, 193–212 (1994), https://doi.org/10.1007/BF01190829

[5] Baumgartner, P., Fuchs, A., Tinelli, C.: Lemma learning in the model evolution calculus. In: LPAR. Lecture Notes in Computer Science, vol. 4246, pp. 572–586. Springer (2006)

[6] Baumgartner, P., Tinelli, C.: The model evolution calculus as a first-order DPLL method. Artif. Intell. **172**(4-5), 591–632 (2008), https://doi.org/10.1016/j.artint.2007.09.005

[7] Baumgartner, P., Waldmann, U.: Hierarchic superposition revisited. CoRR abs/1904.03776 (2019), http://arxiv.org/abs/1904.03776

[8] Blanchette, J.C., Bulwahn, L., Nipkow, T.: Automatic proof and disproof in Isabelle/HOL. In: Tinelli, C., Sofronie-Stokkermans, V. (eds.) Frontiers of Combining Systems, 8th International Symposium, FroCoS 2011, Saarbrücken, Germany, October 5-7, 2011. Proceedings. Lecture Notes in Computer Science, vol. 6989, pp. 12–27. Springer (2011), https://doi.org/10.1007/978-3-642-24364-6_2

[9] Bonacina, M.P., Furbach, U., Sofronie-Stokkermans, V.: On first-order model-based reasoning. In: Martí-Oliet, N., Ölveczky, P.C., Talcott, C.L. (eds.) Logic, Rewriting,
and Concurrency - Essays dedicated to José Meseguer on the Occasion of His 65th
Birthday. Lecture Notes in Computer Science, vol. 9200, pp. 181–204. Springer
(2015)

[10] Bonacina, M.P., Plaisted, D.A.: Semantically-guided goal-sensitive reasoning: Model representation. Journal of Automated Reasoning 56(2), 113–141 (2016)

[11] Bromberger, M., Dragoste, I., Faqeh, R., Fetzer, C., González, L., Krötzsch, M., Marx, M., Murali, H.K., Weidenbach, C.: A sorted datalog hammer for supervisor verification conditions modulo simple linear arithmetic. In: Fisman, D., Rosu, G. (eds.) Tools and Algorithms for the Construction and Analysis of Systems - 28th International Conference, TACAS 2022, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022, Munich, Germany, April 2-7, 2022, Proceedings, Part I. Lecture Notes in Computer Science, vol. 13243, pp. 480–501. Springer (2022). https://doi.org/10.1007/978-3-030-99524-9_27, https://doi.org/10.1007/978-3-030-99524-9_27

[12] Bromberger, M., Dragoste, I., Faqeh, R., Fetzer, C., Krötzsch, M., Weidenbach, C.: A datalog hammer for supervisor verification conditions modulo simple linear arithmetic. In: Konev, B., Reger, G. (eds.) Frontiers of Combining Systems - 13th International Symposium, FroCoS 2021, Birmingham, UK, September 8-10, 2021, Proceedings. Lecture Notes in Computer Science, vol. 12941, pp. 3–24. Springer (2021). https://doi.org/10.1007/978-3-030-86205-3_1, https://doi.org/10.1007/978-3-030-86205-3_1

[13] Bromberger, M., Fiori, A., Weidenbach, C.: SCL with theory constraints (Oct 2020), https://hal.inria.fr/hal-02975868

[14] Bromberger, M., Fiori, A., Weidenbach, C.: Deciding the Bernays-Schoenfinkel fragment over bounded difference constraints by simple clause learning over theories. In: Henglein, F., Shoham, S., Vizel, Y. (eds.) Verification, Model Checking, and Abstract Interpretation - 22nd International Conference, VMCAI 2021, Copenhagen, Denmark, January 17-19, 2021, Proceedings. Lecture Notes in Computer Science, vol. 12597, pp. 511–533. Springer (2021)

[15] Bromberger, M., Leutgeb, L., Weidenbach, C.: An efficient subsumption test pipeline for BS(LRA) clauses. In: Blanchette, J., Kovács, L., Pattinson, D. (eds.) Automated Reasoning - 11th International Joint Conference, IJCAR 2022, Haifa, Israel, August 8-10, 2022, Proceedings. Lecture Notes in Computer Science, vol. 13385, pp. 147–168. Springer (2022), https://doi.org/10.1007/978-3-031-10769-6_10

[16] Bromberger, M., Schwarz, S., Weidenbach, C.: Exploring partial models with SCL. In: Konev, B., Schon, C., Steen, A. (eds.) Proceedings of the Workshop on Practical Aspects of Automated Reasoning Co-located with the 11th International Joint Conference on Automated Reasoning (FLoC/IJCAR 2022), Haifa, Israel, August, 11 - 12, 2022. CEUR Workshop Proceedings, vol. 3201. CEUR-WS.org (2022), http://ceur-ws.org/Vol-3201/paper5.pdf
[17] Davis, M., Logemann, G., Loveland, D.W.: A machine program for theorem-proving. Commun. ACM 5(7), 394–397 (1962), https://doi.org/10.1145/368273.368557

[18] Davis, M., Putnam, H.: A computing procedure for quantification theory. J. ACM 7(3), 201–215 (1960), http://doi.acm.org/10.1145/321033.321034

[19] Dershowitz, N.: Orderings for term-rewriting systems. Theoretical Computer Science 17, 279–301 (1982)

[20] Desharnais, M., Vukmirovic, P., Blanchette, J., Wenzel, M.: Seventeen provers under the hammer. In: Andronick, J., de Moura, L. (eds.) 13th International Conference on Interactive Theorem Proving, ITP 2022, August 7-10, 2022, Haifa, Israel. LIPIcs, vol. 237, pp. 8:1–8:18. Schloss Dagstuhl - Leibniz-Zentrum für Informatik (2022)

[21] Duarte, A., Korovin, K.: Implementing superposition in iProver (system description). In: Peltier, N., Sofronie-Stokkermans, V. (eds.) Automated Reasoning - 10th International Joint Conference, IJCAR 2020, Paris, France, July 1-4, 2020, Proceedings, Part II. Lecture Notes in Computer Science, vol. 12167, pp. 388–397. Springer (2020), https://doi.org/10.1007/978-3-030-51054-1_24

[22] Fiori, A., Weidenbach, C.: SCL clause learning from simple models. In: Automated Deduction - CADE 27 - 27th International Conference on Automated Deduction, Natal, Brazil, August 27-30, 2019, Proceedings. pp. 233–249 (2019), https://doi.org/10.1007/978-3-030-29436-6_14

[23] Jr., R.J.B., Schrag, R.: Using CSP look-back techniques to solve real-world SAT instances. In: Kuipers, B., Webber, B.L. (eds.) Proceedings of the Fourteenth National Conference on Artificial Intelligence and Ninth Innovative Applications of Artificial Intelligence Conference, AAAI 97, IAAI 97, July 27-31, 1997, Providence, Rhode Island, USA. pp. 203–208 (1997)

[24] Kovacs, L., Voronkov, A.: First-order theorem proving and Vampire. In: Sharygina, N., Veith, H. (eds.) Proceedings of the 25th International Conference on Computer Aided Verification. pp. 1–35. No. 8044 in Lecture Notes in Artificial Intelligence, Springer-Verlag (2013)

[25] Kruglov, E., Weidenbach, C.: Superposition decides the first-order logic fragment over ground theories. Math. Comput. Sci. 6(4), 427–456 (2012), https://doi.org/10.1007/s11786-012-0135-4

[26] Leidinger, H., Weidenbach, C.: SCL(EQ): SCL for first-order logic with equality. In: Blanchette, J., Kovacs, L., Pattinson, D. (eds.) Automated Reasoning - 11th International Joint Conference, IJCAR 2022, Held as Part of the Federated Logic Conference, Proceedings. LNCS, Springer (2022), to Appear
[27] Moskewicz, M.W., Madigan, C.F., Zhao, Y., Zhang, L., Malik, S.: Chaff: Engineering an efficient sat solver. In: Design Automation Conference, 2001. Proceedings. pp. 530–535. ACM (2001)

[28] Paulson, L.C., Blanchette, J.C.: Three years of experience with sledgehammer, a practical link between automatic and interactive theorem provers. In: Sutcliffe, G., Schulz, S., Ternovska, E. (eds.) The 8th International Workshop on the Implementation of Logics, IWIL 2010, Yogyakarta, Indonesia, October 9, 2011. EPiC Series in Computing, vol. 2, pp. 1–11. EasyChair (2010), https://doi.org/10.29007/36dt

[29] Piskac, R., de Moura, L.M., Bjørner, N.: Deciding effectively propositional logic using DPLL and substitution sets. Journal of Automated Reasoning 44(4), 401–424 (2010)

[30] Robinson, G., Wos, L.: Paramodulation and Theorem-Proving in First-Order Theories with Equality, pp. 298–313. Springer Berlin Heidelberg, Berlin, Heidelberg (1983), https://doi.org/10.1007/978-3-642-81955-1_19

[31] Robinson, J.A.: A machine-oriented logic based on the resolution principle. J. ACM 12(1), 23–41 (1965), http://doi.acm.org/10.1145/321250.321253

[32] Schulz, S., Cruanes, S., Vukmirović, P.: Faster, Higher, Stronger: E 2.3. In: Fontaine, P. (ed.) Proceedings of the 27th International Conference on Automated Deduction. pp. 495–507. No. 11716 in Lecture Notes in Computer Science, Springer-Verlag (2019)

[33] Schulz, S.: Empirical properties of term orderings for superposition. In: Konev, B., Schon, C., Steen, A. (eds.) Proceedings of the Workshop on Practical Aspects of Automated Reasoning Co-located with the 11th International Joint Conference on Automated Reasoning (FLoC/IJCAR 2022), Haifa, Israel, August, 11 - 12, 2022. CEUR Workshop Proceedings, vol. 3201. CEUR-WS.org (2022), http://ceur-ws.org/Vol-3201/paper4.pdf

[34] Silva, J.P.M., Lynce, I., Malik, S.: Conflict-driven clause learning SAT solvers. In: Biere, A., Heule, M., van Maaren, H., Walsh, T. (eds.) Handbook of Satisfiability, Frontiers in Artificial Intelligence and Applications, vol. 185, pp. 131–153. IOS Press (2009), https://doi.org/10.3233/978-1-58603-929-5-131

[35] Silva, J.P.M., Sakallah, K.A.: Grasp - a new search algorithm for satisfiability. In: International Conference on Computer Aided Design, ICCAD. pp. 220–227. IEEE Computer Society Press (1996)

[36] Slagle, J.R.: Automatic theorem proving with renamable and semantic resolution. J. ACM 14(4), 687–697 (1967), https://doi.org/10.1145/321420.321428

[37] Sutcliffe, G.: The CADE ATP System Competition - CASC. AI Magazine 37(2), 99–101 (2016)