Computational and Proof Complexity of Partial String Avoidability

The partial string avoidability problem is stated as follows: given a finite set of strings with possible “holes” (wildcard symbols), determine whether there exists a two-sided infinite string containing no substrings from this set, assuming that a hole matches every symbol. The problem is known to be NP-hard and in PSPACE, and this article establishes its PSPACE-completeness. Next, string avoidability over the binary alphabet is interpreted as a version of conjunctive normal form satisfiability problem, where each clause has infinitely many shifted variants. Non-satisfiability of these formulas can be proved using variants of classical propositional proof systems, augmented with derivation rules for shifting proof lines (such as clauses, inequalities, polynomials, etc.). First, it is proved that there is a particular formula that has a short refutation in Resolution with a shift rule but requires classical proofs of exponential size. At the same time, it is shown that exponential lower bounds for classical proof systems can be translated for their shifted versions. Finally, it is shown that superpolynomial lower bounds on the size of shifted proofs would separate NP from PSPACE; a connection to lower bounds on circuit complexity is also established.

calculus, in which one can shortly refute every unsatisfiable CNF formula, then proving lower bounds for shift-Π is as hard as proving circuit lower bounds. The intermediate case of a proof system shift-Π, where Π is a propositional proof system with no known lower bounds, is left for future research.

THE PARTIAL STRING AVOIDABILITY PROBLEM
Let Σ be a finite set of symbols called an alphabet. A (two-sided) infinite string over Σ is a mapping α : Z → Σ. Two infinite strings, α and β, are the same up to a shift, if for some offset d ∈ Z, α (n) = β (n + d ) for all n ∈ Z; in this case, α and β are said to be equal, and considered to be the same infinite string.
The set of all infinite strings over an alphabet Σ is denoted by Σ ∞ , whereas Σ * is the set of all finite strings a 1 . . . a n , with n 0 and a 1 , . . . , a n ∈ Σ. Each ith symbol of a finite string w = a 1 . . . a n shall be denoted by w[i] = a i , and a substring a i . . . a j is denoted by w[i..j]. The same notation is used to extract a finite substring α[i..j] from an infinite string α.
For a set of finite strings L ⊆ Σ * , the set of infinite strings formed by concatenating any elements of L is denoted by L ∞ = { . . . w −1 w 0 w 1 w 2 . . . | w i ∈ L for all i ∈ Z }. In particular, the infinite string formed by repeating a finite string w ∈ Σ * is w ∞ = . . . www . . . Such a string is called periodic, with a period of length |w |.
A partial string over an alphabet Σ is a finite string over the alphabet Σ ∪ { }, where a square ( ) denotes an unknown symbol (a hole). For the purposes of string matching, a hole may stand for any symbol from Σ: to be precise, two partial strings of the same length, u and v, are said to be compatible, if, whenever they differ in some jth position (u An infinite string α over an alphabet Σ is said to avoid a partial string w, if every substring of α of the same length as w is incompatible with w: that is, α[i + 1..i + |w |] is incompatible with w for every i ∈ Z. A finite string avoiding w is defined similarly. A finite or infinite string is said to avoid a set of partial strings L, if it avoids every element of L.
The partial string avoidability problem is then stated as follows: given an alphabet Σ and a finite set of partial strings S over Σ, determine whether there exists an infinite string that avoids this set.
The first thing to observe is that if a finite set of partial strings is avoided by a sufficiently long finite string, then it is avoided by an infinite string. Therefore, the avoidability problem may be regarded as a problem on finite strings, and is guaranteed to have an effective solution.
Lemma 2.1. Let Σ be an alphabet, let S ⊂ (Σ ∪ { }) * be a finite set of partial strings, and let be the length of the longest string in S. Then, the following three conditions are equivalent: (I) S is avoided by a finite string of length |Σ| + ; (II) S is avoided by a periodic infinite string with period at most |Σ| ; (III) S is avoided by an infinite string.
The goal is to prove that the infinite periodic string α = (x[i..j − 1]) ∞ avoids all partial strings in S. The first claim is that the string x[i..j − 1] k , for some k large enough, has the string x[i..j + − 1] as a prefix. Indeed, x[j + t] = x[i + t] for all t ∈ {0, . . . , − 1}, because y j = y i ; in other words, each symbol x[j + t] is equal to the symbol x[j + t − (j − i)] that is earlier by j − i positions. Therefore, ], for all t ∈ { , . . . , + (j − i) − 1}. Now, suppose that some partial string u ∈ S occurs in α. Then it occurs in the string x[i..j − 1] k beginning at some position p ∈ {1, . . . , j − i}. Since x[i..j + − 1] is a prefix of x[i..j − 1] k , the string u is also compatible with a substring of x[i..j + − 1] beginning at the same position p; and the latter string contains such a substring, because |u | . This proves the first implication. The two remaining implications are trivial. Lemma 2.1 suggests an obvious algorithm for testing partial string avoidability, that is, by trying all finite strings of length |Σ| + and checking whether any of them avoids S. This takes double exponential time, and can be improved to nondeterministic single exponential time by guessing a single finite string. However, the problem is known to be easier. Sketch of a proof. Let S ⊆ (Σ ∪ { }) * be a finite set of partial strings, and let k = max w ∈S |w | be the maximal length of these strings. Consider a directed graph with the set of vertices {0, 1} k , which has an arc from u ∈ {0, 1} k to v ∈ {0, 1} k , if the string uv contains no forbidden substrings from S. An infinite string avoiding all substrings from S exists if and only if there is a cycle in the graph. A polynomial-space nondeterministic Turing machine can guess this cycle by walking over the graph.
In addition, Blanchet-Sadri et al. [8] proved that the partial string avoidability problem is NPhard, but its exact complexity remained open. In this article, it is established that this problem is actually PSPACE-complete.
Another interesting question raised by Blanchet-Sadri et al. [8] is whether the length of the period in Lemma 2.1(II) could be reduced to polynomial. A negative answer to this question, presented in Section 3, is a starting point for the subsequent PSPACE-completeness argument.
Yet another property that is worth mentioning is that the partial string avoidability problem is reducible to the partial string avoidability problem over the alphabet {0, 1}. Lemma 2.3 (Blakeley et al. [7,Theorem 7]). For every set of partial strings S over an alphabet Σ, there exists a set of partial strings S over {0, 1} with the following properties: (1) S is avoidable if and only if S is avoidable; (2) there is a bijection between infinite strings avoiding S and infinite strings avoiding S , which maps a string with period of p avoiding S to a string with period p · O (log 2 |Σ|) avoiding S ; (3) given S, the set S can be constructed in time polynomial in the total length of all strings in S and in the size of Σ.
In particular, this encoding allows an instance of the partial string avoidability problem to be interpreted as a logical formula, and opens the study of its proof complexity aspects.

THE PSPACE-HARDNESS PROOF
In this section, PSPACE-hardness of the partial string avoidability problem is shown by describing computation histories of a space-bounded Turing machine by a finite set of prohibited partial strings. The simulation relies on a timer represented as a counter that counts the number of steps the machine has passed.
The first goal is to describe such a counter. To be precise, the aim is to construct, for any given k 1, a set of partial strings that will be avoided by a unique infinite string-a string of the form (α 0 . . . α 2 k −1 ) ∞ , where each substring α i encodes the number i and is of length around k. The desired set of forbidden partial strings should ensure that there are no deviations from this order, and the counter is incremented modulo 2 k at each step. The total length of partial strings in this set should be polynomial in k.
Before presenting a complete solution to this problem, it is convenient to begin with a simplified construction, which does not work as it is, but conveys the overall idea of the method. Let the alphabet be Σ = {0, 1, #}, and let every counter value be represented by a block of k digits, followed by a separator (#). Then the desired infinite string shall be of the following form: The prohibited partial strings that ensure incrementation of the counter are defined as follows.
First, the values of the least significant digit should alternate at every step. To ensure that, it is sufficient to prohibit their staying constant, which is expressed by two partial strings, 0# k−1 0# and 1# k−1 1#. Next, the carry should be propagated toward higher digits. This is governed by half a dozen rules that express all cases of incorrect handling of digits. For instance, the partial string 01 k−1 00 is prohibited, because the digit 1 has been changed to 0 at the next step, and therefore the digit in the higher position should be incremented, but it is not. Such rules indeed implement counter incrementation. A few more prohibited partial strings, such as # k 0, request that each instance of the separator (#) must be followed by another separator after k positions. A family of partial strings # i #, for all i between 0 and k − 1, ensures that the separator symbol cannot appear more often than that. However, the problem is, that the existence of the separator cannot be guaranteed in this way. In particular, the string 0 ∞ perfectly avoids all these prohibited strings.
This first unsuccessful attempt motivates the following more elaborate construction, where a larger alphabet is used to ensure that the infinite string is arranged into blocks of k digits each; the rest follows the above plan.
Example 3.1. For every k 1, let the alphabet be Σ = {0, 1} × {1, . . . , k }, where a symbol (d, i) ∈ Σ indicates a digit d stationed at offset i within its block of k digits. Then, there exists a set of partial strings of total length Θ(k 2 ) that is avoided by the following unique infinite string: Proof. The first task is to ensure that all positions in the infinite string are correctly numbered. This is implemented by the following Θ(k 2 ) prohibited partial strings of length 2 each, which list all possible mistakes in the numbering: The correctness of incrementing the counter at each step is ensured by the following forbidden strings. Each of them refers to the corresponding digits of two subsequent counter values, which are k + 1 positions apart. First, 0 and 1 alternate in the least significant digit: Next, for each subsequent digit, consider the quadruple formed of (a) the two consequent digits de in the counter to the left and (b) the two digits d e in the same positions in the counter to the right.
The first group of prohibited partial strings ensures that for every infinite string α over Σ avoiding all these partial strings, the second components of its symbols must form the string Then, the remaining prohibited partial strings specify that if α i encodes the number j, then α i+1 encodes the number j + 1 modulo k, whereas α i−1 encodes the number j − 1 modulo k. This leaves the desired infinite string as the only one avoiding the given partial strings.
Example 3.1, in particular, constitutes a negative answer to a question by Blanchet-Sadri et al. [8,Section 4], as the set S is not avoided by any periodic infinite string with a period of subexponential length. Furthermore, applying Lemma 2.3 to the set in Example 3.1 yields such a set over a two-symbol alphabet. More importantly, the construction in Example 3.1 serves as a base for the PSPACE-hardness construction given in the rest of this section.
Let L be any language in PSPACE. This means that there exists a one-tape Turing machine M and a polynomial s ( ), such that on any input string of length , the machine M uses space at most s ( ) and eventually halts in an accepting state, if the input is in L, or in a rejecting state otherwise. The proof of the PSPACE-hardness result relies on the following encoding of M within an instance of the partial string avoidability problem. Lemma 3.2. Let M be a Turing machine that uses at most s ( ) space on inputs of length . Further, assume that M is modified, so that, instead of halting in a rejecting state, it loops without using any additional space. Let w ∈ Σ be any input string. Then, there exists an alphabet Ω and a finite set of partial strings P ⊂ (Ω ∪ { }) * , such that the Turing machine loops on w if and only if there exists a two-sided infinite string α ∈ Ω ∞ that avoids all partial strings in P. Given a machine, the set P can be constructed in time polynomial in s ( ).
Consider computation histories of a Turing machine, where its configurations are written one after another. The general plan is to use forbidden strings to ensure that each listed configuration is the successor of the previously listed one. If the Turing machine loops, then there is an infinite string containing its infinite computation. A final configuration has no successor, so if it is ever reached, then the list of configurations cannot be continued to an infinite string.
However, there is a problem with this idea. If a Turing machine loops on the input, then it loops starting from its initial configuration. But there can also exist some looping computations beginning from unreachable configurations. These computations give rise to undesired infinite strings that avoid all the constraints.
This problem can be circumvented in the following way. Let the Turing machine be augmented with an alarm clock containing a counter that is incremented at every step. The time until the alarm is triggered must be long enough for any accepting computation to terminate. Then, once the counter overflows, this means that the machine has looped, and the alarm clock resets the machine to its initial configuration. This shall ensure that if the machine does not loop starting from the initial configuration, then there is no infinite string satisfying these constraints.
Let the Turing machine be T = (Σ, Γ, Q, q 0 , δ, q acc ), where Σ is an input alphabet; Γ is a tape alphabet, with Σ ⊆ Γ; Q is a finite set of states, q 0 ∈ Q is the initial state, δ : is the transition function, and q acc ∈ Q is the accepting state. The transition function is completely defined, and it cannot move beyond the end-markers. The machine operates on a tape containing n = s ( ) symbols from Γ enclosed between left and right end-markers ( , ). The machine cannot move beyond the end-markers; there is no loss of generality in this assumption, because the machine is, by definition, space-bounded. Then the machine has (n + 2) · |Q | · |Γ| n possible configurations. Attached to the tape, there is a separate k-bit counter, with k = log 2 (n + 2) + log 2 |Q | + n log 2 |Γ| + 1 , that is, with 2 k greater than the number of possible configurations. This information is encoded in a (n + k + 2)-symbol block that consists of a Turing machine configuration (n + 2 symbols) and of the alarm clock's counter (k digits).
Each symbol in the block is of the form (X , i), where i ∈ {0, . . . , n + k + 1} is a number of the position in the block, and X is a payload, to be defined later. The Turing machine tape is encoded in positions 0, . . . , n + 1, and the counter is in positions n + 2, . . . , n + k + 1.
For each symbol used for encoding the tape, the payload is a triple (a, q, f ), where a ∈ Γ ∪ { , } is a tape symbol, q ∈ Q ∪ {−} is either a state of the Turing machine (if the head is at this square) or a minus sign (if the head is elsewhere), while the third component f ∈ {n, r} is a flag used for restarting the machine.
In each position used for the counter, the payload is any of the two digits: zero (0) and one (1). Altogether, the following alphabet is used: Some of the symbols in Ω are actually unnecessary. These symbols shall be identified in the proof, and then they can either be removed from the alphabet, or, equivalently, they can be listed as 1-symbol forbidden strings. In this proof, the set of forbidden substrings P is constructed gradually, with each instalment of substrings ensuring further properties of any infinite string avoiding those substrings.
The first step of the construction is to ensure that the infinite string consists of blocks of length n + k + 2, each correctly split into n + 2 tape symbols and k counter digits, and with all positions in the block correctly numbered. The correct order of position numbers is ensured by the following forbidden strings of length 2; they are generally the same as the first group in Example 3.1: where (X , i), (Y , j) ∈ Ω, and i + 1 j (mod n + k + 2).
For the tape to be well-formed, it remains to check the position of end-markers, namely, that they occur at the beginning and at the end of the tape, and nowhere else, that is, the tape contains a string from Γ n . This can be ensured by removing the following invalid symbols from the alphabet: Alternatively, they can be listed as one-symbol forbidden strings. Altogether, the forbidden strings added to P so far ensure the following property. Claim 3.3. If a two-sided infinite string contains no forbidden substrings from P, then it is of the form . . . α −1 α 0 α 1 α 2 . . . α . . ., where each α i is a string of the following form, for some tape symbols a 1 , . . . , a n ∈ Γ, states p 0 , . . . ,p n+1 ∈ Q ∪ {−}, flags f 0 , . . . , f n+1 ∈ {n, r} and counter digits d 0 , . . . ,d k−1 ∈ {0, 1}: a n , p n , f n , n)( , p n+1 , f n+1 , n + 1)(d k−1 , n + 2) . . . (d 0 , n + k + 1).
With the enumeration of positions in place, the next step is to implement the alarm clock. It is based on the same k-bit binary counter as in Example 3.1, with the least significant digit in position n + k + 1 and with the most significant digit in position n + 2. The counter is incremented at every step, and resets to zero upon overflow.
The forbidden partial strings implementing this behaviour are exactly the same as in Example 3.1. First, 0 and 1 alternate in the least significant digit: where dd ∈ {00, 11}.
Every next digit is defined by the same function f (d, e, e ) as in Example 3.1, and the following forbidden strings, each of length n + k + 4, are defined: Every time the counter overflows, the alarm clock sends a restart signal to the left into the Turing machine tape. The signal is represented by the restart flag (r) raised in the third components of all symbols.
The first group of forbidden strings ensures that the restart signal is sent whenever the counter overflow has occurred, that is, whenever the most significant digit of the counter changes from 1 to 0. The following forbidden partial strings describe the case when there is an overflow, but the signal does not start: for all a and q.
The second situation to forbid is when there is no overflow, but the signal starts, which is ensured by the following forbidden strings: where dd 10, for all a and q.
The propagation of the signal over the tape is defined by the following rules ensuring that it never disappears and never appears from nowhere: , n}, f f , for all a , a, and q.
The above forbidden strings ensure the following property of the restart signal propagation.
Claim 3.5. In every block α i , if i 0 (mod 2 k ), then each tape square is marked as normal (n). If i = 0 (mod 2 k ), then each tape square has a restart flag (r).
The next group of restrictions specifies that if the restart signal sweeps over the tape in some block, then at the same time the Turing machine configuration is overwritten with its initial configuration. This is implemented by the following one-symbol forbidden strings (alternatively, these symbols may be excluded from the alphabet): Here the space ("␣") is a special tape symbol used to pad the input string of length to n = s ( ) tape squares.

Claim 3.6. If a restart occurs in a block, then this block contains the initial configuration of the Turing machine on the input string w.
The last group of forbidden strings ensures the simulation of the Turing machine's transitions in normal situations, when no reset takes place. Every tape square in a configuration depends on three squares in the previous configuration: namely, on the same square, its left neighbour and its right neighbour. This dependence is ensured by prohibiting all mismatches.
First, if the head is not at a square and in its neighbourhood, then the tape symbol at this square must be copied to the next configuration: strings with mismatched symbols are prohibited, This rule has special cases for the first and for the last tape squares: here the end-marker in the square cannot be rewritten, but one should still make sure that another head can never appear out of nowhere: If the head is nearby, then the following restrictions ensure that nothing can happen contrary to the Turing machine transitions. Consider a state q ∈ Q and a symbol b ∈ Γ with δ (q, b) = (s, σ , −1). The next forbidden string ensures that the machine correctly overwrites the symbol and moves to the left in the new state: Another rule requires that the square to the right of this b remains unaffected: The rules for a state q ∈ Q and a symbol b ∈ Γ, with δ (q, b) = (s, σ , +1), are defined symmetrically: Claim 3.7. If a block contains a syntactically correct Turing machine configuration, and no reset occurs at the subsequent block, then the subsequent block contains a syntactically correct configuration at the next step.
It remains to prohibit all one-symbol strings involving the accepting state, so that only strings not containing an accepting configuration would avoid P: for all a and i.
This completes the construction of the set of forbidden strings P that satisfies the lemma.
Proof of Lemma 3.2. Assume that T loops on w. It is claimed that there exists a two-sided infinite string that avoids all partial strings from P. This is the string (α 0 α 1 . . . α 2 k −1 ) ∞ , defined as follows. The string α 0 corresponds to the Turing machine's initial configuration containing the input string w, with a restart flag (r) in all squares, and with the counter set to zero. Each string α i , with 1 i 2 k − 1, represents the Turing machine configuration at the ith step, with no restart (n) in any square, and with an attached counter with value i. Since the machine loops, it is possible to make as many such steps as needed. At the boundary between the strings α 2 k −1 and α 0 , the counter overflows and all the squares are marked with a restart flag (r).
Suppose that T does not loop on w, but there exists an infinite string s that avoids all partial substrings from P. By Claim 3.3, the string s must be of the form . . . α −1 α 0 α 1 . . . , where every block α i contains a Turing machine configuration and a counter value. Then, according to Claim 3.3, in each pair of neighbouring blocks, α i and α i+1 , the value of the counter is different by 1 modulo 2 k . Eventually, some block will have value 0 in the counter, and then, by Claim 3.5, all tape squares in this block are labelled with the restart flag (r). Furthermore, Claim 3.6 asserts that the machine is in the initial configuration in this block, with the string w written on the tape. According to Claim 3.7, the next 2 k − 1 blocks simply simulate 2 k − 1 steps of the Turing machine. However, since T halts on w, by the choice of k, it does so in fewer than 2 k steps, and at some point the supposed infinite string cannot be continued. Therefore, such a string does not exist.
The set P contains O (n 2 ) partial strings, each of length O (n). Therefore, their total length is polynomial in , and, following the above description, they can be effectively written down in polynomial time.
Now the main result of this article follows from Lemma 3.2 applied to a Turing machine recognizing any PSPACE-complete set.
Theorem 3.8. The partial string avoidability problem is PSPACE-complete. It remains PSPACEcomplete if the alphabet is fixed to be binary.
Proof. The problem is in PSPACE by Lemma 2.2, and it remains to prove that it is PSPACE-hard. Let L be any set in PSPACE, and let M be a polynomial-space Turing machine that recognizes L. Then, by Lemma 3.2, the membership problem in L can be reduced in polynomial time to the partial string avoidability problem. Therefore, the latter is PSPACE-complete by definition.
By Lemma 2.3, the partial string avoidability problem over an arbitrary alphabet is reduced to the same problem over the binary alphabet, which makes the latter PSPACE-complete as well.

RESOLUTION PROOFS WITH SHIFT
As outlined in the Introduction, the avoidability problem over a binary alphabet Σ = {0, 1} can be treated as a logical question. Let Γ = {x i } i ∈Z be the set of numbered Boolean variables. Any variable x i or its negation ¬x i is called a literal; a literal of an unknown sign can be denoted by A clause is a disjunction of finitely many literals, such as x 1 ∨ ¬x 4 . A clause is shifted by adding the same integer to all variable indices. The conjunction of all shifts of a clause C is denoted by Shifts(C) and called a moveable clause. For instance, in the above example, Shifts( A conjunctive normal form (CNF) formula φ is a conjunction of finitely many clauses, and it accordingly depends on finitely many variables. From the perspective of proof systems, it may be regarded as a finite set of clauses. If these clauses are replaced with the corresponding moveable clauses, then the resulting formula, denoted by Shifts(φ), is called a Shift-CNF. A CNF, or a Shift-CNF, is said to be satisfiable, if, for some assignment of Boolean values to the variables, all its clauses hold true.
In terms of strings, a clause is a partial string that lists all values that make its literals false, with holes instead of the unused variables. A clause is matched at a specific position in the string, whereas a moveable clause means that a string is matched at all positions. For example, the above moveable clause Shifts(x 1 ∨ ¬x 4 ) may be regarded as a forbidden partial string 0 1. If all the listed values hold at once, then the clause is false. Accordingly, avoidance of all partial strings representing the moveable clauses in a Shift-CNF is equivalent to its satisfiability. Remark 4.1. In view of this equivalence, Lemma 2.1 states that satisfiability of a Shift-CNF can be tested by considering finitely many shifts of each moveable clause-namely, those involving the variables x 1 , x 2 , . . . , x 2 + .
Unsatisfiability of sets of clauses can be proved using proof systems. A refutation of a set of clauses in the Resolution proof system is a sequence of clauses C 1 , C 2 , . . . ,C s , where C s is the empty clause (false), and each clause C i , with i ∈ {0, . . . , s − 1}, is either a clause from the given set, or is derived from some earlier clauses using the weakening rule or the resolution rule. By the weakening rule, a clause C ∨ D is derived from a clause C by adding any extra literals D. The resolution rule is applied to a pair of clauses x ∨ C and ¬x ∨ D, where x is a variable, deriving the clause C ∨ D. The length of a Resolution proof is the number of clauses therein. For an unsatisfiable formula φ, the length of its shortest Resolution refutation is denoted by S Res (φ).
The following estimation of the length of Resolution proofs is well-known.
Lemma 4.2. Let F be an unsatisfiable CNF formula, and let x be its variable.
To construct Resolution refutations, sometimes it is convenient to use read-once branching programs. A read-once branching program (1-BP) for an unsatisfiable CNF formula F with variables x 1 , x 2 , . . . , x n is a directed acyclic graph with one source and several sinks, such that: (1) all sinks are labelled with clauses of F ; (2) all other nodes are labelled with variables of F , and each of them has two outgoing edges, one labelled with 0 and the other labelled with 1; (3) for every path from the source to a sink, every variable appears as a label of non-sink node at most once; (4) for every path p from the source to a sink, if nodes of p are labelled with variables x i 1 , . . . , x i s , edges are labelled with values α 1 , α 2 , . . . , α s and the sink at the end of p is labelled with a clause C, then the restriction An example of a 1-BP is given in Figure 1 There is a known connection between resolution proofs and read-once branching programs. The definition of Resolution proofs equally applies to infinite sets of clauses. It is known that a set of clauses, finite or infinite, has a Resolution refutation if and only if that set is unsatisfiable. For infinite sets of clauses, this result generally holds by the compactness theorem, although it gives no estimations of the size of a refutation. For infinite formulas of the form Shifts(φ) studied in this article, there is the following upper bound on the length of their Resolution refutations. Lemma 4.4. Let an unsatisfiable CNF formula F depend on variables x 1 , x 2 , . . . , x T , and assume that every clause of F depends on variables whose indices differ by at most k. Then, F has a regular resolution refutation consisting of at most 2 k T + 1 clauses.
Proof. By Theorem 4.3, it is sufficient to create a 1-BP of size 2 k T + 1 for F . We describe this 1-BP. Informally, the 1-BP scans all variables from left to right, keeping a buffer of the last k variables. Considering a value of a next variable it checks the buffer supplied with the value of the last variable against the clauses that fully depend on the variables in the buffer and the last considered variable, and terminates if any of them has been violated. As long as all clauses are of size less than k + 1, the 1-BP shall check all of them and eventually find a falsified one.
not exist, then we assume that it has value "undefined." One can say that the branching program has a buffer for the values of the last k variables.
The first level contains exactly one source node labelled with x 1 : there is nothing in the buffer yet. If a node labelled with x i stores values thus discarded from the buffer, and the new variable x i is added.
By the construction, we get a correct 1-BP for F of size at most 1 + 2 k T . Making an assignment of k + 1 consequent variables is sufficient to falsify each clause, because the indices of variables differ by at most k.
Returning to the avoidability problem for partial strings w 1 , w 2 , . . . ,w m , Lemma 2.1 implies that the avoidability test is given by a CNF with 2 k + k consecutive variables, where k = max i |w i |. Then, by Lemma 4.4, this formula has a Resolution refutation of size O (2 2k ).  For the Resolution method for Shift-CNF formulas, there is a natural derivation rule to be added: the shifting rule, by which, from any clause i 2 +n ∨ · · · ∨ x σ k i k +n , for any n ∈ Z. In the resulting system, called Shift-Resolution, one can prove only statements provable in the classical Resolution. Indeed, every application of the shifting rule can be eliminated by deriving each shifted clause from scratch: this is possible, because the formula contains all shifts of the original clauses. However, as will be shown in Section 4.2, there is a formula, for which a Shift-Resolution proof is exponentially shorter than any classical proofs.

Translation of Lower Bounds
Lower bounds on the size of proofs with shifting can be inferred from the known lower bounds on classical proofs, as follows. Let φ n be an unsatisfiable CNF formula in variables x 1 , . . . , x n . This formula shall be encoded in a Shift-CNF formula Φ n , in a way that from any Shift-Resolution proof of Φ n , one could extract a classical Resolution proof of φ n , which might be a little larger, but not much. Then, every known lower bound on the size a Resolution proof of φ n translates to a lower bound on the size of Shift-Resolution proof of Φ n .
The general idea of encoding a CNF formula φ in a Shift-CNF Φ is that every satisfying assignment x 1 , . . . , x n to φ should be repeated as something like an infinite binary string (x 1 . . . x n ) ∞ representing a satisfying assignment to Φ. The main challenge is that φ is not designed to be shifted, and therefore Φ should somehow apply φ only to every nth substring of length n, that is, x 1 . . . x n , and not to any improperly shifted substrings Since, by definition, shifted formulas apply to all shifts, this selective evaluation is not possible, and it is necessary to use some kind of encoding that would disable all unintended shifts.
The proposed encoding of φ represents each of its variables x i as four consecutive Boolean variables: y 4i+1 , y 4i+2 , y 4i+3 , and y 4i+4 . The first three of them shall always have values 011, whereas the last variable, y 4i+4 , holds the actual value of x i . To distinguish the encoded variable x 1 , a special separator code 0100 is inserted between every two complete blocks of n encoded variables.
The formula Φ n is a conjunction of two parts: The first part W n ensures that the infinite string representing the variable values is a valid encoding of the form described above, while H n simulates φ over that encoding.
The formulaW n has to verify that an infinite string is of the form (${ 0, 1} n ) ∞ , where $ = 0100, 0 = 0110 and 1 = 0111. The first task toward this goal is to define all sequences of the form {$, 0, 1} ∞ . This is done by nine constraints (Shift-CNF clauses). First, all substrings of length 5 that do not contain the control pair 01 are forbidden: namely, 11111, 11110, 11100, 11000, 10000, and 00000. Two more forbidden partial substrings 01 1 and 01 00 ensure that for each control pair 01, after two symbols, there cannot be anything except another control pair 01. The last forbidden substring 0101 makes sure that the data digits between two control pairs cannot be 01.
It remains to ensure that separators ($) never occur close to each other, and that there is a separator after every n encoded digits. The former is done by adding n forbidden partial strings 0100 4k 0100, for all k ∈ {0, . . . , n − 1}, and the existence of separators is asserted by prohibiting n + 1 subsequent encoded digits using a partial string (011 ) n+1 . This completes the formula W n .
The second part of the formula, denoted by H n , contains as many clauses as φ n . Whenever φ n contains a clause x σ 1 i 1 ∨ . . . ∨ x σ k i k , it is represented in H n by the following corresponding clause: y 1 ∨ ¬y 2 ∨ y 3 ∨ y 4 D $ : false only on 0100 ($) .
The disjunction of the first four literals is true, unless there is a substring 0100 there, that is, the separator ($). For that reason, any unintended shifts of this clause hold true, and are therefore irrelevant. On a correct shift, the first four literals are false, and the rest, denoted by p(C), correctly apply the original clause C to the encoded variables of φ n . Each satisfying assignment to the Shift-CNF formula Shifts(W n ∧ H n ) encodes at least one satisfying assignment to the original CNF formula φ, and since the latter is unsatisfiable by assumption, so is Shifts(W n ∧ H n ). The proof consists of two parts. First, a Shift-Resolution refutation of Shifts(W n ∧ H n ) is transformed to a Resolution refutation of the same formula, by mapping each variable y i , with i ∈ Z, to y (i mod 4n+4) and then eliminating the shift rules. Then the latter Resolution refutation of Shifts(W n ∧ H n ) is transformed by substituting the sequence $(011 ) n into all auxiliary variables, resulting in a Resolution refutation of φ n of the stated size.
These transformations of Resolution refutations are based on the following lemma.  Proof. The case of the weakening rule is straightforward. Consider the resolution rule, with a clause C ∨ D derived from x ∨ C and ¬x ∨ D. If the variable the substitution is made into is not x, then this resolution remains correct after the substitution. If the substitution is made into x, and it replaces it with another variable y, then the resolution also remains correct. If x is substituted with 0, then the clause x ∨ C becomes C, and the clause C ∨ D can now be derived from C using the weakening rule. The case of substituting x with 1 is handled analogously, with the clause ¬x ∨ D becoming D.
To prove the second part, it is sufficient to show that if all constant true clauses are removed from the refutation, then it remains a refutation. The empty clause is not satisfiable, and therefore remains in the proof. Weakening of a constant true clause is constant true. If both premises of a resolution rule are constant true, then the resolvent is constant true as well. If one of the premises is constant true (that is, contains x ∨ ¬x or contains x a and τ is x a := 1) and the resolution is made by a variable other than x, then the resolvent is constant true (still contains x ∨ ¬x or contains x a and τ is x a := 1). If the resolution is made by x, then the resolvent is obtained by applying weakening to the second premise.
Proof of Theorem 4.6. Consider any refutation π of Shifts(W n ∧ H n ) in the Shift-Resolution proof system, and let λ n be its length. Let σ be a substitution that maps each variable y i , with i ∈ Z, to the variable y (i mod m) , where m = 4(n + 1). Then, π [σ ] denotes the sequence of clauses in π under the substitution σ . By Lemma 4.7 (part 1), every time the resolution rule or the weakening rules are used in π , this use remains valid in π [σ ]. To complete the transformation of the proof π [σ ] into a Resolution refutation of the formula Shifts(W n ∧ H n )[σ ], one should eliminate the shift rules.
In fact, under the substitution σ , every application of the shifting rule turns into a cyclic shift. There are at most m distinct cyclic shifts of every clause C with variables from {y 0 , y 1 , . . . ,y m−1 }. Hence, instead of using the shifting rule, one can derive each cyclic shift of every clause along with deriving that clause. The number of clauses thus increases at most m-fold.
Let π be the refutation of the formula Shifts(W n ∧ H n )[σ ], obtained from π [σ ] by replacing every shifting rule with derivations of cyclic shifts of all clauses. Then, as noted above, π is of size at most mλ n . Consider a substitution τ into π , defined by y 0 . . . Thus, a Resolution refutation of φ n of size at most mλ n has been obtained. Therefore, λ n Ω( Proof. It is sufficient to take any family of formulas with Resolution proof complexity 2 Ω(n) . Such a family is constructed, for instance, by Urquhart [18].

Shifts Make Proof Systems Stronger
In this section, it is shown that, in some cases, Shift-Resolution can be exponentially more succinct than classical proof systems without shifts. This is proved by presenting a certain false formula, which has a small refutation in Shift-Resolution, whereas in classical proof systems, it requires exponential-size refutations.
For a constant n 1, the formula Ψ n asserts the existence of an infinite string of the form . . . $w −1 $w 0 $w 1 . . ., where each w i is an n-digit binary notation of a certain natural number, and every subsequent number in the list is greater by 1 than the previous number. For every number i ∈ {0, . . . , 2 n − 1}, let bin(i) ∈ {0, 1} n be its n-bit binary representation. The longest finite string, on which this formula is true, is $bin(0)$bin(1)$ . . . $bin(2 n − 1)$, but for any longer string, in particular for any infinite string, the counter eventually overflows and the formula becomes false. In view of Lemma 2.1, this formula contains a finite set of contradictory clauses, and hence is subject to classical proof methods.
The construction of the formula is based on the encoding of digits and separators given in Section 4.1. In particular, the formula Shifts(W n ) ensuring that the infinite string is of the form (${ 0, 1} n ) ∞ , where $ = 0100, 0 = 0110 and 1 = 0111, is used again, and so is the clause D $ = y 1 ∨ ¬y 2 ∨ y 3 ∨ y 4 that identifies a separator ($) beginning at y 1 .
With the syntactic structure defined by the formula W n , the desired counter is implemented by a CNF formula Step n k (x 1 , . . . , x n ; y 1 , . . . ,y n ), with n 1 and k ∈ {0, 1, 2, . . . , n − 1}, which is true if and only if the binary number (x 1 . . . x n ) 2 is greater than (y 1 . . . y n ) 2 exactly by 2 k . This CNF formula contains O(n) clauses of constant size, which implement the following conditions.
(1) x n− = y n− for all 0 < k, that is, the addition of 2 k does not affect any digits in positions from 0 to k − 1.
(2) x n−k y n−k , that is, the addition of 2 k always changes the kth digit.
, for all i with n − k − 1 i 2: This means that if there is no carry in position (n − i + 1)th, then there is no carry in the next position either.
, for all i with n − k − 1 i 2: This shows the case when the last incremented digit is in position n + 1 − i, and in the next position, there is no carry anymore.
has not yet finished in position n + 1 − i, then there is a carry to the next position.
Each condition depends on a constant number of variables, and therefore can be transcribed as a CNF formula of constant size. There are O (n) conditions in total, so that the whole formula is of the claimed size. Given two propositions, Step n k (x 1 , . . . , x n ; y 1 , . . . ,y n ) and Step n k (y 1 , . . . ,y n ; z 1 , . . . , z n ), one asserting that x + 2 k = y and the other that y + 2 k = z, one can infer from them that x + 2 k+1 = z, that is, the proposition Step n k+1 (x 1 , . . . , x n ; z 1 , . . . , z n ). The next lemma formalizes this intuition, and shows that this inference can be carried out using resolutions. Proof. The proof relies on the implicational completeness of resolutions, which means that if a clause semantically follows from a set of clauses, then this clause can be derived from them using the weakening and the resolution rules. This property will be invoked O (n) times for different clauses, and each time all the clauses involved depend on a constant number of variables. Hence, the size of every such derivation shall always be bounded by a constant.
All conditions from the definition of the formula Step n k+1 (x 1 , . . . , x n ; z 1 , . . . , z n ) are derived one by one, as follows.
(1) For each with 0 < k, the equality x n− = z n− is implied by the equalities x n− = y n− and y n− = z n− (condition 1). For = k, it follows from x n−k y n−k and y n−k z n−k (condition 2).
(2) For x n−k−1 z n−k−1 , since x n−k y n−k and y n−k z n−k , there are two cases: x n−k = z n−k < y n−k and x n−k = z n−k > y n−k . In the former case, condition 4 implies x n−k−1 = y n−k−1 , and condition 5 implies z n−k−1 y n−k−1 . In the latter case, condition 4 implies z n−k−1 = y n−k−1 , and condition 5 implies , and therefore this case is impossible.
There are two cases: • if x i = y i < z i , then x i−1 = y i−1 by condition 3 and z i−1 = y i−1 by condition 4; • if x i < y i = z i , then x i−1 = y i−1 by condition 4 and z i−1 = y i−1 by condition 3.
Consider the two cases: •   Proof. The formula is false, because Shifts(W n ) requires the existence of a separator ($), while D $ states that the separator may not occur anywhere.
The resolution refutation of this formula consists of 32 pieces corresponding to different values of the variables x 1 , . . . , x 5 . The pieces are constructed by a case analysis, and once a contradiction is established in each case, the full resolution derivation is obtained using Lemma 4.2.
In each case where x 1 x 2 x 3 x 4 x 5 does not contain a substring 01, the formula Shifts(W n ) contains clauses that forbid such substrings, and therefore, once these values are substituted into the formula, those clauses turn into contradictions. If the substring 01 exists, then let a ∈ {1, 2, 3, 4} be the position where it occurs, with x a = 0 and x a+1 = 1. The clause shift a−1 (D $ ) forbids the substring 0100, Shifts(W n ) contains a clause that forbids 0101, hence one may derive the clause x a+2 . Using the clauses that forbid 01 1 and 01 00, one may derive ¬x a+4 and x a+5 . Similarly, one may derive x a+6 and so on. Thus, all clauses ¬x a+4k , x a+4k+1 and x a+4k+2 are derived for all k with 0 k n. Then, by the clause that forbids the partial string (011 ) n+1 , a contradiction is obtained.
Denote m = 4n + 4: This is the number of variables used to encode one counter value and one separator.
For every CNF formula φ = C 1 ∧ . . . ∧ C k and for every clause D, the CNF formula obtained from φ by adding all literals from D into every clause is denoted by Furthermore, denote by V n a CNF formula containing the following clauses, which assert that after the current separator ($), there is another one m symbols later: D $ ∨ ¬x m+1 , D $ ∨ x m+2 , D $ ∨ ¬x m+3 and D $ ∨ ¬x m+4 . These conditions actually follow from W n , but it is more convenient to add them than to derive them using Resolution.
In this notation, the formula separating classical proof systems from Shift-Resolution is constructed as follows: . The first part of Ψ n is W n , which enforces the syntactic structure of the string. The second part (D $ ∨ Step n 0 (x 8 , x 12 , . . . , x 4n+4 ; x 4n+12 , x 4n+16 , . . . , x 8n+8 ) states that any two subsequent values of the counter differ by 1. The last part (D $ ∨ ¬x 8 ), requires the highest digit of the counter to be 0. The formula Ψ n is unsatisfiable, because, after a series of incrementations, the highest digit shall eventually become 1. The lower bound on the size of any refutations of Ψ n is based on the fact that every such refutation must use more than 1 3 2 n−2 clauses of this formula. Lemma 4.12. The conjunction of any 1 3 2 n−2 clauses of Ψ n is a satisfiable formula. Proof. Let C 1 , C 2 , . . . ,C k be all clauses of Ψ n , where k 1 3 2 n−2 , and assume that their conjunction is unsatisfiable. It can be additionally assumed that, upon removal of any of these clauses, the formula becomes satisfiable.
Let j be the minimal index of a variable occurring in the clauses C 1 , C 2 , . . . ,C k . Beginning with this variable, let the set of variables be split into blocks of m variables each, so that each th block consists of the variables x j+ m−m , . . . , x j+ m−1 . A clause C is said to touch a block, if the block contains at least one of the variables {x t , x t +1 , . . . , x T }, where t is the least index of a variable in C, while T is the greatest index. For every clause from Ψ n , the difference between T and t does not exceed 2m, and therefore every clause touches at most three blocks.
Note that there cannot exist an untouched block, with touched blocks both to the left and to the right of it. Indeed, if this were the case, then the conjunction of the selected clauses could be split into a conjunction of two formulas in disjoint sets of variables. Therefore, the selected unsatisfiable set of clauses would not be minimal.
Proof of Theorem 4.11. The lower bound on the size of Resolution proofs follows from Lemma 4.12.
The key element of a small Shift-Resolution refutation of Ψ n is the use of Lemma 4.9. The formula contains a clause about incrementing the counter by 1; by Lemma 4.9, it can be shifted, and two such clauses resolved, to obtain a clause about incrementing by 2. The latter clause can be again shifted and resolved, resulting in a clause about adding 4, and so on. This gives a proof of an appropriate Step n n−1 formula, in Θ(n) steps. A contradiction is obtained by resolving that formula with other clauses of Ψ n . Proof. Consider the proof for = 0. The formula Shifts(V n ) contains the clause shift m (D $ ∨ ¬x m+1 ) = x m+1 ∨ ¬x m+2 ∨ x m+3 ∨ x m+4 ∨ ¬x 2m+1 . Applying the Resolution rule to the latter clause and to the clauses D $ ∨ ¬x m+1 , D $ ∨ x m+2 , D $ ∨ ¬x m+3 and D $ ∨ ¬x m+4 , in this order, yields the resolvent D $ ∨ ¬x 2m+1 . The clauses D $ ∨ x 2m+2 , D $ ∨ ¬x 2m+3 , and D $ ∨ ¬x 2m+4 are derived in a similar way.
By Lemma 4.10, the empty clause can be derived from Shifts(W n ∧ D $ ) in O (n) steps.

REFUTATIONAL PROOF SYSTEMS
In general, a proof line can be regarded as a predicate with variables substituted into it: a proof line of arity k is a pair of a predicate P : {0, 1} k → {0, 1} and a tuple (i 1 , i 2 , . . . , i k ) ∈ Z k . A proof line (P, (i 1 , i 2 , . . . , i k )) restricts possible values of variables true. Let L P be the set of proof lines defined by predicates from P.
Every refutational calculus Π operates with its own set of admissible predicates P used in the proof lines, along with a representation for these predicates. For example, for Resolution, P is the set of all disjunctions of literals.
Every refutational calculus has its own finite set of inference rules. Every inference rule of arity defines a set R ⊆ L +1 P such that if (Q, P 1 , P 2 , . . . , P ) ∈ R, then we may derive Q from P 1 , P 2 , . . . , P . All inference rules should be sound: For all (Q, P 1 , P 2 , . . . , P ) ∈ R, if an assignment satisfies all P 1 , P 2 , . . . , P , then it also satisfies Q.
A refutation of a CNF formula ϕ in a refutational calculus is a sequence of proof lines F 1 , F 2 , . . . , F s such that (1) for every j ∈ [s], F j either represents a clause of ϕ or can be obtained from F j 1 , . . . , F j , for some j 1 , . . . , j < j, by an inference rule; (2) F s is a constant false proof line. The size of a refutation is the size of representations of proof lines F 1 , F 2 , . . . , F s . Note that, in different calculi, the same proof line may have representations of different size. The length of a refutation is the number of proof lines in it.
If a formula ϕ has a refutation in a refutational calculus Π, then it is unsatisfiable (this follows by the soundness of inference rules). The minimal length of refutation of a formula ϕ is denoted by S Π (ϕ).
A refutational calculus Π must be complete, in the sense that every unsatisfiable formula has a refutation.
We say that a refutational calculus Π is a proof system (in the sense of Cook and Rekhow [10]) if there is an algorithm V (ϕ, w ) that verifies whether w is a correct Π-refutation of a CNF formula ϕ in poly(|ϕ | + |w |) steps. every refutation can be verified in time polynomial in size of the original formula and size of the refutation. Namely, for every clause one can compute the corresponding proof line; for every proof line, one can check whether it can be inferred from the earlier proof lines, and there is a special proof line representing constant false, which should be the last one in every refutation.
Similarly to how the Resolution proof system has been augmented to Shift-Resolution, one can define a "shifted" version of every proof system Π, denoted by Shift-Π. By the shifting rule, a proof line P (x i 1 , x i 2 , . . . , x i k ), can be shifted to P (x i 1 +n , x i 2 +n , . . . , x i k +n ), for every n ∈ Z.

Generalizations
Now, we will generalize results we have proved for Resolution to arbitrary refutational proof systems. In Section 4.2, we have shown that there is a sequence of formulas Ψ n that has no short Resolution refutation, but has short refutation in Shift-Resolution. In fact, Lemma 4.12 implies that those formulas are hard for any refutational calculus. And, by Theorem 4.11, for any refutational proof system Π that can polynomially simulate resolution rules, there are short refutations of these formulas in Shift-Π.
The lower bound method in Theorem 4.6 applies to a class of refutational calculi that satisfy Lemma 4.7, so that a lower bound on the size of a Π-proof of φ n , where Π is a proof system, implies a fairly close lower bound on the size of Shift-Π proofs for Shifts(W n ∧ H n ).

Then the length of any Shift-Π refutation of Shifts
The proof almost literally repeats that of Theorem 4.6, with every reference to Lemma 4.7 replaced by a reference to the conditions of this theorem. Proof. The proof uses a family of formulas with the Cutting Plane proof complexity 2 n Ω(1) . Such formulas were constructed by Pudlák [16]. Proof. The proof uses random k-CNF formulas, where k is a constant. By the results of Alekhnovich and Razborov [2] and of Impagliazzo et al. [12], every Polynomial Calculus derivation of random k-CNF formulas is of size at least 2 Ω(n) with high probability.

SHIFTED PROOF COMPLEXITY
Propositional proof complexity came into light as Cook's approach to the NP vs. co-NP problem. Proof complexity for quantified boolean formulas similarly applies to the NP vs. PSPACE problem. The shifted proof complexity, as introduced in this article, turns out to be another approach to separating NP from PSPACE, based on the PSPACE-completeness of the language of unsatisfiable Shift-CNF formulas, see Theorem 3.8.

Predicate Fill i
The arguments in this section are based on a particular predicate defined for a CNF formula φ. This predicate, called Fill i , expresses the satisfiability of Shi f ts (φ) on a large segment of variables.
Let n − 1 be the maximum difference between the variable indices in a single CNF clause. The following proposition Fill 0 (y 1 , . . . ,y n ; z 1 , . . . , z n ) determines whether every shift of every clause of φ is satisfied on a segment of 2n consecutive variables: For every k 1, the proposition Fill k (x 1 , . . . , x n ; x n2 k +1 , . . . , x n2 k +n ) asserts that there exists a binary string of length n · (2 k + 1) that begins with the digits x 1 . . . x n and ends with the digits x n2 n +1 . . . x n2 k +1 , such that every shift of every clause is satisfied on that string.
If the original Shifts(φ) is satisfiable, then Fill k is satisfiable for every k. If Shifts(φ) is unsatisfiable, then, by Remark 4.1, it is false on every string of 2 n + n variables, and therefore the proposition Fill n (y 1 , . . . ,y n ; z 1 , . . . , z n ) is unsatisfiable.
Proof. The proposition Fill k (x 1 , . . . , x n ; x n2 k +1 , . . . , x n2 k +n ) asserts that the values of all intermediate variables x i , with n + 1 i x n2 k , can be filled so that all clauses of the CNF hold true on all variables from x 1 to x n2 k +n The proposition Fill k (x n2 k +1 , . . . , x n2 k +n ; x n2 k +1 +1 , . . . , x n2 k +1 +n ) similarly asserts that the variables x i , with n2 k + n + 1 i n2 k+1 , can be filled to satisfy all the clauses on the variables from x n2 k +1 to x n2 k +1 +n . Now, all variables in the entire range from x 1 to x n2 k +1 +n can be filled with some values. Since, for every clause of the CNF, the indices of its variables differ by at most n, this means that this clause, applied to any variables in the range from x 1 to x n2 k +1 +n , entirely fits into one of the subranges, either from x 1 to x n2 k +n , or from x n2 k +1 to x n2 k +1 +n , and one of the two premises Fill k asserts that it is satisfied. Lemma 6.2. There exists a PSPACE algorithm for testing a given proposition Fill k (y 1 , . . . ,y n ; z 1 , . . . , z n ), for a given k poly(n).
Proof. According to Lemma 6.1, one can test whether Fill k is true on any given 2n variables by trying all values of the intermediate variables t 1 , . . . , t n and testing whether both Fill k−1 (y 1 , . . . ,y n ; t 1 , . . . , t n ) and Fill k−1 (t 1 , . . . , t n ; z 1 , . . . , z n ) are true. The depth of recursion is k, and n bits are used at each level, so that the procedure uses polynomial memory.

The Shifting Rule and the PSPACE vs. NP Problem
The language of unsatisfiable Shift-CNF formulas, denoted by Shift-UNSAT, is PSPACE-complete by Theorem 3.8. Hence, to prove that PSPACE NP, it is sufficient to prove that every nondeterministic algorithm solving this problem works in super-polynomial time on some formula. A stronger result proved in this article is that it is sufficient to prove this not for all nondeterministic algorithms, but for algorithms that guess a proof in a certain proof system, Shift-Π, where Π is a refutational proof system. Theorem 6.3. If PSPACE = NP, then there exists a proof system Π, such that every unsatisfiable Shift-CNF has a Shift-Π refutation of polynomial size.
Proof lines are derived in Π by the so-called semantic inference rule. The general goal is that, as long as two formulas (proof lines), φ(y 1 , . . . ,y n ) and φ (y 1 , . . . ,y n ), logically imply a formula ψ (y 1 , . . . ,y n , y 1 , . . . ,y n ), one can immediately infer the latter formula from these two premises. Of course, an inference rule should be effectively checkable, and these details shall be explained later on.
Using this kind of semantic inference, one can derive a contradiction as follows. First, Fill 0 is a conjunction of the clauses of the original formula, and hence semantically follows from those clauses. By Lemma 6.1, every next Fill k+1 (x 1 , . . . , x n ; x n2 k +1 +1 , . . . , x n2 k +1 +n ) is inferred from Fill k (x 1 , . . . , x n ; x n2 k +1 , . . . , x n2 k +n ) and Fill k (x n2 k +1 , . . . , x n2 k +n ; x n2 k +1 +1 , . . . , x n2 k +1 +n ), where the latter is obtained from the former by the shift rule. The formula Fill n is false, and one can obtain this by semantic derivation. Now, to make semantic inference effectively verifiable, it shall be represented as two inference rules, each checkable in polynomial time. Consider that the correctness of the desired implication φ ∧ φ → ψ , where φ, φ ,ψ are existentially quantified proposition formulae, is expressed by a Π 2propositional formula. Since, by assumption, the polynomial hierarchy collapses to NP, this Π 2formula has a proof of polynomial length. This proof shall be formally encoded within a true formula of the form σ (x ) = (x ∨ ¬x ) ∨ x b 1 ∨ x b 2 ∨ . . . ∨ x b k , where (b 1 , . . . ,b k ) is a sequence of bits encoding the proof. Overall, the semantic inference of ψ shall be performed in two steps; at the first step, the formula ψ ∧ σ is derived instead; at the second step, the tautology σ is removed: Whereas the second rule is purely syntactical, the first rule includes a "certificate" in the form of σ , which allows the correctness of semantic inference to be checked in polynomial time.

Lower Bounds on Shift-Π and Circuit Complexity
As shown in Section 6.2 above, to prove that PSPACE NP. it is sufficient to verify that for every propositional proof system Π there are formulas that have no polynomial-size proofs in the Shift-Π proof system. Furthermore, the proof of Theorem 6.3 demonstrates that one can consider one particular refutation calculus, SΣ 1 FC (semantic Σ 1 formula calculus). In this calculus, proof lines are existential propositional formulas, with semantic inference rules, which allows any semantic implication of any two formulas to be inferred in a single step. Proving a superpolynomial lower bound on the size of proofs in the Shift-SΣ 1 FC calculus would then separate NP from PSPACE. Any superpolynomial lower bounds for the Shift-SΣ 1 FC calculus would also imply a separation involving a non-uniform complexity class, namely, PSPACE P/poly. Recall that P/poly is the set of languages decidable by a non-uniform family of circuits of polynomial size. This result shall actually be achieved using a weaker refutational calculus: the Semantic Circuit Calculus (SCC).
In SCC, proof lines are Boolean circuits, each implementing a Boolean predicate in some of the variables of the original CNF, and there is only one type of derivation rules: The semantic derivation rule, by which one can take any two circuits and infer any circuit that is their semantic implication. This calculus is weaker than SΣ 1 FC, because every circuit can be represented by an existential formula of comparable size. Also, this calculus is not a proof system, because verifying such a step is an NP-complete problem. Every unsatisfiable CNF formula has a refutation of linear size in this system.
A superpolynomial lower bound on the size of Shift-SCC proofs would imply a lower bound on circuit complexity. This suggests that proving any lower bounds on the proof complexity for Shift-SCC is likely very hard. Theorem 6.4. Under the assumption that PSPACE ⊆ P/poly, every unsatisfiable Shift-CNF has a Shift-SCC refutation of polynomial size.
Proof. The proof follows the same strategy as in Theorem 6.3. Let Shifts(φ) be an unsatisfiable Shift-CNF and let n − 1 be the maximum difference between the variable indices in a single clause of φ. Propositions Fill i (y 1 , . . . ,y n ; z 1 , . . . , z n ) are constructed for φ as before. Lemma 6.2, asserts that Fill k (y 1 , . . . ,y n ; z 1 , . . . , z n ) can be tested in PSPACE. Then, by the assumption that PSPACE ⊆ P/poly, each proposition Fill k (y 1 , . . . ,y n ; z 1 , . . . , z n ), with k poly(n), has a representation by a polynomial-size circuit.
Using a weaker version of SCC, with circuits replaced by formulas, called the Semantic Formula Calculus (SFC), one can separate PSPACE from another class of circuits: the non-uniform NC 1 . This is the class of languages recognised by non-uniform circuits of logarithmic depth. The following theorem can be proved by the same method as Theorem 6.4. Theorem 6.6. Under the assumption that PSPACE ⊆ non-uniform NC 1 , every unsatisfiable Shift-CNF has a Shift-SFC refutation of polynomial size.
Another result on shifted versions of semantic calculi is that the existence of short proofs implies the collapse of the polynomial hierarchy. The argument uses the complexity class NP NP : these are languages decidable by nondeterministic polynomial-time algorithms using an oracle for a problem in NP; this class is known to coincide with Σ P 2 in the second level of the polynomial hierarchy. Proposition 6.7. If every unsatisfiable Shift-CNF formula has a polynomial-size Shift-SCC refutation, then PSPACE ⊆ Σ P 2 . Proof. Shift-CNF satisfiability is PSPACE-complete. Then, there is the following NP NPalgorithm for solving this problem. First, the algorithm guesses a short proof of the formula. Then, it verifies each semantic derivation using an NP oracle.

CONCLUSION
An interesting direction for further research would be to prove lower bounds for any proof systems augmented with a shift rule, for which no non-trivial lower bounds are known in the classical case,