Paid Exchanges are Worth the Price

We consider the list update problem as deﬁned in the seminal work on competitive analysis by Sleator and Tarjan [12]. In this problem, a sequence of requests, consisting of items to access in a linked list, is given. After an item is accessed it can be moved to any position forward in the list at no cost (free exchange), and, at any time, any two adjacent items can be swapped at a cost of 1 (paid exchange). The cost to access an item is its current position in the list. The goal is to dynamically rearrange the list so as to minimize the total cost (accrued from accesses and exchanges) over the request sequence. We show a lower bound of 12 / 11 on the worst-case ratio between the performance of an (oﬄine) optimal algorithm that can only perform free exchanges and that of an (oﬄine) optimal algorithm that can perform both paid and free exchanges. This answers an outstanding question that has been open since 1996 [10].


Introduction
The list update problem consists of a linked list of items and a finite request sequence.Each request is to access an item of the list.Each item access begins at the head of the list and follows the list item by item until the requested item is reached.The cost to access the i-th item in the list is thus i.Then, the requested item can be moved forward in the list at no cost and such a move is called a free exchange.At any time, two adjacent items may be swapped at a cost of 1 and such swaps are called paid exchanges.The goal is to dynamically rearrange the list over the request sequence so as to minimize the total cost of accesses and paid exchanges over the request sequence.
The list update problem (also called the list access problem) was one of the two problems studied in the seminal work on competitive analysis of Sleator and Tarjan [12] (the other being the paging problem).It is a fundamental problem in the area of algorithms that has been intensely studied, particularly, due to its importance for compression algorithms [5].For a recent survey on the list update problem, see [8].
In [12], Sleator and Tarjan present a 2-competitive online deterministic algorithm called move to front (mtf) that Irani showed later to be an optimal online deterministic algorithm [7].As its name implies, mtf moves every requested item to the front, using a free exchange.Also, in [7], Irani presented the first online randomized algorithm for the list update problem; it has a competitive ratio of 15/8.Reingold and Westbrook presented the first barely random online algorithm called bit that has a competitive ratio of 7/4 [11].The best known randomized online algorithm, comb, of Albers et al. [2] has a competitive ratio of 1.6 and only uses free exchanges.The comb algorithm randomly uses the barely random online algorithm bit with a probability of 4/5 and the non-parameterized, deterministic online algorithm timestamp [1] with a probability of 1/5.The currently best randomized online lower bound is 1.50115 [4].It should noted that all the best known online algorithms use only free exchanges [8].
The offline problem is known to NP-hard [3].It is not known if this holds if only free exchanges are permitted.In [10], an algorithm that computes the optimal schedule that uses only paid exchanges is shown to have a running time of O(2 ( − 1)!n), where is the length of the list and n is the number of requests. 1Based on the work of [10], an alternative algorithm that computes the optimal schedule, with a running time of O(2 !f ( ) + n + n), where f ( ) ≤ !3 !, is presented in [6].

Free vs. Paid Exchanges
In [12], Sleator and Tarjan claim that an algorithm that uses paid exchanges and free exchanges can be converted to an algorithm that uses only free exchanges without increasing the cost.This claim turns out not to be true as Reingold and Westbrook gave the counterexample of the request sequence 3, 2, 2, 3 for a list of length 3 with a starting configuration of 1, 2, 3 [10].An optimal algorithm serves this sequence at a cost of 8 by moving item 1 to the back of list with paid exchanges at a cost of 2, and then serving the sequence at a cost of 6.From an enumeration of all possible schedules that use only free moves, it can be seen that an algorithm using only free exchanges serves this sequence for a cost of at least 9, implying that, in the worst case, there is at least an additive constant in the difference between the performance of an optimal algorithm that uses only free exchanges and an unrestricted optimal algorithm.Further, Reingold and Westbrook show that the opposite is true: they show that an algorithm can replace the free exchanges by paid exchanges without increasing the cost [10].They also show that the permitted paid exchanges can be further restricted, without increasing the cost, to allow only "subset transfers" (see Definition 2 below).
The competitive ratio of 1.6 for the comb algorithm [1] (as described above) implies an upper bound of 1.6 on the worst case ratio between the cost of an optimal algorithm restricted to free exchanges and the cost of an unrestricted optimal algorithm, over all finite request sequences.

Our Contribution
We compare the cost of an optimal algorithm that can only perform free exchanges, denoted by opt_free, and an optimal algorithm that can use both paid and free exchanges, denoted Paid Exchanges are Worth the Price by opt.We show that there is a multiplicative gap of at least 12/11 on the worst-case ratio, over all possible finite request sequences, between the performance of opt_free and opt.Until now, it was not known if there is such a gap in an asymptotic sense.We answer this question in the affirmative, thus solving a question that has been open for almost 20 years since Reingold and Westbrook [10] gave the counterexample to the claim of Sleator and Tarjan.
As all online algorithms with currently best known competitive ratios use only free exchanges [8], our result suggests that, in order to achieve better upper bounds, it may be useful to consider online algorithms that make use of paid exchanges.

Preliminaries
The list update problem consists of a linked list of items and a finite request sequence of accesses.Each request is to access an item of the list.Each item access begins at the head of the list and there is a cost of 1 to the algorithm for each item accessed until the requested item is found.That is, the cost to access the i-th item in the list is i.Then, the requested item can be moved forward to any position in the list at no cost and such a move is called a free exchange.At any time, two adjacent items may be swapped at a cost of 1 and these swaps are called paid exchanges.The goal is to dynamically rearrange the list over the request sequence so as to minimize the total cost of accesses and paid exchanges over the request sequence.Note that, in the offline version of the list update problem (as defined above), the input is still a request sequence that must be served in order.The difference between the offline and online versions is that the offline algorithm has knowledge of the entire request sequence whereas, in the online version, a request is not revealed until all prior requests in the sequence have been served.
For an algorithm alg and a request sequence σ, we denote the cost to alg to serve σ by alg(σ).
We will use opt to denote an unrestricted optimal (offline) algorithm, and we will use opt_free to denote an optimal (offline) algorithm restricted to using only free exchanges.For the request sequences, we will denote multiple requests in a row to the same item by using exponents, e.g.x k means that x is requested k times in a row.
In [9,10], Reingold and Westbrook consider the offline version of the list update problem and show several properties of an offline optimum that uses both paid and free exchanges such as the following lemma.Lemma 1. [9][Cor.3.2] If an item x is requested 3 or more times consecutively, then an optimal offline algorithm must move it to the front before the second access.
In [9,10], Reingold and Westbrook also define the notion of a subset transfer and show that there exists an optimal algorithm that only performs such moves.Definition 2 (Subset Transfer).Let x be a requested item.A subset transfer is a move, performed just before x is accessed, of a subset of the items ahead of x in the list to the position immediately after x such that the relative order of the items in the subset is maintained.
Using Lemma 1 and Theorem 3, we get the following theorem that states that, for any sequence consisting of at least 3 consecutive requests to every item, mtf is opt_free.
, where, for all i, k i ≥ 3 and, for i < j, x i = x i+1 .For any initial list configuration, there exists an opt_free that moves each x i , 1 ≤ i ≤ j, to the front of the list immediately after the first access to x i of x ki i in σ.
Proof.By Lemma 1, an (unrestricted) optimal algorithm must move each x i , 1 ≤ i ≤ j, of σ to the front before the second request to that item.Furthermore, by Theorem 3, there exists such optimal algorithm that only performs subset transfers; denote this optimal algorithm by opt.Observe that if opt does not move x i to the front immediately before the first request to x i , but does move x i to the front immediately before the second request to x i , then it cannot be optimal, since smaller cost could be achieved by moving x i to the front immediately before the first request to x i .We conclude that opt is an optimal, subset-transfer-only, algorithm, that moves each x i , 1 ≤ i ≤ j, of σ to the front immediately before the first request to x i .Observe now that since opt is a subset-transfer-only algorithm, then opt does not perform any other rearrangements in the list while processing σ.
The action by opt of moving x i to the front by subset transfer immediately before the first request to x i , and then accessing x i k i times, can be accomplished for the same cost by an algorithm restricted to free exchanges.This is done by first accessing x i (on the first request to x i ), then moving x i to the front by a free exchange, and then accessing x i for the remaining k i − 1 times.It follows that there exists an algorithm restricted to free moves, that on σ moves every x i , 1 ≤ i ≤ j, to the front immediately after the first request to x i , and its cost is equal to the cost of the optimal unrestricted algorithm for σ.This algorithm must therefore be opt_free for σ.
Informally, the next theorem shows that, on a series of sequential requests, it is not to the advantage of alg_free to delay moving the requested item forward.That is, for an arbitrary algorithm that only performs free exchanges, denoted by alg_free, and, for a sequence of consecutive requests to an item x, such that β is the position closest to the head of the list to which x is moved by the end of these consecutive requests, if alg_free would move x to β immediately after the first request, it would not increase its cost.This holds for both offline and online algorithms, but online algorithms generally are not able take advantage of this fact given that they do not in general know the subsequent requests.Theorem 5. Let σ = σ 1 , ν, σ 2 , where ν is at least two consecutive requests to the same item x.Let β be the position of x immediately after ν for an arbitrary algorithm alg_free.There exists an algorithm alg_free that moves x to β immediately after the first request of ν such that alg_free (σ) ≤ alg_free(σ), and alg_free serves σ 1 and σ 2 exactly as alg_free.
Proof.The algorithm alg_free is defined to serve σ 1 in the same manner as alg_free, to then move x to position β immediately after the first request of ν, and to serve σ 2 in the same manner as alg_free.Note that the list configurations of alg_free and alg_free match prior to and after serving ν.Therefore, the cost to both algorithms is the same for σ 1 and σ 2 .
Since alg_free uses only free moves, i.e. moves of items towards the head of the list, it follows that the cost of alg_free for all requests in ν is no more than the cost of alg_free for those requests.Therefore, alg_free (σ) ≤ alg_free(σ).Lower Bound for OPT_FREE In this section, we give a lower bound for the free move optimal offline algorithm as compared to the unrestricted optimal offline algorithm.That is, we are comparing the power of paid exchanges and free exchanges versus only free exchanges.We show that, for the case of a list of length at least 3, the ratio between the performance of opt_free and that of opt is at least 12/11 > 1.09 in the worst case.More formally, we show that there exists an infinite family of finite request sequences σ r , r > 0, such that the cost of an offline algorithm that can use paid exchanges, paid, increases with r, and such that opt_free(σr) opt(σr) ≥ opt_free(σr) paid(σr) ≥ 12/11.This implies that, for any ε > 0 and any additive constant η that does not depend on the request sequence, there does not exist a free exchange algorithm, alg_free, such that alg_free(σ) ≤ 12  11 − ε opt(σ) + η for all σ.To prove the claim, we use a list of length 3 and we begin by defining a request sequence R(L).For a given initial list configuration L, we define the request sequence R(L) and a deterministic offline algorithm paid that uses paid exchanges.By relabelling the list of paid after having served R(L) to match L, we can define an arbitrarily long request sequence σ r consisting of repeated requests to R(L) based on a relabelling of the list state of paid after each R(L).Our result applies to a list of length at least 3: If the list has a length greater than 3, we can ignore all but 3 items.Hence, without loss of generality, we only consider lists of length 3.

Line of Proof
As indicated above, our proof uses arbitrarily long request sequences, σ r , r ≥ 1 that are built by a repeated concatenation of r short request sequence R(L), defined using a relabelling of the list state of paid after each R(L).We first prove two claims related to a single short request sequence R(L).Namely, that paid serves R(L) starting with list configuration L at cost of 11; and that any opt_free that serves R(L) starting with list configuration L has cost at least 12.This however only repeats the claim of Reingold and Westbrook as to the existence of a request sequence with an additive difference between the optimal performance with free exchanges only and the optimal performance with both free and paid exchanges.We then concatenate these short request sequences to create a long request sequence.Observe that a multiplicative gap does not follow from such a concatenation.Indeed, an optimal algorithm that uses only free exchanges could potentially pay more than 12 for a given request sequence R(L), reach a different list configuration, and then be able to serve the next R(L) with cost less than 12, thus paying in total no more than 23 for the two sequences (or have such a phenomenon over a sequence of more than two sequences R(L)).To overcome this difficulty we prove that, for the long sequences that we consider, σ r , any opt_free must reach the same configuration as paid does at the end of each R(L).We can then conclude that for σ r the cost of paid is 11r and the cost of any opt_free is at least 12r.

Offline Paid Exchange Algorithm
For a list of length 3 with a starting list configuration L = y, x 1 , x 2 , we define the request sequence R(L) = x 2 , x 3  1 , x 3 2 .Let paid be an unrestricted offline algorithm for R(L) defined as follows.Before the first request of R(L), using two paid exchanges, x 1 and x 2 are moved to the front of the list.Then, immediately before the second request to any x i , 1 ≤ i ≤ 2, paid moves x i to the front.
Immediately from the definition of paid, we have the following facts.Fact 6.Given a starting list configuration of L = y, x 1 , x 2 , after serving R(L), the list configuration of paid is x 2 , x 1 , y. Fact 7. Given a starting list configuration of L = y, x 1 , x 2 , the cost of paid to serve R(L) is 11.
Proof.The cost to bring x 1 , x 2 to the front by paid exchanges is 2 and the list configuration is now x 1 , x 2 , y.The cost of the first access to x 2 is 2, the cost to the next three requests of x 1 is 3.The second access to x 2 costs 2 and then x 2 is brought to the front and the remaining two accesses cost 2. Overall, the cost to paid is 11.

Arbitrarily Long Request Sequences
For an initial list configuration of L = y, x 1 , x 2 , from Fact 6, the configuration of the list of paid after serving R(L) is x 2 , x 1 , y.Therefore, after serving R(L), with a relabelling of the list of paid to that of L, R(L) can subsequently be requested again, and this can be repeated to create arbitrarily long request sequences.That is, if L = x 2 , x 1 , y (as is the list configuration paid after serving R(L) for L = y, x 1 , x 2 ), then R(L ) = y, x 3  1 , y 3 .
where L j is the configuration of the list of paid after serving R 1 , . . ., R j−1 for 1 < j ≤ r and L 1 = L is the initial configuration of the list.We will use the term round to signify a subsequence R(L) in σ r .

Optimal (Offline) Free Exchange Algorithm
Let mtf be the algorithm that moves every requested item to the front.Immediately from the definition of mtf, we have the following fact.Fact 8. Given a starting list configuration of L = y, x 1 , x 2 , after serving R(L), the list configuration of mtf is x 2 , x 1 , y.
Note that, when starting from the same initial list configuration and serving R(L), the list configuration of mtf is exactly that of paid after serving R(L).
For an initial configuration L = y, x 1 , x 2 and R(L) = x 2 , x 3 1 , x 3 2 , the following lemma shows that mtf is an optimal free move algorithm for R(L).

Lemma 9. For an initial list configuration
Proof.Irrespective of the specific free exchange algorithm, the access cost for the first request is 3 and there are 3 possible list configurations after the access.They are y, x 1 , x 2 ; y, x 2 , x 1 ; and x 2 , y, x 1 (this last configuration corresponds to that of mtf).By Theorem 4, applied to the suffix of R(L), after serving the first request of R(L), x 3  1 , x 3 2 ,every opt_free moves x 1 and x 2 to the front of the list on the next request to each item.Table 1 summarizes the costs of the 3 possible ways to serve R(L), as a function of the list configuration after the first request.The actions of mtf on R(L) correspond to the x 2 , y, x 1 column which is a minimum.
We note that our proof will go through also if instead of using mtf we would use the algorithm that results in the list configuration as defined in the first configuration in the table.

S TA C S 2 0 1 5
Table 1 For an initial list configuration of L = y, x1, x2, this table summarizes the potential optimal free exchange algorithms for R(L) = x2, x 3  1 , x 3 2 .From Theorem 4, we know that after the first request every opt_free moves all the items to the front of the list for the remaining requests.Therefore, the only variable is the configuration of the list immediately after the first request.Columns 3 − 5 represent the three possible list configurations.Column 1 is the index in R(L) of the request listed in column 2. From the table, the first and third list configurations are optimal, and mtf corresponds to the third list configuration.The Last Round of σ r

List Configuration
In the following lemma, we show that any opt_free moves any item x to the front of the list immediately after the first access of three consecutive requests to x in R r (L r ) of σ r , i.e. in the last round of σ r .
Lemma 10.For σ r = R 1 (L 1 ), . . ., R r (L r ) , every opt_free moves any item x to the front of the list immediately after the first access of three consecutive requests to x in R r (L r ), where L 1 = y, x 1 , x 2 and L j , 1 < j ≤ r, is the list configuration of paid after serving R 1 (L 1 ), . . ., R j−1 (L j−1 ) .
Proof.Let L r = y, x 1 , x 2 and let A be an arbitrary opt_free algorithm.By way of contradiction, assume that A does not move some x i ∈ R r (L r ) to the front immediately after the first request to x 3 i ∈ R r (L r ).Let σ = R 1 (L 1 ), . . ., R r−1 (L r−1 ), x 2 and σ = x 3  1 , x 3 2 (note that σ r = σ , σ ).Define Â to be a free move algorithm that serves σ exactly as A and moves all x j ∈ σ to the front immediately after the first request to each item in σ .
Since A and Â serve σ in the same manner, Â(σ ) = A(σ ) and the list configurations of A and Â are the same immediately after σ .From Theorem 4, Â is opt_free over the remainder of the sequence.But, given the list configuration of both A and Â after serving σ , starting with that list configuration, Â(σ ) = opt_free(σ ) < A(σ ).Therefore, Â(σ r ) = A(σ ) + opt_free(σ ) < A(σ r ) which contradicts the fact that A is an optimal free exchange algorithm.

The Rest of σ r
In the next lemma, we show that the property proved in Lemma 10 for the last round of σ r can be proved for all of σ r .Namely, we show that for σ r there exists an opt_free that moves any item x to the front after the first access of any three consecutive requests to the same item.We note that Theorem 4 holds only for the specific type of sequence defined in the statement of that theorem, and that the property proved in the next lemma does not hold in general for an arbitrary sequence.For example, it can be verified that the sequence 5, 5, 5, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1 (starting with list configuration 1, 2, 3, 4, 5) can be served by opt_free at cost of 44, while if alg_free moves item 5 to the front immediately after the first request to item 5, then the cost of alg_free is at least 45.Lemma 11.For σ r = R 1 (L 1 ), . . ., R r (L r ) , there exists an opt_free that moves any item x to the front of the list immediately after the first access of three consecutive requests to x, where L 1 = y, x 1 , x 2 and L j , 1 < j ≤ r, is the list configuration of paid after serving R 1 (L 1 ), . . ., R j−1 (L j−1 ) .
Proof.In this proof, for σ r , we consider an arbitrary opt_free algorithm A and show that, if the property does not hold for A, then there exists another opt_free algorithm A that does move every item x to the front of the list immediately after the first access of three consecutive requests to x, and such that A (σ r ) ≤ A(σ r ).This will be done by defining a sequence of algorithms A q , starting with A 0 = A, and by reverse induction on i and j over all the That is, we consider the rounds from R r (L r ) to R 1 (L 1 ) and the consecutive three requests in each round from the last consecutive three requests to the first.For each x 3 , if A q does not move x to the front immediately after the first request, we define A q+1 , based on A q , such that the desired property holds for x 3 and all subsequent consecutive three requests, and we show that the cost does not increase.
In the proof, we use the following notations.Let x 3 be three consecutive requests in R j (L j ) for which A q does not have the desired property.We will denote all the requests in σ r before x 3 by σ 1 .The requests after x 3 will be denoted by σ 2 .Note that σ 2 could be an empty sequence.For the analysis, we will often (Case 2 and Case 3 below) further partition σ 2 into disjoint subsequences σ 3 , . . ., σ p such that σ r = σ 1 , x 3 , σ 3 , . . ., σ p .At a risk of a slight abuse of notation, we will denote the cost of a subsequence of an arbitrary σ r to an algorithm, alg, that serves all of σ r , as alg(r i , . . ., r j ) = alg(r 1 , . . ., r j ) − alg(r 1 , . . ., r i−1 ), where the prefix and the suffix are understood implicitly.That is, alg(r i , . . ., r j ) is the cost accrued by alg over the requests r i , . . ., r j of σ r given that alg has served the prefix r 1 , . . ., r i−1 and will serve the remaining requests.Therefore, we have that alg(σ r ) = alg(σ 1 ) + alg(x 3 ) + alg(σ 3 ) + • • • + alg(σ p ).Further note that by Theorem 5, we can assume without loss of generality that A q does not move x further ahead in the list on the second or third requests of x 3 .

Definition of Âq
We first define an algorithm Âq that we use extensively in the proof.For σ = σ 1 , x 3  i , σ 2 and algorithm A q as defined previously, let Âq be an algorithm that serves σ 1 in the same manner as A q and then moves x i from position α > 1 to the front of the list at the first request of x i .Immediately after serving x i , the configuration of the list of A q is some B, x i , C and the configuration of the list of Âq is x i , B, C, where B is the set of items ahead of x i in the configuration of A q at this point and C is the set of items behind x i in the configuration of A q .As long as the list configurations of A q and Âq differ, for each x j ∈ σ 2 , if A q moves x j to the front, Âq moves x j to front.Otherwise, Âq does not move x j forward at all.Once the list configurations of A q and Âq match, Âq will serve the remaining requests exactly as A q .Note that it is possible that the list configuration of Âq may never match that of A q (see Case 1 below).
From the definition of Âq , and the fact that the list has length of 3, we have the following useful properties.

S TA C S 2 0 1 5
where β is the position to which x i is moved by A q .Further, given that A q moves x i from α to β, 1 < β ≤ α, and Âq moves x i from α to the front of the list, we have the following properties.
We now turn to the inductive proof.For a list of length 3, there are two alternating list configurations for paid (i.e.values for L j ) before each R j (L j ): y, x 1 , x 2 and x 2 , x 1 , y.Therefore, x 1 is requested in every R j (L j ), and x 2 and y are requested in alternating R j (L j )'s.
For x i ∈ R j (L j ), which is the last point in σ r for which A q does not move x i to the front immediately after the first request of three consecutive requests, we can distinguish between three cases: (1) x i is never requested again in σ r ; (2) x i is requested again in R j+1 (L j+1 ), i.e. in the next round; (3) x i is requested again in R j+2 (L j+2 ), i.e. in the round after the next round.Note that this partitioning is exhaustive.
At each inductive step such that A q does not have the desired property, we define an algorithm A q+1 based on A q , for q ≥ 0, and show that A q+1 (σ r ) ≤ A q (σ r ).This is done by case analysis over the three cases defined above.
Case 1: x i ∈ R j (L j ) is never requested again in σ r .
Recall that σ r = σ 1 , x 3  i , σ 2 .When j = r, this case follows immediately from Lemma 10 by defining A q+1 to be the algorithm defined in the proof of Lemma 10.
Cost for σ 2 = y, x 3 1 , y 3 .By the induction hypothesis we know that A q moves x 1 and y to the front of the list on the first request to x 1 and on the second request to y.It follows that the configurations of the lists of Âq and A q will match before the the third request to y is processed.
If y is in B, then the total cost to access y for Âq over σ 2 is at most 2 more than that of A q over σ 2 .This follows from the fact that there are two requests to y before A q must move y to the front, according to the induction hypothesis and, if y is in B, then Âq has x 1 in front of y, whereas A q does not.
If y is in C, the total cost to access y for Âq over σ 2 is at most 1 more than that of A q over σ 2 .This can occur if, on the first access to y in σ 2 , A q were to move y between x 1 and x 2 in its list.Then, on the second access, y is one item closer to the front in the list of A q as compared to the list of Âq .

Note that σ
Cost for σ 3 = x 3 2 , y, x 3 1 .After serving x 3 1 , the configuration of the list of Âq is x 1 , B, C and the list of A q is B, x 1 , C. By the induction hypothesis, A q will move x 2 to the front on the first request to x 2 in σ 3 .This request and the request to y will each cost 1 more to Âq than to A q if they are in B. If they are in C, there is no additional cost to Âq as compared to A q .Finally, on the first request to x 1 in σ 3 , x 1 is no further from the front in Âq than it is in A q .Then, by the induction hypothesis, A q moves x 1 to the front for the remaining requests to x 1 in σ 3 as does Âq .Therefore, List Configuration after σ 3 .By the induction hypothesis, A q will move x 2 and x 1 to the front of the list immediately after the first access to each one in σ 3 .Consider the state of the lists of A q and Âq immediately after serving σ 3 , depending on whether or not A q moves y to the front.If A q does not move y to the front of the list, the configuration of its list will be x 1 , x 2 , y, and, by the definition of Âq , its list configuration will also be x 1 , x 2 , y.If A q does move y to the front of the list, the configuration of its list will be x 1 , y, x 2 , and, by the definition of Âq , its list configuration will also be x 1 , y, x 2 .

S TA C S 2 0 1 5
Proof.By Lemma 11, there exists an opt_free that will have the same configuration as paid and mtf immediately before R j (L j ), 1 ≤ j ≤ r.Let opt_free * be such an opt_free.Since the list configuration of mtf and opt_free * match prior to serving every R j (L j ), Lemma 9 implies that mtf(σ r ) = opt_free(σ r ).
Using the fact that, for any r > 0, mtf is an optimal free exchange algorithm for σ r , we can, in the following lemma and theorem, give a lower bound on the worst-case ratio between opt_free(σ) and opt(σ) by analysing the ratio between mtf(σ r ) and paid(σ r ) for σ r = R 1 (L 1 ), . . ., R r (L r ) , where L 1 = y, x 1 , x 2 and L j , 1 < j ≤ r, is the list configuration of paid after serving R 1 (L 1 ), . . ., R j−1 (L j−1 ) .
Proof.Towards a contradiction, assume α = 12  11 −ε for some ε > 0. Hence, alg_free(σ r ) ≤ by the fact that paid(σ r ) ≥ opt(σ r ) and Lemma 13.Since η does not depend on r, and alg_free(σ r ) and paid(σ r ) both increase with r, we have a contradiction by choosing a sufficiently large r such that alg_free(σ r ) > η and (13) no longer holds.

Conclusions
We showed that the difference in the performance between an offline optimal algorithm restricted to free exchanges and an unrestricted offline optimal algorithm is at least a multiplicative factor of 12/11, answering a question that has been open since 1996 [10].
Based on computer simulations, we believe that it should be possible to generalize the construction presented here and, based on this generalization, improve the lower bound to 3 − √ 3. Further, it would be interesting to consider upper bounds, in particular, an (offline) algorithm restricted to free exchanges that improves upon the 1.6 upper bound that follows from the randomized online algorithm comb [2].
We note that the currently best known online algorithms use only free exchanges (cf.[8]).Our results bring up the possibility that improving the currently best randomized competitive ratio for the list update problem might necessitate introducing paid exchanges into the algorithm.The same might apply also to offline approximation algorithms.