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 at 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. 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.


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. String-averaging 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 points set of a family of self-mapping operators, the problem of finding such a 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 BAP are widely studied, and are useful in mathematics and various physical science (see, e.g., Bauschke and Borwein [6], Reich and Zalas [33] and Cegielski [13], to name but a few), including in the context of string-averaging 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, not proposed neither investigated. Motivated by this, we devote our research presented here, to developing stringaveraging algorithmic schemes for finding the best approximation to the common fixed points set of a, either finite or infinite, family of firmly nonexpansive operators. Besides pure mathematical interest, see, e.g., Dye, Khamsi and Reich [27] and 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 methods in which a fixed pre-determined 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,Subsection 30.2] and Haugazeau's method, see [7,Subsection 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 iteartive process was investigated there but the framework was more general due to the kind of operators (nonexpansive) and the size of the pool of opeartors (a semigroup, not limited to the countable case). This is a theoretical work in the spirit of the 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 Section 3, the work is divided into two main parts: A first part where the given family of firmly nonexpansive operators is finite, in Sections 5 and 6, and a second part where the given family of firmly nonexpansive operators is a countable family, in Section 7. The static, the quasi-dynamic and the simultaneous stringaveraging methods can be found in Subsections 5.1, 5.2 and 5.3, respectively. In Subsection 6, we show for which choices of pairs (Ω, w), the simultaneous version of the Halpern-Lions-Wittman-Baucschke algorithm and the Halpern-Wittman algorithm are special cases of our static string-averaging approach. In Subsection 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 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 projections approaches can be found in Aragón Artacho and Campoy [2] and Bergman, 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 string-averaging 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 stringaveraging, 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 string-averaging 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 : D → H be an operator. A vector x ∈ D is a fixed point of T if it satisfies T (x) = x. The set of all fixed points of T is denoted by F ix(T ) := {x ∈ D | T (x) = x} . If D is a closed convex set, then for every u ∈ H there exists a unique point Such a point y is called the projection of u onto D and denoted by P D (u). We now recall some definitions regarding various classes of operators. Then T is: (iv) Strictly quasi-nonexpansive (sQNE) if (v) C-strictly quasi-nonexpansive (C-sQNE) if T is quasi-nonexpansive and where C = ∅ and C ⊆ F ix(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. Definition 3.2. (steering sequences). A real sequence (λ k ) k∈N is called a steering sequence if it has the following properties: ∞ 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 the 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. 4 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 wellknown 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 Section 7, the point to which our string-averaging algorithm converges to.
5 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.
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.
As mentioned above, [7,Corollary 4.50] and [7,Proposition 4.47] are cornerstones to our proofs of convergence. The following are slight rephrased versions of them, respectively, adapted to our notations and needs.
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.
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 tq 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 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 F ix(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 F ix(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 F ix(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 an 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.
Theorem 5.6. Let D be a nonempty closed convex subset of H and let Then any sequence (x k ) k∈N , generated by Algorithm 1, converges strongly to P F (u).
and (Ω, w) ∈ M consider the family of operators (T [t]) t∈Ω and define the string-averaging operator T : 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, F ix(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 F ix(T ) (u). Now, applying Lemma 5.4 on 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 by choosing either 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 Section 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 stringaveraging 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] but, 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.
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].
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 := ∩ m i=1 F ix(T i ) = ∅. 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 Sr )
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 Sr is both NE and sQNE. By similar arguments to those made for T in the proof of Theorem 5.6, it follows that (T Sr ) |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 a given r and any t ∈ Ω r , we have, due to (26), that for all x ∈ D \ F ix(T [t]) and y ∈ F ix(T Sr ), Thus, T [t] is C-sQNE with C := F ix(T Sr ). Consequently, from (26), (27) and [ |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 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 Sr ) |M ′ | r=1 , as in Subsection 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 convexlycombines via (ŵ r ) |M ′ | r=1 the points T Sr (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 ) are user-chosen 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 Sr ) |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 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 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.
|M ′ | r=1 be as in Theorem 5.10, let (ŵ r ) |M ′ | r=1 be a sequence of strictly positive real numbers such that |M ′ | r=1ŵ r = 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 3, converges strongly to P F (u).
Proof. In the proof of Theorem 5.10 we showed that the family (T Sr ) |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 F ix(T Sr ) (u). Now, from (29), we conclude that 6 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, 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 an arbitrary x 0 ∈ D. Iterative step: Given the current iterate x k , calculate the next iterate 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, 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 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 : 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 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, 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 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.
7 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 Section 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, 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 exist 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.
Algorithm 8. The static string-averaging algorithm for solving the best approximation problem in the countable case. Initialization: Choose a single pair (Ω, w) ∈ M and an 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 above 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 F ix(T i ) = ∅ and let (w i ) i∈I be a countable sequence of strictly positive real numbers such that i∈I w i = 1.
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 F ix(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, S n := n i=1 w i T i (x). In order to apply the Cauchy criterion for series convergence, we use (39) to obtain (41) 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 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 To handle the opposite inclusion, we first do the following calculation. Let y ∈ ∩ i∈I F ix(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 ∈ F ix(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 F ix(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 F ix(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 tq 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 common fixed points set. Note that F = ∅ and (37) imply that for every t ∈ Ω and for every x ∈ F , 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 tq T t q−1 · · · T t 1 , is NE. Thus, from (48) which guarantees the non-emptiness of F ix(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 ∈ Ω, the 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 F ix(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 i∈I w i = 1, it follows that ||S(x) − S(y)|| = || i∈I w i S i (x) − i∈I w i S i (y)|| ≤ i∈I ||w i S i (x) − w i S i (y)|| ≤ i∈I w i ||S i (x) − S i (y)|| ≤ i∈I w i ||x − y|| = ||x − y||.
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 F ix(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∈Ω F ix(T [t]), it follows that ∩ t∈Ω F ix(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 F ix(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 F ix(T ) (u). Now, by applying Lemma 7.3 on (T i ) i∈I together with (Ω, w), we obtain that F ix(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 string-averaging 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 than a single pair is used. Nevertheless, these methods are obtained with string operators which are defined as finite compositions of operators, taken from the given family of operators, thus, the question for infinitely many compositions, i.e., strings of infinite length, remains open, as well as the question whether our methods can be extended to the fully dynamic case. Another question that remains open is whether the results of [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 string-averaging algorithmic schemes.

Declarations
Availability of data and materials: Not applicable.
Competing interests: The authors declare that they have no competing interests.
Funding: This work was supported by the ISF-NSFC joint research program grant No. 2874/19.
Authors' contributions: All authors contributed equally and significantly in this research work. All authors read and approved the final manuscript.