String-averaging methods for best approximation to common fixed point sets of operators: the finite and infinite cases

String-averaging is an algorithmic structure used when handling a family of operators in situations where the algorithm in hand requires to employ the operators in a specific order. Sequential orderings are well known, and a simultaneous order means that all operators are used simultaneously (in parallel). String-averaging allows to use strings of indices, constructed by subsets of the index set of all operators, to apply the operators along these strings, and then to combine their end-points in some agreed manner to yield the next iterate of the algorithm. String-averaging methods were discussed and used for solving the common fixed point problem or its important special case of the convex feasibility problem. In this paper we propose and investigate string-averaging methods for the problem of best approximation to the common fixed point set of a family of operators. This problem involves finding a point in the common fixed point set of a family of operators that is closest to a given point, called an anchor point, in contrast with the common fixed point problem that seeks any point in the common fixed point set. We construct string-averaging methods for solving the best approximation problem to the common fixed points set of either finite or infinite families of firmly nonexpansive operators in a real Hilbert space. We show that the simultaneous Halpern–Lions–Wittman–Bauschke algorithm, the Halpern–Wittman algorithm, and the Combettes algorithm, which were not labeled as string-averaging methods, are actually special cases of these methods. Some of our string-averaging methods are labeled as “static” because they use a fixed pre-determined set of strings. Others are labeled as “quasi-dynamic” because they allow the choices of strings to vary, between iterations, in a specific manner and belong to a finite fixed pre-determined set of applicable strings. For the problem of best approximation to the common fixed point set of a family of operators, the full dynamic case that would allow strings to unconditionally vary between iterations remains unsolved, although it exists and is validated in the literature for the convex feasibility problem where it is called “dynamic string-averaging”.


Introduction
String-averaging algorithmic structures are used for handling a family of operators in situations where the algorithm needs to employ the operators in a specific order. Stringaveraging allows to use strings of indices taken from the index set of all operators, to apply the operators along these strings, and to combine their end-points in some agreed manner to yield the next iterate of the algorithm.
If a point p of a set C is nearest to a given point x in space, known as the anchor, then p is a best approximation to x from C. In the case when C is the common fixed point set of a family of self-mapping operators, the problem of finding such p is known as the best approximation problem (BAP). In case the fixed point sets are all convex, this problem is a special case of two well-known problems: The convex feasibility problem (CFP), which is to find a (any) point in the intersection of closed convex sets, and the common fixed point problem (CFPP), where the closed convex sets in CFP are the fixed point sets of operators of a given family. The CFP, the CFPP, and the BAP are widely studied and are useful in mathematics and various physical sciences (see, e.g., Bauschke and Borwein [6], Reich and Zalas [33], and Cegielski [13], to name but a few), including in the context of stringaveraging for the CFP and the CFPP (see, e.g., Censor and Zaslavski [19,20], Bargetz, Reich, and Zalas [3] and [33]).
Nevertheless, string-averaging algorithmic approaches for solving the BAP were, to the best of our knowledge, neither proposed nor investigated. Motivated by this, we devote our research presented here to developing string-averaging algorithmic schemes for finding the best approximation to the common fixed points set of either a finite or an infinite family of firmly nonexpansive operators. Besides purely mathematical interest, see, e.g., Dye, Khamsi, and Reich [27] and the references therein, motivation for the infinite case can also come from practical real-world situations. This point is succinctly made in the introduction of the recent paper of Kong, Pajoohesh, and Herman [30]. Although they refer to the infinite CFP, their arguments can serve also to justify the infinite case for the BAP. The case of infinitely many sets is useful in applications where there is a potential infinity of samples or measurements, each one of which gives rise to a convex set that contains the point we wish to recover, see, for example, Blat and Hero [10].

Contribution and structure of the paper
Our string-averaging methods are applied to families of firmly nonexpansive operators, and they follow the principles of the original string-averaging process suggested by Censor, Elfving, and Herman in [16]. Consider a set M containing all pairs of the form (Ω, w), where Ω is a set of finite strings of indices, by which the string operators are formed, and w is a function that attaches to every string t ∈ Ω a positive real weight w(t) such that the sum of weights equals 1. We construct what we call a "static" string-averaging method in which a fixed predetermined single pair (Ω, w) ∈ M is used throughout the iterative process. This approach solves the BAP for a common fixed points set of either a finite or an infinite family of firmly nonexpansive operators, and we show that the simultaneous Halpern-Lions-Wittman-Bauschke algorithm (see, e.g., in Censor [14,Algorithm 5]), the Halpern-Wittman algorithm (see, e.g., [6,Algorithm 4.1]), and the Combettes algorithm [21], which were labeled as sequential and simultaneous algorithms, respectively, are special cases of our static string-averaging methods. We extend the "static" notion in the finite case to the situation where a finite number of pairs (Ω, w) ∈ M can be used and call it a "quasi" dynamic string-averaging method due to its resemblance to the dynamic string-averaging scheme (see [19]). This is done by ordering a finite pre-defined set of pairs (Ω, w) ∈ M and forming a finite family of operators of the form t∈ w(t)T[t](x) for every such (Ω, w), where T[t] are string operators. These are, in turn, used in a cyclic manner.
With the aid of a construction similar to the quasi-dynamic string-averaging algorithm, we propose a simultaneous string-averaging method.
We focus here on Halpern's algorithm and the Halpern-Lions-Wittman-Bauschke algorithm. There are, however, several other iterative processes for solving the BAP, which are not treated here, but can possibly be also extended via the string-averaging algorithmic concept, e.g., Dykstra's algorithm, see [7,Sect. 30.2], and Haugazeau's method, see [7,Sect. 30.3], where further references can be found.
The results presented here for the infinite case complement our earlier work in Aleyner and Censor [1] where a sequential algorithm for solving the BAP to the common fixed points set of a semigroup of nonexpansive operators in Hilbert space was studied. Only a sequential iterative process was investigated there, but the framework was more general due to the kind of operators (nonexpansive) and the size of the pool of operators (a semigroup, not limited to the countable case). This is a theoretical work in the spirit of theoretical developments in fixed point theory presented in many of the earlier referenced papers. The string-averaging approach is actually not a single algorithm but an "algorithmic scheme" so that every individual choice of lengths and assignments of strings will give rise to a different algorithm. In this way our string-averaging algorithmic scheme generalizes earlier algorithms that become special cases of it. It is not practical to conduct a numerical experiment without having a specific scientific or real-world problem in hand, but it is expected that researchers who need to solve the best approximation problem to common fixed point sets will find here valuable algorithmic information.
The paper is structured as follows. After preliminaries in Sect. 3, the work is divided into two main parts: The first part where the given family of firmly nonexpansive operators is finite, in Sects. 5 and 6, and the second part where the given family of firmly nonexpansive operators is a countable family, in Sect. 7. The static, the quasi-dynamic, and the simultaneous string-averaging methods can be found in Sects. 5.1, 5.2, and 5.3, respectively. In Sect. 6, we show for which choices of pairs (Ω, w) the simultaneous version of the Halpern-Lions-Wittman-Bauschke algorithm and the Halpern-Wittman algorithm are special cases of our static string-averaging approach. In Sect. 7.1, we propose our static string-averaging method for solving the BAP in the infinite case, from which the well-known Combettes algorithm follows.

Previous related works
An early approach, based on projection operators, is John von Neumann's alternating projection method [34] for solving the BAP with two closed linear subspaces. It has been widely studied and generalized by many authors, see, e.g., Bauschke and Borwein [5], Deutsch [23], Kopecká and Reich [31], and Deutsch and Hundal [25]. For the general case of arbitrary convex sets, the Dykstra's algorithm is a suitable modification of the alternating projections method to solve the BAP. This algorithm was first introduced by Censor  Dykstra in [28] for closed and convex cones in finite-dimensional Euclidean spaces, and later extended by Boyle and Dykstra in [11] for closed and convex sets in a Hilbert space. Additional projection approaches can be found in Aragón Artacho and Campoy [2] and Bregman, Censor, Reich, and Zepkowitz-Malachi [9]. For a recent bibliography of papers and monographs on projection methods, see Censor and Cegielski [15]. A well-known method for solving the more general BAP is Halpern's algorithm [29], whose strong convergence to the solution, under various sets of assumptions on the parameters, has been proved by several authors. The main contributions are due to Lions, to Wittman, and to Bauschke, see Bauschke's paper [4]. Additional literature background of the BAP and related problems appear in the excellent literature review of [2], from which we adapted some of the above.
The literature on string-averaging algorithms has also expanded since its first presentation in [16], and further related work has been published. In Crombez [22], a stringaveraging algorithm for solving the common fixed point problem for a finite family of paracontracting operators is proposed. Censor and Segal in [17] suggested a string-averaging solution for the common fixed point problem for a finite family of sparse operators. In Censor and Tom [18], a study on the behavior of a string-averaging algorithm for inconsistent convex feasibility problems is done.
A generalized notion of string-averaging is the notion of dynamic string-averaging, in which one is able to use in the iterative process pairs (Ω, w) from a pre-defined set, denoted by M * ⊂ M (see, e.g., [20]). In every (Ω, w) ∈ M * , the length of every t ∈ Ω is bounded and w(t) is bounded away from zero. An example of a dynamic string-averaging algorithm can be found in [19]. That iterative process generates a convergent sequence whose limit is a point in the intersection of a finite family of closed convex sets, namely a solution to the CFP. Recently, Censor, Brooke, and Gibali in [12] were able to construct a dynamic stringaveraging method for solving the multiple-operator split common fixed point problem (see, e.g., [12,Problem 1]) for families of cutters in Hilbert spaces.

Preliminaries
Throughout our work we denote by H a real Hilbert space with the inner product · , · and induced norm · , and by N the set of all natural numbers including zero. Let D ⊆ H be a nonempty set, and let T : If D is a closed convex set, then for every u ∈ H there exists a unique point y ∈ D such that ( 1 ) Such a point y is called the projection of u onto D and is denoted by P D (u). We now recall some definitions regarding various classes of operators.
(iv) Strictly quasi-nonexpansive (sQNE) if (v) C-strictly quasi-nonexpansive (C-sQNE) if T is quasi-nonexpansive and where C = ∅ and C ⊆ Fix(T). A useful fact which can be found, e.g., in [13,Proposition 2.1.11] is that the fixed point set of a nonexpansive operator is a closed convex set. Since an intersection of any collection of closed convex sets is a closed convex set (see, e.g., Lemma 1.13 and Example 2.3 in Deutsch [24]), it follows that the set of common fixed point sets of a family of nonexpansive operators of any cardinality is a closed convex set and, thus, the projection of any given point u onto this set is well defined provided that the intersection is nonempty.
All our string-averaging methods use sequences of real numbers called steering sequences.
∞ k=0 λ k = +∞ or, equivalently, Observe that although λ k ∈ [0, 1] the definition rules out the option of choosing all λ k equal to zero or all equal to one because of contradictions with other properties. Infinitely many zeros are possible only if the remaining nonzero elements obey all properties. The third property in (9) was introduced by Wittmann, see, e.g., the recent review paper of López, Martin-Márquez, and Xu [32]. Lemma 3.3 below is composed of several known claims which will be used in the sequel. We supply pointers to the proof of the lemma for completeness.
Proof For (i) and (ii) see [

String-averaging methods for best approximation to the common fixed points set of a family of firmly nonexpansive operators: general
In our present work we consider the best approximation problem with respect to the common fixed points set of a family of FNEs. Our overall aim is to develop and investigate string-averaging algorithms for this problem. In the string-averaging algorithmic scheme, one constructs from a given family of operators a family of so-called string-operators which are certain compositions of some of the operators from the given family. According to these, the string-averaging algorithm proceeds in its iterative process. We show that such string-averaging algorithmic schemes converge to the projection of a given point (commonly called the "anchor") to the common fixed point set of the given family.
We are able to ensure convergence of our string-averaging methods by demanding that the operators of the given family be FNEs. There are well-known links between the classes of FNEs, NEs, sQNEs, and QNEs defined above that help us in our analysis. To take advantage of these links, we use Corollary 4.50 and Proposition 4.47 in Bauschke and Combettes' book [7], which are proved for a finite family of sQNEs and a finite family of QNEs, respectively. We extend the usage of [7,Proposition 4.47] to the countable case in order to determine, in Sect. 7, the point to which our string-averaging algorithm converges to.

String-averaging methods for best approximation to the common fixed points set of a family of firmly nonexpansive operators: the finite case
In our work we develop string-averaging algorithms for two distinct situations. One is the finite case wherein the family of given FNEs is finite. The other is when the family of given FNEs is countably infinite. In this section we consider the finite case. We start by defining the terms which we use throughout this section.

Definition 5.1
Let D be a nonempty closed convex subset of H, and let (T i ) m i=1 be a finite family of self-mapping operators on D. An index vector is a vector of the form t = (t 1 , t 2 , . . . , t p ) such that t ∈ {1, 2, . . . , m} for all ∈ {1, 2, . . . , p}. For a given index vector t = (t 1 , t 2 , . . . , t q ), we denote its length (i.e., the number of its components) by γ (t) = q and define the operator T[t] as the composition of the operators T i whose indices appear in the index vector t, namely and call it a string operator. A finite set Ω of index vectors is called fit if, for each i ∈ {1, 2, . . . , m}, there exists a vector t = (t 1 , t 2 , . . . , t p ) ∈ Ω such that t = i for some ∈ {1, 2, . . . , p}. As in [19], we denote by M the collection of all pairs (Ω, w), where is a fit finite set of index vectors and w : → (0, 1] is such that t∈Ω w(t) = 1.

Censor and Nisenbaum Fixed Point Theory Algorithms Sci Eng
(2021) 2021:9 Page 7 of 21 As mentioned above, [7,Corollary 4.50] and [7,Proposition 4.47] are cornerstones to our proofs of convergence. The following are slightly rephrased versions of them, respectively, adapted to our notations and needs.

Proposition 5.3 Let D be a nonempty subset of H, let
The following lemma combines all of the above into a useful auxiliary tool which is used repeatedly. We consider the operator T := t∈ w(t)T[t] which is called a string-averaging operator.

Lemma 5.4 Let D be a nonempty closed convex subset of H, and let
Proof Note that F = ∅ and (10) imply that, for every t ∈ Ω and for every Therefore, We want to use Proposition 5.3 for the family (T[t]) t∈Ω . Since every FNE is NE (see Lemma 3.3(i)), for every t ∈ Ω, we apply [13, Lemma 2.1.12(ii)] to the family (T t ) q =1 and conclude that the string operator T[t] = T t q T t q-1 · · · T t 1 is NE. Thus, from (11) and due to the fact that every NE with a fixed point is QNE, the family of operators (T[t]) t∈Ω is a finite family of QNEs. This, together with (12), yields, according to Proposition 5.3, that is a family of sQNEs, and so, for every t ∈ Ω, applying Proposition 5.2 with the family (T t ) q =1 yields that the string operator From the fitness of Ω and from (14), we get and, overall, from (13) We are now ready to propose the new string-averaging methods for solving the best approximation problem and prove their convergence.

The static string-averaging method for the finite case
First we discuss string-averaging methods in which a single pair (Ω, w) ∈ M is picked at the outset and kept fixed throughout the iterative process. Such string-averaging methods will be termed "static string-averaging methods". We will make use of the convergence theorem in [29]. Halpern's algorithm is a sequential algorithm which generates a sequence via the iterative process where S : D → D is NE with Fix(S) = ∅, the anchor point u ∈ D is given and fixed, the initialization x 0 ∈ D is an arbitrary point, and the sequence (λ k ) k∈N is a steering sequence as in Definition 3.2. Its proof of convergence can be found also in [7, Theorem 30.1]. We present a slightly rephrased version of this theorem without a proof.

Theorem 5.5 Let D be a nonempty closed convex subset of H, and let S be a self NE on D
such that Fix(S) = ∅. Let (λ k ) k∈N be a steering sequence, and let u, x 0 ∈ D. Then any sequence generated by (17) converges strongly to P Fix(S) (u).
Our new static string-averaging algorithm for a finite family of FNEs is as follows.
Algorithm 1 (The static string-averaging algorithm for solving the best approximation problem in the finite case) Initialization: Choose a single pair (Ω, w) ∈ M and arbitrary x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and w(t) and T[t] are as in Definition 5.1.
The convergence proof of Algorithm 1 follows. NE and that Fix(T) = m i=1 Fix(T i ). From the proof of Lemma 3.3 we conclude that T is a convex combination of NEs, and thus, since a convex combination of NEs is a NE (see, e.g., [13, Lemma 2.1.12(i)]), T is NE. Moreover, Fix(T) is not empty since it contains F. Applying Halpern's Theorem 5.5 with T in the role of S, any sequence (x k ) k∈N generated by Algorithm 1 converges strongly to P Fix(T) (u). Now, applying Lemma 5.

Theorem 5.6 Let D be a nonempty closed convex subset of H, and let
and, therefore, This concludes our treatment of the static string-averaging algorithm for solving the best approximation problem in the finite case. We make the following remark about it.
Remark 5.7 Theorem 5.6 is related to two important results that appear in [7]. It generalizes Corollaries 30.2 and 30.3 in that book from the algorithmic structural point of view, because the algorithms there are fully-simultaneous and fully-sequential, respectively. These two algorithmic options are special cases of the static string-averaging algorithm that are obtained either by choosing strings of length one with every index i = 1, 2, . . . , m appearing exactly in one string or by choosing to use a single string that includes all indices i = 1, 2, . . . , m, respectively. However, our Theorem 5.6 cannot be considered as a generalization of those corollaries because the corollaries deal with NEs while we restrict our analysis of the string-averaging algorithmic structure to only FNEs. The question whether or not our Theorem 5.6 can be proven for NEs remains open.
Next we expand our results to a non-static case.

The quasi-dynamic string-averaging method for the finite case
The key adjustment which we did in the construction of Algorithm 1 in order to prove its convergence with the aid of Halpern's algorithm was the repeated use of the same single fixed pair (Ω, w) in all iterations k ≥ 1. This reuse of a fixed (Ω, w) throughout the whole iterative process of Algorithm 1 is a special case of a more general method, mentioned briefly already in Sect. 2, called the dynamic string-averaging method. The dynamic stringaveraging algorithmic scheme allows to pick and use in every step of the iterative process any pair (Ω, w) from a pre-defined set M * ⊂ M. The set M * was defined in [19,Equation (21)] as follows. The set M * is an infinite subset of M, but in our quasi-dynamic string-averaging method proposed below we must confine ourselves to a finite subset of M. So, instead of choosing the pairs (Ω, w) from M * , we choose them from a finite-cardinality subset, denoted by M ⊂ M, and use them in a cyclic manner. The finiteness of M guarantees that it is actually a subset of M * . As one can tell, such an algorithm is indeed not as "dynamic" as Algorithm 6 of [19] or Algorithm 3 of [20]; nevertheless, it is not static as Algorithm 1. Therefore, we name it quasi-dynamic string-averaging method.
The following is our quasi-dynamic string-averaging algorithm.
Algorithm 2 (The quasi-dynamic string-averaging algorithm for solving the best approximation problem in the finite case) Initialization: x 0 ∈ D is arbitrary. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, j(k) = k mod |M | + 1 for all k ≥ 0 is a cyclic control sequence (see, e.g., [17,Definition 4]), and Ω j(k) and w j(k) are the elements of the pair S j(k) = (Ω j(k) , w j(k) ), respectively.
To prove the convergence of Algorithm 2, we make use of the following theorem, which is a slightly rephrased version of Theorem 3.1 in [4].

Theorem 5.9 Let D be a nonempty closed convex subset of H, and let (T i ) m i=1 be a finite family of self NEs on D such that F
Let i(k) = k mod m + 1 be a cyclic control sequence, let (λ k ) k∈N be a steering sequence, and let u, x 0 ∈ D. Then any sequence (x k ) k∈N generated by converges strongly to P F (u).
With the aid of the sequence (S r ) |M | r=1 and Theorem 5.9, we present in the next theorem a proof of convergence of Algorithm 2.

Theorem 5.10 Let D be a nonempty closed convex subset of H, and let (T i ) m i=1 be a finite family of self FNEs on D such that F
Let M be a finite subset of M, let j(k) = k mod |M | + 1 for all k ≥ 0 be a cyclic control sequence, and let (λ k ) k∈N be a steering sequence. Let u, x 0 ∈ D. Then any sequence (x k ) k∈N , generated by Algorithm 2, converges strongly to P F (u).
Proof Define the finite family of operators (T S r ) |M | r=1 by T S r := t∈Ω r w r (t)T[t], where for every r ∈ {1, 2, . . . , |M |}, S r := (Ω r , w r ). We first show that for every r ∈ {1, 2, . . . , |M |} the operator T S r is both NE and sQNE. By similar arguments to those made for T in the proof of Theorem 5.6, it follows that (T S r ) |M | r=1 is a family of NEs. From the proof of Lemma 5.4 we deduce that (T[t]) t∈Ω r is a family of QNEs such that for every r ∈ {1, 2, . . . , |M |}. Therefore, we are able to apply Proposition 5.3 to the family (T[t]) t∈Ω r (in place of the family (T i ) m i=1 ) for every r ∈ {1, 2, . . . , |M |}, which results in Therefore, by (25), In particular, the latter shows that, for given r and any t ∈ Ω r , we have, due to (26), that for all x ∈ D \ Fix(T[t]) and y ∈ Fix(T S r ), |M | r=1 is a family of NEs and it satisfies (23), we let the role of the family (T i ) m i=1 in Theorem 5.9 to be played by the family (T S r ) |M | r=1 . Moreover, by taking the sequence (i(k)) k∈N in Theorem 5.9 to be (j(k)) k∈N , (22) turns out to be a special case of (24), and we deduce that any sequence (x k ) k∈N , generated by (22), converges strongly to P |M | r=1 Fix(T Sr ) (u). Now, (26), (14), and the fitness of Ω (recall Definition 5.1) imply that and, in conclusion, This concludes our treatment of the quasi-dynamic string-averaging algorithm for solving the best approximation problem in the finite case.

Simultaneous string-averaging methods
One possibility to define a simultaneous string-averaging method was discussed in Remark 5.7 above and termed "fully simultaneous". By using a family of string-averaging operators (T S r ) |M | r=1 , as in Sect. 5.2, and employing an additional weight sequence (ŵ r ) |M | r=1 of strictly positive real numbers such that |M | r=1ŵ r = 1, we can construct yet another algorithm of a simultaneous nature for solving the best approximation problem to common fixed point sets of operators in the finite case. This algorithm convexly combines via (ŵ r ) |M | r=1 the points T S r (x k ), which amounts to string-averaging the end-points of the string operators T[t] for every t ∈ Ω r and for every r ∈ {1, 2, . . . , |M |}. The scheme is as follows.
Algorithm 3 (The simultaneous string-averaging algorithm for solving the best approximation problem in the finite case) Initialization: x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and (ŵ r ) |M | r=1 are userchosen strictly positive real numbers such that |M | r=1ŵ r = 1.
It is possible to obtain the convergence of Algorithm 3 from Theorem 5.6 about our static string-averaging Algorithm 1. But this would limit the scope to a family (T S r ) |M | r=1 of FNEs only. Therefore, we derive the convergence of Algorithm 3 from Corollary 30.2 in [7] which holds for NEs. We do this next. Let D be a nonempty closed convex subset of H, and let (T i ) m i=1 be a finite family of self NEs on D.

Algorithm 4 (The fully-simultaneous algorithm for the best approximation problem in Corollary 30.2 of [7])
Initialization: x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and (w i ) m i=1 is a sequence of user-chosen strictly positive numbers such that m i=1 w i = 1.
A slightly rephrased version of Corollary 30.2 of [7] is as follows.

Theorem 5.11 Let D be a nonempty closed convex subset of H, and let (T i ) m i=1 be a finite family of self NEs on D such that F
be a sequence of strictly positive real numbers such that i∈I w i = 1, and let (λ k ) k∈N be a steering sequence. Let u, x 0 ∈ D. Then any sequence (x k ) k∈N , generated by Algorithm 4, converges strongly to P F (u).
Algorithm 3 is now a special case of Algorithm 4 and its convergence follows from the above theorem. Proof In the proof of Theorem 5.10 we showed that the family (T S r ) |M | r=1 is a family of NEs with a nonempty common fixed points set, and so, Theorem 5.11 implies that any sequence (x k ) k∈N , generated by Algorithm 3, converges strongly to P |M | r=1 Fix(T Sr ) (u). Now, from (29), we conclude that

String-averaging with orthogonal projections for the best approximation to a finite family of closed convex sets
In this section we specialize our results on string-averaging methods for solving the best approximation problem to orthogonal projections since they are known to be FNEs (see, e.g., [6, Facts 1.5(i)]). We start by looking at the static string-averaging method with orthogonal projections, which is a special case of our Algorithm 1. We show that the simultaneous version of the Halpern-Lions-Wittman-Bauschke (HLWB) algorithm, used in [14,Algorithm 5], and the sequential Halpern-Wittman algorithm (see, e.g., Bauschke and Koch [8,Algorithm 4.1]) are special cases of the string-averaging methods.

The static string-averaging method for a finite family of closed convex sets
We write down formally the static string-averaging method for a finite family of orthogonal projections in order to make sure that our string operators in such a case remain well defined. Let D ⊆ H be a subset of H, and let (C i ) m i=1 be a finite family of closed convex sets C i ⊆ D for every i ∈ {1, 2, . . . , m}. We denote by P C i : D → C i the orthogonal projection onto the closed convex set C i . We now present the static string-averaging method for a finite family of closed convex sets.
Algorithm 5 (The static string-averaging algorithm for the best approximation to a finite family of closed convex sets) Initialization: Choose a single pair (Ω, w) ∈ M and arbitrary x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and w(t) and P[t] are as in Definition 5.1 with The proof of convergence of Algorithm 5 follows.
Theorem 6.1 Let D be a nonempty closed convex subset of H, and let (C i ) m i=1 be a finite family of closed convex sets C i ⊆ D for every i ∈ {1, 2, . . . , m} such that C := m i=1 C i = ∅. Let (Ω, w) ∈ M, let (λ k ) k∈N be a steering sequence, and let u, x 0 ∈ D. Then any sequence (x k ) k∈N , generated by Algorithm 5, converges strongly to P C (u).
Proof This is a straightforward consequence of Theorem 5.6. Set the finite family of FNEs in Theorem 5.6 to be (P C i ) m i=1 . Then (34) turns out to be a special case of (17), and so, by Theorem 5.6, any sequence (x k ) k∈N , generated by Algorithm 5, converges strongly to P C (u).

The simultaneous Halpern-Lions-Wittman-Bauschke algorithm as a special case
In [21] a parallel version of Halpern's algorithm leads to a simultaneous Halpern-Lions-Wittman-Bauschke (HLWB) algorithm for a countable family of FNEs, see also Deutsch and Yamada [26]. Here we present a simultaneous HLWB algorithm for the case of a finite family of closed convex sets. The convergence of this algorithm follows directly by choosing strings that are singletons such that each index i ∈ {1, 2, . . . , m} appears in one string. Thus, this algorithm is not only a consequence of the above-mentioned work of Combettes but also a consequence of our work here. Again, let D be a nonempty closed convex subset of H, let (C i ) m i=1 be a finite family of closed convex sets C i ⊆ D for every i ∈ {1, 2, . . . , m} such that C := m i=1 C i = ∅.
Algorithm 6 (The simultaneous HLWB algorithm with orthogonal projections for the best approximation to a finite family of closed convex sets) Initialization: x 0 = u. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and (w i ) m i=1 is a sequence of user-chosen strictly positive real numbers such that i∈I w i = 1.

The Halpern-Wittman algorithm as a special case
Following the results in [29], Wittman [35] showed the convergence of an algorithm that is presented in [8,Algorithm 4.1] and is named there the Halpern-Wittman algorithm. It is designed for a finite family of orthogonal projections and a specific steering sequence. This algorithm is presented below as Algorithm 7 and its convergence follows directly from the convergence of Algorithm 5 by putting all indices of i ∈ {1, 2, . . . , m} into a single string. Again, let D be a nonempty closed convex subset of H, and let (C i ) m i=1 be a finite family of closed convex sets C i ⊆ D for every i ∈ {1, 2, . . . , m} such that C := m i=1 C i = ∅.

Algorithm 7 (The Halpern-Wittman algorithm)
Initialization: x 0 = u. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where u is the given anchor point.

String-averaging methods for best approximation to the common fixed points set of a family of firmly nonexpansive operators: the infinite case
In this section we propose a string-averaging method for solving the best approximation problem to the common fixed point set of a countable family of FNEs (T i ) i∈I , where I is a countable set of positive integers. We use similar terms to the ones that were used in Sect. 5 for the finite case, extending Definition 5.1 to the countable case.
The following definition elaborates how this expansion is made.
Definition 7.1 Let D be a nonempty closed convex subset of H, and let (T i ) i∈I be a countable family of self operators on D. An index vector is a vector of the form t = (t 1 , t 2 , . . . , t p ) such that t ∈ I for all ∈ {1, 2, . . . , p}. For a given index vector t = (t 1 , t 2 , . . . , t q ), we denote its length (i.e., the number of its components) by γ (t) = q and define the operator T[t] as the (finite) composition of the operators T i whose indices appear in the index vector t, namely and call it a string operator. An infinite set Ω of index vectors is called fit if, for each i ∈ I, there exists a vector t = (t 1 , t 2 , . . . , t p ) ∈ Ω such that t = i for some ∈ {1, 2, . . . , p}. Denote by M the collection of all pairs (Ω, w), where Ω is a fit countable set of index vectors and w : Ω → (0, 1) is such that t∈ w(t) = 1.
Observe that in Definition 5.1 w : → (0, 1] is permitted, whereas here we must have w : Ω → (0, 1). This is due to the fact that in the infinite case here it is impossible to put all operators (T i ) i∈I in a single string operator T[t].

The static string-averaging method for the infinite case
Algorithm 1 handles a finite family of FNEs (T i ) m i=1 and throughout its iterative process, a finite number of string operators T[t] is used to construct a single string-averaging operator T = t∈ w(t)T [t]. In the infinite case we allow an infinite family (T i ) i∈I . In our extension to the infinite case Ω is countable (not finite as it was before), and we allow a countable number of string operators T[t] and a chosen fixed (infinite dimensional) weight vector, making now the single string-averaging operator T := t∈ w(t)T[t] an infinite series. The fact that only a single T is used makes this a "static" string-averaging method. Algorithm 8 below is our suggested method for this case. Initialization: Choose a single pair (Ω, w) ∈ M and arbitrary x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and w(t) and T[t] are as in Definition 7.1.
Our aim is to use again Theorem 5.5 to prove the convergence of Algorithm 8 to the projection of the anchor point onto the common fixed point set of the initial given family of FNEs. Recall that, when we did so earlier for the finite case, we used Lemma 5.4, which in turn depended on Propositions 5.2 and 5.3. As we are now dealing with the countable case, we first extend these propositions to the countable case. Note that since the length of any index vector remains finite in our countable case, Proposition 5.2 remains applicable. Hence, we only slightly adjust Proposition 5.3 as follows and present an elementary proof of it.

Proposition 7.2 Let D be a nonempty subset of H, let (T i ) i∈I be a countable family of self
QNEs on D such that i∈I Fix(T i ) = ∅, and let (w i ) i∈I be a countable sequence of strictly positive real numbers such that i∈I w i = 1. Then Fix( i∈I w i T i ) = i∈I Fix(T i ).
Proof First, let us show that i∈I w i T i is a well-defined operator. That is, for every x ∈ D, we have to show that i∈I w i T i (x) converges as an infinite series. Fix x ∈ D, let f ∈ i∈I Fix(T i ) and let T i ∈ (T i ) i∈I . First, we observe that, by the quasi-nonexpansivity of T i , which shows that the series converges. Define the sequence of partial sums of i∈I w i T i (x), i.e., for every n ∈ N, In order to apply the Cauchy criterion for series convergence, we use (39) to obtain Since the series in (40) is convergent, it follows that which shows that (S n ) n∈N is a Cauchy sequence, thus, from the completeness of H, (S n ) n∈N converges and, hence, i∈I w i T i (x) converges as well and i∈I w i T i (x) is well defined, as required. The rest of the proof is similar to the proof of Corollary 4.48 in [7], which is quoted above in our Proposition 5.3. Set Q := i∈I w i T i . It is clear that i∈I Fix(T i ) ⊆ Fix(Q). To handle the opposite inclusion, we first do the following calculation. Let y ∈ i∈I Fix(T i ). Then, for every i ∈ I and any x ∈ D, which, together with the quasi-nonexpansivity of T i , yields Now let us take a point z ∈ Fix(Q) and observe that it can be rewritten as z = i∈I w i z.
Then from (44) it follows that but only if the right-hand side series -i∈I w i T i (z)z 2 is convergent. To prove this last claim, we use (39) and the Cauchy-Schwarz inequality to reach for any f ∈ i∈I Fix(T i ). Hence, by (46), and once more by (39), we have The first infinite sum on the right-hand side of (47) is a convergent series due to (39), the middle series on the right-hand side of (46) is convergent because of (46), and the last series converges trivially, thus the series i∈I w i T i (z)z 2 is convergent and (45) guarantees that i∈I w i T i (z)z 2 = 0. Since w i = 0 for all i ∈ I, we obtain that z ∈ i∈I Fix(T i ).
We are now ready to extend Lemma 5.4 to the countable case. Proof The proof proceeds in several steps. First, the family (T[t]) t∈Ω is countable because Ω is, and since T[t] = T t q T t q-1 · · · T t 1 is a finite composition, we use similar arguments to those in the proof of Lemma 5.4 to show that (T[t]) t∈Ω is a family of QNEs with nonempty Therefore, Since every FNE is NE (see Lemma 3.3(i)), we apply, for every t ∈ Ω, [13, Lemma 2.1.12(ii)] to the family (T t ) q =1 and conclude that the string operator T[t] := T t q T t q-1 · · · T t 1 is NE. Thus, from (48) which guarantees the nonemptiness of Fix(T[t]) and due to the fact that every NE with a fixed point is QNE, the family of operators (T[t]) t∈Ω is a family of QNEs.
Secondly, by similar arguments to those that appear in the first part of the proof of Proposition 7.2, T is a well-defined operator and we can apply Proposition 7.2 with the family (T[t]) t∈Ω instead of the family (T i ) i∈I and with the family (w(t)) t∈Ω instead of the family (w i ) i∈I used there. Hence, we get Now we apply Proposition 5.2 to the finite family (T t ) q =1 . To do so, we note that, by Lemma 3.3(iii), all members of (T i ) i∈I are sQNEs, and so, for every t ∈ Ω, Proposition 5.2 yields that the string operator Finally, from the fitness of Ω, from (50) and from (51), we obtain that It is well known that a convex combination of NEs is a NE (see, e.g., [13, Lemma 2.1.12]). Since the string operators T[t] in Algorithm 8 appear inside an infinite series that resembles a convex combination, our next aim is to show that, under certain assumptions, the string-averaging operator T = t∈ w(t)T[t] is NE. The following lemma will show this. Lemma 7.4 Let D be a nonempty subset of H, and let (S i ) i∈I be a countable family of NEs such that, for every i ∈ I, S i : D → H and i∈I Fix(S i ) = ∅. Then S := i∈I w i S i , where (w i ) i∈I is a countable sequence of strictly positive real numbers such that i∈I w i = 1, is NE.
Proof By using similar arguments to the ones that were used in Proposition 7.2 for T, we deduce that S is well defined. Now, let x, y ∈ D. By the nonexpansivity of every S i and since Thus, by Definition 3.1(i), S is NE.
We are now ready to prove convergence of Algorithm 8.
Theorem 7.5 Let D be a nonempty closed convex subset of H, and let (T i ) i∈I be a countable family of self FNEs on D such that F := i∈I Fix(T i ) = ∅. Let ( , w) ∈ M, let (λ k ) k∈N be a steering sequence, and let u, x 0 ∈ D. Then any sequence (x k ) k∈N , generated by Algorithm 8, converges strongly to P F (u).
Proof For (T i ) i∈I and ( , w) ∈ M, consider the family of operators (T[t]) t∈Ω and define the string-averaging operator T := t∈Ω w(t)T [t]. By the proof of Lemma 5.4, we deduce that (T[t]) t∈Ω is a countable family of NEs, and thus, T is a "convex combination" of countably many NEs. Since F ⊆ t∈Ω Fix(T[t]), it follows that t∈Ω Fix(T[t]) = ∅ and, therefore, it can be shown by using similar arguments to the ones that were used in Proposition 7.2, that T is a well-defined operator. Moreover, Lemma 7.4 yields that T is NE, and since Fix(T) ⊇ F = ∅, Theorem 5.5 is applicable to T and implies that every sequence (x k ) k∈N generated by Algorithm 8 converges strongly to P Fix(T) (u). Now, by applying Lemma 7.3 on (T i ) i∈I together with (Ω, w), we obtain that Fix(T) = F, thus x k → P F (u).
In [21] the following simultaneous algorithm for solving the best approximation problem to the common fixed point set of a countable family of FNEs with a nonempty common fixed points set is studied. This algorithm turns out to be a special case of our Algorithm 8 when the pair (Ω, w) is chosen := {(1), (2), (3), . . .} and for every i ∈ I, w((i)) := w i . The convergence of this algorithm then follows from our Theorem 7.5.

Algorithm 9 (Combettes simultaneous algorithm)
Initialization: Choose x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate x k+1 by where (λ k ) k∈N is a steering sequence, u is the given anchor point, and (w i ) i∈I is a sequence of user-chosen strictly positive real numbers such that i∈I w i = 1.

Concluding comments
In this work we expand the class of string-averaging methods by proposing new stringaveraging approaches for solving the BAP for the common fixed points set of either a finite or an infinite family of FNEs. These methods vary from the "static" format, in which one uses a single pair (Ω, w) ∈ M, to quasi-dynamic and simultaneous formats, where more  [1], where a sequential algorithm for solving the BAP to the common fixed points set of a semigroup of nonexpansive operators in Hilbert space was studied, can be extended to encompass stringaveraging algorithmic schemes.