2 Background and notation

Modern formal logics, including formulations of SAT problems, are usually presented in a symbolic and linear fashion. Existential graphs (EGs) (Shin, Reference Shin1999; Sowa, Reference Sowa2011), by contrast, are a non-symbolic and non-linear system for logical expressions, where propositions are drawn on a two-dimensional sheet, negation is represented by oval lines (aka cuts), and all elements contained in the same area (delimited by negation lines) are in implicit conjunction. We say that an area is evenly (resp. oddly) nested if it is enclosed by an even (resp. odd) number of cuts. Note that a blank sheet of assertion denotes true ( $\top$ ), has nesting level $0$ and therefore it is assumed to be evenly enclosed. In Figure 2, we present a few introductory examples illustrating that the combination of these simple primitives suffices to express any propositional logic formula.

Fig. 2. Examples of existential graphs representing different propositional logic formulae.

EGs cannot only represent propositional logic formulae, but they are, in fact, equivalent to sentential languagesFootnote ² (Zeman, Reference Zeman1964; Roberts, Reference Roberts1973). Even if this diagrammatic notation is less commonly used, it offers a simple, elegant, and easy-to-learn alternative that comes with a sound and complete deductive system which has many advantages over the traditional Gentzen’s rules of natural deduction and sequent calculus and, thus, over all other rewriting methods based on these. Most significantly, EGs’ inference rules are symmetric, and no bookkeeping of previous steps is required in the process of inferring a graph from another. Furthermore, as illustrated in Figure 2, EGs’ graphical non-ordered nature provides a canonical representation of a logical formula that, in linear notation, can take many equivalent forms. Another key and perhaps underexplored advantage is that the visual representation allows for the recognition of patterns that would otherwise be obscured in nested clausal form. Finally, since EGs are easily transferred to any notation, they can help clarify the relationships between diverse reasoning methods, such as resolution and natural deduction and, ultimately, help understand the foundations of proof theory.

We assume the reader is familiar with basic notions of propositional logic and the Boolean satisfiability problem (SAT). In what follows, we will use a subscript to indicate the size of a clause (e.g. $C_8$ refers to a clause of size $8$ ) and, given a clause $C_n=(l_1\lor l_2\lor \cdots \lor l_n)$ , we refer to the set of its literals as $\mathrm{lit}(C_n)=\{l_1,l_2,\cdots ,l_n\}$ .

As shown in Figure 2, nested cuts can be interpreted as implication, so it is easy to see that every binary clause, for example $C_2=(x\lor y)$ , admits the following two interpretations: $(\neg x\rightarrow y)$ and its logically equivalent contrapositive $(\neg y\rightarrow x)$ . Thus, binary clauses provide the information needed to build what is known as the binary implication graph (BIG) (Reference Aspvall, Plass and TarjanAspvall et al. 1979) of the formula, which is a directed graph where edges represent implication, and nodes are all the literals occurring in binary clauses and their negations (see Figure 3).

Fig. 3. BIG of $\varphi =(\overline {X}\lor Y)\land (\overline {Y}\lor Z)\land (\overline {Z}\lor U)\land (\overline {U}\lor V)\land (\overline {U}\lor Y)$ .

If there exists a directed path from vertex $x$ to vertex $y$ , we say that $y$ is a descendant of (or reachable from) $x$ , and we say that $x$ is an ancestor of $y$ . We will denote the set of all descendants (resp. ancestors) of a vertex $z$ by $\mathrm{des}(z)$ (resp. $\mathrm{anc}(z)$ ). We say that two vertices $u$ and $v$ in a directed graph $G$ are strongly connected iff there are directed paths from $u$ to $v$ and from $v$ to $u$ . A subgraph $S\subseteq G$ is a strongly connected component if all its vertices are strongly connected and they are not strongly connected with any other vertex of $G\setminus S$ (i.e. every vertex in $S$ is reachable from every other vertex in $S$ and $S$ is maximal with this property wrt $G$ ). Every strongly connected component corresponds to an equivalence class. Two elements belong to the same equivalence class iff they are equivalent. We can choose one of the elements in the class as a class representative to refer to the whole equivalence class.

3 Preprocessing framework

3.1 Simplification rules

Charles S. Peirce (1839 – 1914) provided the following sound and complete set of inference rules for EGs (for more details, see e.g. Peirce (Reference Peirce1909); Shin (Reference Shin1999); Dau (Reference Dau2008); Sowa (Reference Sowa2011)), where an EG-element is any arbitrary clauseFootnote ³ expressed as an EG:

1. 1.

   1. (i) Insertion: in an odd area (nesting level $2k+1, k\in \mathbb{N}$ ), we can draw any EG-element.

   2. (e) Erasure: any EG-element in an even area (nesting level $2k, k\in \mathbb{N}$ ) can be deleted.

2. 2.

   1. (i) Iteration: any EG-element in an area $a$ can be duplicated in $a$ or in any nested areas within $a$ .

   2. (e) Deiteration: any EG-element whose occurrence could be the result of iteration may be erased.

3. 3.

   1. (i) Double Cut Insertion: a double negation may be drawn around any collection of zero or more EG-elements in any area.

   2. (e) Double Cut Erasure: any double negations can be erased.

We investigate the reversibility properties of Peirce’s EGs inference rules and their combinations in order to determine which sequences of rule applications and underlying restrictions ensure non-increasing model equivalence. Note that rules $2i$ & $2e$ and $3i$ & $3e$ are mutually reversible and, thus, preserve equivalence, whilst the first two rules are not. To the best of our knowledge, the EG calculus has only been studied as a proof system and used to prove logical assertions by inference (Dau, Reference Dau2008; Sowa, Reference Sowa2011), but it has never been used as a simplification method nor restricted to equivalence-preserving rules.

In what follows, we present the definitions of each of our rules alongside a visual exemplification, and compare them to existing preprocessing techniques. Throughout, let $\varphi$ be an arbitrary propositional formula and BIG( $\varphi$ ) denote its binary implication graph.

3.1.1 Singleton wipe

This rule is equivalent to a combination of Shin’s rules 1 and 2 (Shin, Reference Shin1999), and to Peirce’s EGs deiteration rule ( $2e$ above) restricted to single EG-elements (unit clauses) and extended to account for the generation of empty cuts. Most importantly, it can be seen as a generalisation of unit propagation applicable over arbitrary formulae, not only in CNF.

Definition 1 (Singleton wipe rule (SWR)). Any copy of a single EG-element (i.e. a literal) present in the same or any nested (inner) areas can be erased, and, if an empty cut is generated, the area containing the empty negation oval shall be deleted.

Note that, in linear notation, clausal levels can be distinguished by parenthesis (either explicit or implicit in accordance with the precedence of logical operators). Moreover, note that empty cuts are generated when the negation of the propagated singleton is encountered.

Example 1. Let $\varphi = P \wedge ((A \wedge D \wedge P \wedge (A \rightarrow B) \wedge (\neg C \vee D)) \vee (P \wedge Q \wedge R) \vee T \vee (S \wedge T) \vee \neg (X \rightarrow (X \wedge Y \wedge Z))) \wedge \neg T$ . When trying to simplify $\varphi$ , several singletons can be propagated in the same or inner levels, namely $A, D, P, \neg T,$ and $X$ . This is not easy for a human reader to detect if the formula is expressed in linear form, but it becomes apparent when expressed as an EG (see Figure 4). If we apply SWR to $\varphi$ , we obtain the following simplified equivalent formula: $\varphi '=\mathrm{SWR}(\varphi )=P \wedge \neg T \wedge ((A \wedge B \wedge D) \vee (Q \wedge R) \vee (X \wedge (\neg Y \vee \neg Z)))$ . Note that transforming $\varphi$ to CNF (with trivial tautology removal) would result in a formula of $30$ clauses of sizes $1$ to $5$ with a total of $124$ literals and $11$ variables, where traditional unit propagation could only be applied to the unit clauses $P$ and $\neg T$ , and the resulting (partially) simplified formula would have $26$ clauses of sizes $1$ to $5$ with a total of $98$ literals and $11$ variables. Instead, if we transform $\varphi '$ to CNF, we obtain a formula with $10$ variables, $14$ clauses of sizes $1$ to $4$ , and a total of $44$ literals.

Fig. 4. EG of $\varphi$ (left), where the EG-elements coloured in orange can be simplified by propagating their outermost instances, marked in blue, to obtain $\varphi '$ (right).

Remark 1. SWR effectively tells us that each EG-element (literal, clause, or subclause) contributes to the truth value of the whole EG (i.e. the whole formula) at its outermost occurrence, and the presence or absence of more deeply nested instances is irrelevant.

3.1.2 Equivalence projection

This rule can be achieved by nontrivial applications of the iteration, deiteration and cut rules ( $2i$ , $2e$ , $3i$ and $3e$ from Section 3.1) and noticing that two propositional variables $x$ and $y$ are equivalent (resp. opposites) whenever we have the following two clauses: $(x\lor \overline {y})\land (\overline {x}\lor y)$ (resp. $(x\lor y)\land (\overline {x}\lor \overline {y})$ ). This is obvious from the implication interpretation of these clauses as EGs that we saw in Section 2.

Trying all possible (de)iterations of binary clauses within each other is clearly impractical, and requires a nontrivial search for candidate EG-elements and backtracking. However, if we use the BIG of the formula to inform our procedure, it becomes straightforward and efficient.

Definition 2 (Equivalence projection rule (EPR)). Let $\phi$ be an arbitrary subformula of $\varphi$ . Every strongly connected component of $\mathrm{BIG(\phi )}$ corresponds to an equivalence class, and all literals in the equivalence class in the same or greater nesting level within $\phi$ can be substituted by their class representative. If a cut contains multiple elements of the equivalence class, they can all be substituted by a single instance of the representative literal. If a cut contains both an element of the equivalence class and the negation of an element in the equivalence class, it can be deleted. The $\mathrm{BIG(EPR(\phi ))}$ of the remaining binary clauses is guaranteed to be acyclic and corresponds to the condensation of $\mathrm{BIG(\phi )}$ .

The deletion of literals and clauses in EPR can be seen as a nested application of the SWR rule (see Definition1) performed immediately after a substitution step. The replacement part of EPR is in fact equivalent to a well-known preprocessing technique called equivalent-literal substitution (ELS) (Gelder and Tsuji, Reference Gelder, Tsuji, Johnson and Trick1993; Li, Reference Li, Kautz and Porter2000), but ours does not require a formula to be in CNF. Moreover, our rule is equivalence-preserving (unlike ELS) since we keep the information of any equivalence classes, and both substitution and simplification are applied in one step. Additionally, the BIG built and updated during the application of this rule will inform other preprocessing techniques, so the effort of building the graph will be reused and further exploited.

3.1.2.1 Nested equivalence projection

Equivalence projection can be applied not only at the formula level but also within nested cuts, which enhances its reduction powers and makes EPR applicable to formulae in forms other than CNF too (see Example2). To do so, we maintain local implication graphs corresponding to the binary clauses present at each nesting level.

Example 2. Let $\varphi =(\overline {X}\lor \overline {Y}\lor \overline {A})\land \neg ((A\rightarrow B)\land (B\rightarrow A)\land (\overline {X}\lor \overline {Y}\lor \overline {B}))$ . We generate the BIG of any area with binary clauses, which in this case is only the big level- $1$ area. The nested BIG contains a strongly connected component $[A]=\{A,B\}$ , so the innermost $B$ can be substituted by the representative $A$ . The resulting ternary clause can then be wiped by the deiteration rule (and our rules to come), leading to the negation of the equivalence found (see Figure 5). Hence $\varphi$ can be simplified to $\varphi '=\mathrm{EPR}(\varphi )=(\overline {X}\lor \overline {Y}\lor \overline {A})$ with $[A]=\{A,\overline {B}\}$ .

Fig. 5. EGs of $\varphi =(\overline {X}\lor \overline {Y}\lor \overline {A})\land \neg ((A\rightarrow B)\land (B\rightarrow A)\land (\overline {X}\lor \overline {Y}\lor \overline {B}))$ and its reduction to $\varphi '=(\overline {X}\lor \overline {Y}\lor \overline {A})$ with $[A]=\{A,\overline {B}\}$ after nestedly applying EPR and then deiteration.

Even higher reductions can be achieved if we consider equivalence – and, as we will see, implication chains – in the union of nested implication graphs (see Example3).

Example 3. Let $\varphi =(\overline {X}\lor \overline {Y}\lor \overline {A})\land (A\rightarrow B)\land (B\rightarrow A)\land \neg ((C\rightarrow B)\land (B\rightarrow C)\land (\overline {X}\lor \overline {Y}\lor \overline {C}))$ . We generate the BIG of any area with binary clauses, which in this case are the outermost area and the biggest level- $1$ area. The outer BIG contains a strongly connected component $[A]=\{A,B\}$ , and the nested BIG contains a strongly connected component $[B]=\{B,C\}$ . The union of both BIGs results in the strongly connected component $[A]=\{A,B,C\}$ , so the inner ternary clause can be wiped by a combination of EPR and the deiteration rule. Thus, $\varphi$ can be simplified to $\varphi '=\mathrm{EPR}(\varphi )=(\overline {X}\lor \overline {Y}\lor \overline {A})$ with $[A]=\{A,B,\overline {C}\}$ (see Figure 6).

Fig. 6. EGs of $\varphi =(\overline {X}\lor \overline {Y}\lor \overline {A})\land (A\rightarrow B)\land (B\rightarrow A)\land \neg ((C\rightarrow B)\land (B\rightarrow C)\land (\overline {X}\lor \overline {Y}\lor \overline {C}))$ and its reduction to $\varphi '=(\overline {X}\lor \overline {Y}\lor \overline {A})$ with $[A]=\{A,B,\overline {C}\}$ after nestedly applying EPR to the union of nested BIGs and then deiteration.

3.1.3 Transitive reduction

After applying EPR until completion, the BIG is guaranteed to be acyclic since all equivalences (and so strongly connected components) have been condensed into a representative literal (or node). However, the formula can still contain redundant binary clauses. In order to remove those, we compute the transitive reduction (TR) of the BIG, which coincides with its minimum equivalent graph. Even if TR is a well-known concept, the EGs viewpoint allows us to apply this technique in a nested form and be able to detect transitive redundancies in arbitrary formulas (see Example4). We refer to this systematic application of TR across nesting levels and BIG unions as TRR. As in the EPR case, the same results can be achieved by nontrivial applications of the iteration, deiteration and cut rules, but these are only efficient if guided by the BIG.

Example 4. Let $\varphi =(\overline {A}\lor B)\land (\overline {B}\lor C)\land \neg ((C\lor \overline {A})\land X\land Y)$ . Then the level-0 BIG contains the implication chain $A\implies B\implies C$ , and the level-1 binary clause is equivalent to $A\rightarrow C$ . Computing the TR of the union of both BIGs shows that the inner binary clause is redundant and can be deleted. As illustrated in Figure 7, we then obtain the equivalent simplified formula $\varphi '=(\overline {A}\lor B)\land (\overline {B}\lor C)\land (\overline {X}\lor \overline {Y})$ .

Fig. 7. EGs of $\varphi =(\overline {A}\lor B)\land (\overline {B}\lor C)\land \neg ((C\lor \overline {A})\land X\land Y)$ (left), and its equivalent reduction $\varphi '=\mathrm{TRR}(\varphi )=(\overline {A}\lor B)\land (\overline {B}\lor C)\land (\overline {X}\lor \overline {Y})$ (right).

3.1.4 Opposite singletons implication

Definition 3 (Opposite singletons implication rule (OSIR)). If a directed path in BIG $(\varphi )$ contains a literal $l$ and later its negation $\overline {l}$ , then all the literals including and after the consequent ( $\overline {l}$ ) evaluate to true, and all the literals in the implication path before and including the antecedent ( $l$ ) evaluate to false. The Boolean variables “collapsing” in opposite chains will be equal by construction, so only one side of the implication path needs to be evaluated. All evaluated literals can be added as singletons and propagated accordingly by the SWR rule.

Note that this preprocessing step can also be seen as a backtrack-free (i.e. non-look-ahead) exhaustive version of failed-literal probing (FLP) (Berre, Reference Berre2001) over all (implicit and explicit) binary clauses, where we do not need to test candidate literals that might not lead to any new knowledge after a whole round of unit propagation. A strategy to make all possible unit-clause inferences from the BIG was proposed in Gelder (Reference Gelder2005), but their approach may add redundant, unnecessary clauses to the formula. As the previous rules, OSIR can also be applied to arbitrary nesting levels, so it does not require a formula to be in CNF (see Example5).

Example 5. Let $\varphi =(\overline {X}\lor \overline {Z})\land ((B\land \overline {C})\lor (X\land Y\land \overline {A})\lor (A\land \overline {B})\lor (P\land A\land Q)\lor (C\land A))$ . The BIG of the $1$ -nested biggest subformula contains the following implication chain: $A\implies B\implies C\implies \overline {A}$ , so we can apply the OSIR rule to it and derive $\overline {A}$ , which can be added as a nested singleton and later propagated using the SWR rule (see Figure 8 below) to obtain the much simpler formula $\varphi '=\mathrm{OSIR}(\varphi )=(\overline {X}\lor \overline {Z})\land ((B\land \overline {C})\lor (X\land Y)\lor A)$ .

Fig. 8. EGs showing the application of OSIR to $\varphi =(\overline {X}\lor \overline {Z})\land ((B\land \overline {C})\lor$ $ (X\land Y\land \overline {A})\lor (A\land \overline {B})\lor (P\land A\land Q)\lor (C\land A))$ and the subsequent SWR application where the new singleton $\overline {A}$ is propagated to obtain the equivalent reduced formula $\varphi '=(\overline {X}\lor \overline {Z})\land ((B\land \overline {C})\lor (X\land Y)\lor A)$ .

3.1.5 Tuple wipe and subflip

After understanding the basics of Peirce’s EGs rules and binary implication graphs, we can now introduce a rule which, in fact, generalises all the previous rules (except the non-reductive part of EPR).

Definition 4 (Tuple wipe and subflip rule (TWSR)). Let $C_n,D_m\in \varphi$ be two (sub)clauses of size $n\leq m$ . Let $c$ be the nesting level of $C_n$ , and $D_m$ be either in the same area as $C_n$ or in a nested area within $c$ . Let $\mathrm{des}(l)$ be the set of descendants of a literal $l$ in $\mathrm{BIG}(\varphi )$ . Let $\mathrm{lit}(C_n)=\{p_1,\dots ,p_n\}$ and $\mathrm{lit}(D_m)=\{q_1,\dots ,q_m\}$ .

(1) If for each $i\in \{1,\ldots ,n-1\}$ either $p_i=q_i$ or $q_i\in \mathrm{des}(p_i)$ , and $p_n=q_n$ or $q_n\in \mathrm{des}(p_n)$ , then $D_m$ can be deleted from $\varphi$ .

(2) If for each $i\in \{1,\ldots ,n-1\}$ either $p_i=q_i$ or $q_i\in \mathrm{des}(p_i)$ , and $p_n=\overline {q_n}$ or $\overline {q_n}\in \mathrm{des}(p_n)$ , then $q_n$ can be deleted from $D_m$ .

Note that we need to specify the cases $p_n=q_n$ and $p_n=\overline {q_n}$ since it is always the case that $x\rightarrow x$ and $\overline {x} \rightarrow \overline {x}$ , but these tautologies are not added to the BIG in order to keep it redundancy- and tautology-free.

As before, our rule can be applied to arbitrary nesting levels, and so it does not require a formula to be in CNF (see Example6).

Example 6. Let $\varphi =(A\rightarrow E)\land (B\rightarrow F)\land (C\rightarrow G)\land \neg ((\overline {A}\lor \overline {B}\lor G\lor \overline {H})\land (\overline {A}\lor \overline {B}\lor \overline {C}\lor \overline {D})\land (\overline {E}\lor \overline {F}\lor \overline {G}))$ . Note that the BIG of the outermost area applies to the biggest $1$ -nested subformula. As illustrated in Figure 9, we can apply TWSR to the clauses of sizes 3 and 4 inside the biggest $1$ -nested area and obtain the simplified equivalent formula $\varphi '=(A\rightarrow E)\land (B\rightarrow F)\land (C\rightarrow G)\land ((A\land B\land H)\lor (E\land F\land G))$ . In particular, the clauses $P_3=(\overline {E}\lor \overline {F}\lor \overline {G})$ and $Q_4=(\overline {A}\lor \overline {B}\lor \overline {C}\lor \overline {D})$ satisfy condition (1) in TWSR’s definition, and $P_3$ together with $R_4=(\overline {A}\lor \overline {B}\lor G\lor \overline {H})$ satisfy condition (2).

Fig. 9. EG of $\varphi =(A\rightarrow E)\land (B\rightarrow F)\land (C\rightarrow G)\land \neg ((\overline {A}\lor \overline {B}\lor G\lor \overline {H})\land$ $ (\overline {A}\lor \overline {B}\lor \overline {C}\lor \overline {D})\land (\overline {E}\lor \overline {F}\lor \overline {G}))$ (left), where the literals satisfying TWSR’s definition conditions are highlighted in matching colours. The equivalent reduced formula resulting from applying TWSR is shown on the right-hand side.

It is easy to see that TWSR with $n=1$ is equivalent to SWR. TWSR restricted to binary clauses only (i.e. with $n=m=2$ ) is equivalent to the clause deletion part of EPR and computing the TRR of $\mathrm{BIG}(\varphi )$ when condition (1) is satisfied; and to the literal deletion part of EPR together with OSIR when condition (2) applies. However, TWSR cannot fully emulate EPR since it cannot perform the non-reductive substitution step (i.e. substitute a literal by its class representative) nor keep equivalence classes information. Figure 10 shows two examples of TWSR applications for $n=m=3$ satisfying, respectively, conditions (1) and (2).

Fig. 10. EGs of two applications of the TWSR, where colours highlight related literals (equal – in green – or in the same implication chain – in orange or blue).

Our TWSR is a generalisation of subsumption and self-subsuming resolution since it removes in one pass not only all the explicitly (self)subsumed redundant clauses but also all the implicitly (self)subsumed ones. It also generalises unit propagation, transitive reduction and, since it can be applied to clauses of arbitrary sizes, it is strictly more powerful than binary resolution combined with transitive reduction and unit propagation, while guaranteeing a non-increasing number of variables, literals and clauses (i.e. redundant variables, literals or clauses are never added). TWSR can also be seen as a backtrack-free (non-look-ahead, i.e. with no arbitrary assignments) more efficient version of FLP over all literals in the BIG of the formula.

Moreover, TWSR strictly generalises the combination of hidden subsumption elimination (HSE) (Reference Heule, Järvisalo, Biere, Fermüller and VoronkovHeule et al. 2010), hidden tautology elimination (HTE) (Reference Heule, Järvisalo, Biere, Fermüller and VoronkovHeule et al. 2010) and hidden literal elimination (Reference Heule, Järvisalo, Biere, Sakallah and SimonHeule et al. 2011) in a manner that is guaranteed to never increase the size of the formula. Note that this is not necessarily the case for the aforementioned rules. For example, in order to deduce that clauses are redundant, HTE adds literals instead of removing them and tests if this leads to a tautology. Note in particular that neither of these rules nor their combination could achieve the reduction shown in Example6, even if all clauses were at the same nesting level. For formulas in CNF, HTE combined with HSE, computing the transitive closure of BIG( $\varphi$ ) and adding all new binary clauses to $\varphi$ can achieve the same reduction as TWSR with condition (1) only, but clearly at a much higher cost and space complexity.

4 Algorithmic complexity and future work

Our systematic reduction procedure applies TWSR prioritising the propagation of the outermost smallest unprocessed clauses – since these have greater reduction potential than inner and bigger clauses – and whenever the smallest unprocessed/new clauses are of size $2$ , the procedure applies EPR before propagating them by TWSR. This might seem a straightforward operation, but it becomes a nontrivial task if we want to avoid unnecessarily repeating computations every time a reduction changes the BIG of the formula, or strengthens or modifies an already propagated clause.

Before analysing the complexity of the corresponding algorithm, let us illustrate the potential of our novel approach by revisiting Peirce’s Law, which the automatic theorem prover Vampire was able to automatically prove by contradiction in 7 steps, 3 of which were transformations to a normal form (recall Figure 1). Note that other state-of-the-art tools, such as the interactive theorem prover CoqFootnote ⁴ and MiniZincIDEFootnote ⁵ (an IDE to run high-level, solver-independent constraint models), are not able to automatically prove or simplify this tautology. On the contrary, our novel systematic approach can automatically reduce Peirce’s Law to $\top$ in as little as 2 steps, as shown in Figure 11.

Fig. 11. Proof of Peirce’s law, which states that $((P\rightarrow Q)\rightarrow P)\rightarrow P$ , obtained from the systematic application of the EPR + TWSR procedure, which prioritises the propagation of the smallest outermost unprocessed clauses. The detected simplifications in each graph transformation are highlighted in orange. Recall that the automatic theorem prover Vampire required 7 steps and 3 flattening transformations (see Figure 1).

Note that the double negation (double cut) generated in the first step is automatically simplified by the parser (and is hence not counted as a reasoning step), and the clause deletion whenever an empty cut is generated is part of our TWSR and EPR rules. Nevertheless, even if we count these two trivial simplifications as reasoning steps, our procedure still proves Peirce’s Law in half the number of steps required by Vampire, whilst avoiding any form of flattening nor requiring bookkeeping of rule applications (since all of our transformations are equivalence-preserving), and therefore requiring less space too.

In what follows, let $l$ be the total number of literals of a given propositional formula, $v$ the number of variables, and $c$ the total number of clauses across nesting levels, that is, the number of cuts of depth less or equal than $2$ (i.e. containing literals only) not already contained in a cut of depth less or equal than $2$ . For example, the middle EG in Figure 8 has $5$ clauses across nesting levels. Let $s$ be the total number of singletons across all nesting levels, $\beta$ the number of variables present in binary clauses, $\beta '\subseteq \beta$ the number of binary variables present in clauses of size greater than $2$ , $\kappa$ the number of binary clauses, $maxL$ the maximal clausal length, and $\mu$ the number of cuts of depth greater than $2$ .

Our algorithm stores the given propositional formula as an arborescence of depth $\mu$ corresponding to the EG representation of the formula, the binary clauses in each nesting level as a BIG, and the non-binary clauses as a directed graph with as many nodes as variables and clauses, and as many edges as literals. Even if the BIG might store redundant information due to it needing to be skew-symmetric, and our algorithm computing temporary BIG unions, the size of any temporary helper set used along the computation is minimal compared to the total size of the formula, and less than twofold in the worst case. Thus, the space complexity of the EPR + TWSR procedure is $\mathcal{O}(l)$ in terms of edges, and $\mathcal{O}(v+c)$ in terms of nodes, so linear in the size of the formula in any case. Moreover, notice that the size of the working formula will decrease with every EPR + TWSR reduction found, so this is clearly its worst-case space complexity.

The space complexity of our approach is better than all existing encodings used by PL preprocessors and simplifiers we are aware of, given that, to begin with, we do not need to flatten the original formula before processing. Our approach just transforms arbitrary operators to their equivalent form using $\wedge$ and $\neg$ , which has a one-to-one correspondence with the EG representation of the formula. This transformation has no impact on the number of variables, literals or (sub)clauses. In contrast, rewritings such as the widely used Tseitin transformation (Tseitin Reference Tseitin, Siekmann and Wrightson1983) need to introduce new variables to avoid potential formula explosions during flattening, and so they not only increase the number of literals and clauses, but might also increase the number of formula variables. The length of the resulting flattened formula might still be linear in the size of the formula, but clearly greater than the one obtained with our approach (recall Example1).

On the other hand, the worst-case time complexity of the EPR + TWSR procedure is $\mathcal{O}(l+\mu (\beta \kappa +(\frac {\beta '}{v-\beta +\beta '}\kappa +maxL)(c-\kappa -s)))$ , where the term $l$ corresponds to the parsing of the formula, and $\beta \kappa$ encompasses all operations over BIGs, including finding strongly connected components and computing its transitive reduction. The term $(\frac {\beta '}{v-\beta +\beta '}\kappa +maxL)(c-\kappa -s)$ corresponds to the complexity of applying TWSR, where $(c-\kappa -s)$ is the number of clauses of size greater than $2$ . Our method avoids unnecessary checks by only comparing clauses which have potential to reduce each other, that is, which share variables or contain variables present in the BIG. The number of binary variables present in each clause of interest is upper bounded by the size of the clause, which is in turn upper bounded by $maxL$ . The number of connectivity checks required is very much affected by the proportion of binary variables present in clauses of size greater than $2$ , that is $\frac {\beta '}{v-\beta +\beta '}$ , and the size of the BIG, that is $\kappa$ . Finally, since EPR and TWSR computations are performed at each nesting level, we need to multiply these complexities by $\mu$ .

Notice that if a given formula contains only singletons in its nested cuts, the worst-time complexity collapses to $\mathcal{O}(l)$ . If a formula has no binary clauses, then our algorithm’s worst time complexity turns into $\mathcal{O}(l+\mu (maxL(c-s))\approx \mathcal{O}(l+\mu c)$ , that is linear time in the size of the problem. If a given formula has maximum clausal length $2$ – over all cuts, which note is not the same as a CNF 2-SAT problem – the complexity is then bounded by $\mathcal{O}(l+\mu \beta \kappa )\approx \mathcal{O}(l+\mu vc)$ .

In summary, the complexity of EPR + TWSR( $\varphi$ ) is linear $\mathcal{O}(c)$ when $s\to c$ and when $\kappa \to 0$ . Otherwise, it has quadratic worst-case complexity. In particular, it is upper bounded by $\mathcal{O}(\beta \kappa )$ when $\kappa \to c$ , when $\beta '\to 0$ or when $\beta \ll v$ . Otherwise, the complexity is upper bounded by $\mathcal{O}(\kappa c)$ and it reaches its maximum $\mathcal{O}(c^2)$ when $\kappa \to (c-s)/2$ , that is, when half of the non-singleton clauses are binary. However, sub-quadratic behaviour can still be observed in practice on problems with sparse graphs and with non-uniform connectivity distributions – which is the case for most non-synthetic problems. Moreover, note that the problem size of an unflattened formula can be orders of magnitude smaller than its flattened version, so even if our algorithm is in the same complexity class as other state-of-the-art SAT preprocessing techniques it generalises, its actual complexity can be orders of magnitude smaller.

Another key advantage of our unified approach is that it eliminates the need to choose between different techniques or their order of application, which can have a major impact on the final level of reduction (e.g. some preprocessing techniques add redundant clauses by resolution, whilst others delete them, which could lead to an infinite loop). It can also be the case that some rules are not applicable at first, but they can provide further reduction if applied after other techniques. This is a nontrivial problem usually resolved by heuristics (e.g. restarts) or by limiting the application and behaviour of the rules according to arbitrary parameters (e.g. apply preprocessing to learned or bigger clauses only). Example7 illustrates these problems and how our solution addresses them instead. Moreover, note that our approach is guaranteed to terminate since it never increases the size of the problem.

Some of the existing computationally most expensive preprocessing techniques (namely FLP, hyper binary resolution (HBR) (Bacchus, Reference Bacchus, Dechter, Kearns and Sutton2002), asymmetric subsumption elimination (ASE) (Reference Heule, Järvisalo, Biere, Fermüller and VoronkovHeule et al. 2010), asymmetric literal elimination (Reference Biere, Järvisalo, Kiesl, Biere, Heule, van Maaren and WalshBiere et al. 2021) and asymmetric tautology elimination (ATE) (Reference Heule, Järvisalo, Biere, Fermüller and VoronkovHeule et al. 2010)) can achieve reductions on CNF formulae that TWSR is not able to attain. However, TWSR can reach the same level of reduction if applied to the original nested formula (see Example8).

Fig. 12. EGs of $\mathrm{CNF}(\varphi )=(\overline {C}\lor A)\land (\overline {C}\lor B)\land (\overline {C}\lor D)\land (\overline {A}\lor \overline {B}\lor \overline {D})$ (left), its equivalent factorised form $\varphi =(\overline {C}\lor \neg (\overline {A}\lor \overline {B}\lor \overline {D}))\land (\overline {A}\lor \overline {B}\lor \overline {D})$ (middle), and its equivalent reduced form $\mathrm{TWSR}(\varphi )=\varphi '=\overline {C}\land (\overline {A}\lor \overline {B}\lor \overline {D})$ (right).

In fact, by using EGs and BIGs, we have realised that TWSR and these advanced SAT preprocessing techniques can actually be seen as $n$ -ary versions of TRR and OSIR, where the nodes of the implication graph can be clauses instead of singletons. That is, instead of finding a redundant edge between two singletons, we remove redundant edges between implied clauses (see Example9), and instead of finding a singleton implying its negation, we uncover an $n$ -ary clause implying its negation (see Example10). Thus, we are currently working on an extension of TWSR guided by the n-ary implication hypergraph of the formula, which we claim will be able to generalise all the aforementioned rules while still guaranteeing a never-increasing problem size.

Example 9. Let $\varphi =(\overline {P}\lor \overline {Q}\lor Y)\land (\overline {Y}\lor X)\land (\overline {X}\lor R\lor S)\land (\overline {P}\lor \overline {Q}\lor R\lor S)$ . Note that the first clause can be interpreted as $(P\land Q)\rightarrow Y$ , the second as $Y\rightarrow X$ , the third as $X\rightarrow (R\lor S)$ , and the fourth as $(P\land Q)\rightarrow (R\lor S)$ , amongst many other alternative readings. However, with these particular interpretations, we can build the following implication graph:

from where it is clear that the clause $(\overline {P}\lor \overline {Q}\lor R\lor S)$ corresponds to a redundant edge and so it can be deleted. This reduction can therefore be seen as an $n$ -ary version of TRR. Our current version of TWSR cannot find these redundancies, nor can FLP or HBR. From the rules we have mentioned in this paper, only ASE and ATE would be able to detect this redundancy.