Efficient iterative solutions to complex-valued nonlinear least-squares problems with mixed linear and antilinear operators.

We consider a setting in which it is desired to find an optimal complex vector x ∈ C N that satisfies A (x) ≈ b in a least-squares sense, where b ∈ C M is a data vector (possibly noise-corrupted), and A (·) : C N → C M is a measurement operator. If A (·) were linear, this reduces to the classical linear least-squares problem, which has a well-known analytic solution as well as powerful iterative solution algorithms. However, instead of linear least-squares, this work considers the more complicated scenario where A (·) is nonlinear, but can be represented as the summation and/or composition of some operators that are linear and some operators that are antilinear. Some common nonlinear operations that have this structure include complex conjugation or taking the real-part or imaginary-part of a complex vector. Previous literature has shown that this kind of mixed linear/antilinear least-squares problem can be mapped into a linear least-squares problem by considering x as a vector in R 2N instead of C N . While this approach is valid, the replacement of the original complex-valued optimization problem with a real-valued optimization problem can be complicated to implement, and can also be associated with increased computational complexity. In this work, we describe theory and computational methods that enable mixed linear/antilinear least-squares problems to be solved iteratively using standard linear least-squares tools, while retaining all of the complex-valued structure of the original inverse problem. An illustration is providedtodemonstratethatthisapproachcansimplifytheimplementationandreduce the computational complexity of iterative solution algorithms.

Introduction

Consider a generic complex-valued finite-dimensional inverse problem scenario in which the forward model is represented as where represents the measured data, is the measurement operator, represents noise, and represents the unknown signal that we wish to estimate based on knowledge of b and . A common approach to solving this inverse problem is to find a least-squares solution where ‖·‖2 denotes the standard ℓ2-norm. This choice of formulation can be justified in multiple ways, and e.g., corresponds to the optimal maximum likelihood estimator when the noise vector n is independent and identically-distributed (i.i.d.) Gaussian noise (Kay 1993). Even for more complicated noise statistics that follow, e.g., the Poisson, Rician, or non-Central Chi distributions, there exist iterative methods that allow the maximum likelihood estimator to be obtained by iteratively solving a sequence of least-squares objective functions (Erdogan and Fessler 1999; Fessler and Erdogan 1998; Varadarajan and Haldar 2015). In addition, another reason for the popularity of least-squares is that the optimization problem is frequently very easy to solve. For example, in the case where (·) is a linear operator (i.e., (·) can be represented in an equivalent matrix form as (x) = Ax for some matrix ) with a trivial nullspace, the solution to Eq. (2) has the analytic closed-form expression (Luenberger 1969) where denotes the conjugate-transpose operation. In large-scale problems where N is very large, the matrix inversion in Eq. (3) may be computationally intractable, although there exist a variety of simple iterative algorithms that are guaranteed to converge to a globally-optimal solution, including Landweber iteration (Landweber 1951), the conjugate gradient (CG) algorithm (Hestenes and Stiefel 1952), and LSQR (Paige and Saunders 1982).

Instead of assuming linearity, we focus in this work on solving least-squares problems in the scenario where (·) is nonlinear, but can be represented as the summation and/or composition of some operators that are linear and some operators that are antilinear. Such nonlinear operators have sometimes been termed as real-linear operators in mathematical physics (Huhtanen and Ruotsalainen 2011). Important common examples of operators that possess this kind of nonlinear structure include the complex-conjugation operator the operator that takes the real part of a complex vector and the operator that takes the imaginary part of a complex vector

Even though the descriptions we present in this paper are generally applicable to arbitrary real-linear operators, we were initially motivated to consider such operators because of specific applications in magnetic resonance imaging (MRI) reconstruction. In particular, MRI images are complex-valued, and real-linear operators have previously been used to incorporate prior information about the image phase characteristics into the image reconstruction process, which helps to regularize/stabilize the solution when the inverse problem is ill posed. For example, there is a line of research within MRI that poses phase-constrained image reconstruction as either (Bydder and Robson 2005; Willig-Onwuachi et al. 2005; Lew et al. 2007; Hoge et al. 2007; Haldar et al. 2013; Blaimer et al. 2016; Markovsky 2011) or (Bydder 2010)

In the case of Eq. (7), is a positive regularization parameter and the matrix B embeds prior information about the image phase such that the regularization encourages Bx to be real-valued. In the case of Eq. (8), the phase information is embedded in the matrix A, such that the vector x is strictly forced to be real-valued. Another line of research within MRI instead imposes phase constraints by leveraging linear predictability and the conjugate-symmetry characteristics of the Fourier transform, leading to an inverse problem formulation that can take the general form (Haldar 2014, Haldar and Setsompop 2020, Haldar 2015, Kim and Haldar 2018) for appropriate matrices C, D, and E.

Although these are nonlinear least-squares problems because the operators involved are nonlinear, previous work has benefitted from the fact that this kind of inverse problem can be transformed into an equivalent higher-dimensional real-valued linear least-squares problem (Bydder and Robson 2005; Willig-Onwuachi et al. 2005; Lew et al. 2007; Hoge et al. 2007; Haldar et al. 2013; Blaimer et al. 2016; Haldar 2014; Haldar and Setsompop 2020; Haldar 2015; Kim and Haldar 2018). Specifically, this can be done by replacing all complex-valued quantities with real-valued quantities, e.g., separating into its real and imaginary components, and treating this as an inverse problem in rather than the original space . While this real-valued transformation of the problem is effective and enables the use of standard linear least-squares solution methods, it can also cause computational inefficiencies and can sometimes be difficult to implement when the operators involved have complicated structure.

In this work, we describe theory that enables provably-convergent linear least-squares iterative algorithms to be applied to this nonlinear least-squares problem setting, without requiring a real-valued transformation of the original complex-valued vectors and operators. This can enable both improved computation speed and simplified algorithm implementations.

Background

Linear, antilinear, and real-linear operators

In this section, we briefly summarize some definitions and properties of linear and antilinear operators, with simplifications corresponding to our finite-dimensional problem context. Readers interested in a more detailed and more general treatment are referred to Refs. (Rudin 1991; Huhtanen and Ruotsalainen 2011).

Definition 1

(Linear Operator) An operator is said to be linear (or complex-linear) if it satisfies both additivity and homogeneity

Property 1

For any linear operator , there is a unique matrix such that .

Definition 2

(Antilinear Operator) An operator is said to be antilinear (or conjugate-linear) if it satisfies both additivity and conjugate homogeneity

Property 2

For any antilinear operator , there is a unique matrix such that .

Note that by taking the matrix G as the identity matrix, we observe that applying complex conjugation is an antilinear operation on the vector x.

Definition 3

(Real-Linear Operator) An operator is said to be real-linear if it satisfies both additivity and homogeneity with respect to real-valued scalars

Real-linearity is a generalization of both linearity and antilinearity, as can be seen from the following property.

Property 3

Every real-linear operator can be uniquely decomposed as the sum of a linear operator and an antilinear operator. In particular, , where is the linear operator defined by and is the antilinear operator defined by

Property 4

For any real-linear operator , there are unique matrices such that .

Notably, both the real(·) and imag(·) operators from Eqs. (5) to (6) are observed to have real-linear form.

Property 5

For any two real-linear operators and , their sum is also a real-linear operator.

Property 6

For any two real-linear operators and , their composition is also a real-linear operator.

As can be seen, any operator that can be represented as the summation and/or composition of some operators that are linear and some operators that are antilinear can be viewed as a real-linear operator. As a result, the scenarios of interest in this paper all involve real-linear operators, and the remainder of this paper will assume that (·) obeys real-linearity, and has been decomposed in matrix form as .

Real-valued transformation of complex-valued least squares

Assuming (·) is real-linear as described in the previous subsection, Eq. (2) can be rewritten as which is a nonlinear least squares problem. However, as stated in the introduction, previous work (Bydder and Robson 2005; Willig-Onwuachi et al. 2005; Lew et al. 2007; Hoge et al. 2007; Haldar et al. 2013; Blaimer et al. 2016; Haldar 2014; Haldar and Setsompop 2020; Haldar 2015; Kim and Haldar 2018) has transformed this problem into the form of a conventional linear least-squares problem by treating the variable x as an element of instead of . This was achieved by rewriting as x = x + ix, where the real-valued vectors represent the real and imaginary components of x. This allows us to equivalently rewrite the solution to Eq. (18) as , with where and

The final expression in Eq. (19) has the form of a standard real-valued linear least-squares problem, and therefore can be solved using any of the linear least-squares solution methods described in the introduction. For example, the Landweber iteration (Landweber 1951) applied to this problem would proceed as given in Algorithm 1, and with infinite numerical precision, is guaranteed to converge to a globally optimal solution as k → ∞ whenever .

Algorithm 1:

Landweber Iteration applied to Eq. (19)

Inputs: A˜∈ℝ^2M×2N, b˜∈ℝ^2M, x˜_0∈ℝ^2N (initial guess for x˜), and α∈ℝ

(step size parameter)

Initialization:

k = 0;

Iteration:

While stopping conditions are not met:

x˜_k+1=x˜_k+αA˜^H(b˜−A˜x˜_k);

k = k + 1;

Output: Final value of x˜_k+1

As another example, the CG algorithm (Hestenes and Stiefel 1952) applied to this problem would proceed as given in Algorithm 2, and with infinite numerical precision, would be guaranteed to converge to a globally optimal solution after at most 2N iterations.

Algorithm 2:

Conjugate Gradient Algorithm applied to Eq. (19)

Inputs: A˜∈ℝ^2M×2N, b˜∈ℝ^2M, and x˜_0∈ℝ^2N (initial guess for x˜)

Initialization:

r_0=A˜^H(b˜−A˜x˜_0);

p0 = r0;

k = 0;

Iteration:

While stopping conditions are not met:

z_k=A˜^HA˜p_k;

α_k=(rkHr_k)/(pkHz_k);

x˜_k+1=x˜_k+α_kp_k;

r_k+1=r_k−α_kz_k;

β_k=(rk+1Hr_k+1)/(rkHr_k);

p_k+1=r_k+1+β_kp_k;

k=k+1;

Output: Final value of x˜_k+1

Compared to the analytic linear least-squares solution corresponding to Eq. (3), these iterative algorithms are generally useful for larger-scale problems where the matrix à may be too large to store in memory, and where the matrix has structure so that matrix-vector multiplications with à and à can be computed quickly using specially-coded function calls rather than working with actual matrix representations (e.g., if à has convolution structure so that matrix-vector multiplication can be implemented using the Fast Fourier Transform, if à is sparse, etc.).

Although the problem transformation from Eq. (19) has been widely used (Bydder and Robson 2005; Willig-Onwuachi et al. 2005; Lew et al. 2007; Hoge et al. 2007; Haldar et al. 2013; Blaimer et al. 2016; Haldar 2014; Haldar and Setsompop 2020; Haldar 2015; Kim and Haldar 2018), it can also be cumbersome to work with if the operator (·) has more complicated structure. For example, the optimization problem in Eq. (9) involves the composition of linear and antilinear operators, and the à matrix corresponding to this case has a complicated structure that is laborious to derive. In particular, with much manipulation, the matrix for this case can be derived to be with and

Of course, Eq. (9) relies on a relatively simple mixture of linear and antilinear operators, and problems involving more complicated mixtures would be even more laborious to derive.

Beyond just the effort required to compute the general form of Ã, it can also be computationally expensive to try to use this type of expression in an iterative algorithm, particularly when the different operators have been implemented as specially-coded function calls. For example, if we were not given the actual matrix representations of A, C, D, and E in Eq. (23) and only had function calls that implemented matrix-vector multiplication with these matrices, then a naive implementation of matrix multiplication between à and a vector would require 4 calls to the function that computes multiplication with A (e.g., to compute real(A)r for an arbitrary real-valued vector , we could instead compute the complex-valued matrix-vector multiplication function call to obtain s = Ar, and then use real(A)r = real(s), with an analogous approach for computing imag(A)t for an arbitrary real-valued vector ), 4 calls to the function that computes multiplication with C, 8 calls to the function that computes multiplication with D, and 8 calls to the function that computes multiplication with E. This relatively large number of function calls represents a substantial increase in computational complexity compared to a standard evaluation of the complex-valued forward model, which would only require the use of one function call for each operator. Of course, this number of computations is based on a standard naive implementation, and additional careful manipulations could be used to reduce these numbers of function calls by exploiting redundant computations – however, this would contribute further to the laborious nature of deriving the form of Ã.

Main results

Our main results are given by the following lemmas, which enable the use of the real-valued linear least-squares framework from Sect. 2.2 while relying entirely on complex-valued representations and computations.

Lemma 1

Consider a real-linear operator , with corresponding à matrix as defined in . Also consider arbitrary vectors and , which are decomposed into their real and imaginary components according to m = m + im and n = n + in, with and . Then and with *(·) defined below.

Definition 4

(*(·)) Consider a real-linear operator , which is represented for as for some matrices . We define as the mapping for .

Note that *(·) is also a real-linear operator, and can be equivalently written in real-linear form as for , where denotes the transpose operation (without conjugation). Interestingly, it can also be shown that *(·) matches the definition of the adjoint operator of (·) from real-linear operator theory (Huhtanen and Ruotsalainen 2011). We believe this is interesting because our definition of *(·) was derived independently of adjoint concepts. In addition, while the adjoint of a linear operator is well-known to be useful for solving linear least-squares problems, the adjoint definition used in real-linear operator theory is different from that used in the linear case (Huhtanen and Ruotsalainen 2011), and we had no prior expectations that the real-linear definition of adjoint would be related to the present work.

Lemma 2

Consider a real-linear operator that can be written as the composition of real-linear operators and . Then .

Lemma 3

Consider a real-linear operator that can be written as the summation of real-linear operators and . Then .

The proofs of these three lemmas are straightforward, and are given in the appendices. Note that results similar to Lemmas 2 and 3 have been previously described for the adjoints of real-linear operators (Huhtanen and Ruotsalainen 2011), although the previous results were derived in a different context and relied on different concepts and proof techniques than those used in this paper (i.e., our approach is completely free of the inner-product-based real-linear adjoint concepts that were central to previous literature).

When combined together, Lemmas 1-3 completely eliminate the need to derive or work with the real-valued matrix à in the context of iterative algorithms, because the effects of multiplication with the real-valued matrices à and à can be obtained equivalently using the complex-valued nonlinear operators (·) and *(·). This can also lead to computational savings, since e.g., computing real ((m)) and imag((m)) (as needed for computing multiplication of the matrix with a vector using Eq. (28)) only requires a single call to the function that computes (m). Likewise, computing multiplication of the matrix à with a vector only requires a single call to the function that computes *(·). And further, if (·) is represented as a complicated summation and/or composition of real-linear operators, we can rely on Properties 5 and 6 and Lemmas 2 and 3 to build *(·) incrementally from the individual constituent operators, rather than needing to use Definition 4 (which would require (·) to be simplified so that it can be decomposed using F and G matrices).

As a consequence of these lemmas, it is, e.g., possible to replace the real-valued Landweber iteration from Algorithm 1 with the simpler complex-valued iteration given by Algorithm 3.

Algorithm 3:

Proposed Complex-Valued Landweber Iteration

Inputs: A(⋅):ℂ^N→ℂ^N, b∈ℂ^M, x_0∈ℂ^N (initial guess for x), and α∈ℝ

(step size parameter:)

Initialization:

k = 0;

Iteration:

While stopping conditions are not met:

xk+1 = xk + αA*(b − Axk);

k = k + 1;

Output: Final value of xk+1

With infinite numerical precision, Algorithm 3 will produce the exact same sequence of iterates as Algorithm 1, and will therefore have the exact same global convergence guarantees stated previously for Landweber iteration.

We can make similar modifications to the CG algorithm from Algorithm 2, although need the following additional property to be able to correctly handle the inner-products appearing in the CG algorithm.

Property 7

Consider arbitrary vectors , which are decomposed into their real and imaginary components according to p = p + ip and q = q + iq, with p, p, q, q ∈ . Define according to Then .

Combining this property with the previous lemmas leads to the simple complex-valued iteration for the CG algorithm given by Algorithm 4.

Algorithm 4:

Proposed Complex-Valued Conjugate Gradient Algorithm

Inputs: A(⋅):ℂ^N→ℂ^N, b∈ℂ^M, and x_0∈ℂ^N (initial guess for x)

Initialization:

r0 = A*(b − A(x0));

p0 = r0;

k = 0;

Iteration:

While stopping conditions are not met:

z_k=A^∗(A(p_k));

α_k=(rkHr_k)/real(pkHz_k);

x_k+1=x_k+α_kp_k;

r_k+1=r_k−α_kz_k;

β_k=(rk+1Hr_k+1)/(rkHr_k);

p_k+1=r_k+1+β_kp_k;

k=k+1;

Output: Final value of xk+1

While we have only shown complex-valued adaptations of the Landweber and CG algorithms, this same approach is easily applied to other related algorithms like LSQR (Paige and Saunders 1982).

Useful relations for common real-linear operators

Before demonstrating the empirical characteristics of our proposed new approach, we believe that our proposed framework will be easier to use if we enumerated some of the most common real-linear (·) operators and their corresponding *(·) operators. Such a list is provided in Table 1.

Table 1

Table of common real-linear (·) operators and corresponding *(·) operators. We also provide expressions for *((·)) in cases where the combined operator takes a simpler form than applying each operator sequentially. In the last two rows, it is assumed that the matrix , and that the vector is divided into two components and with . In the last row, we take , with corresponding . Note that a special case of equivalent complex-valued operators associated with Eq. (7) (with B chosen as the identity matrix) was previously presented by Ref. (Bydder and Robson 2005), although without the more general real-linear mathematical framework developed in this work

	A(x)forx∈ℂ^N	A^∗(y)fory∈ℂ^M	A^∗(A(x))forx∈ℂ^N
Real-linear	Fx+(Gx)¯	F^Hy+G^Hy¯
Conjugation	X¯	y¯	x
Real part	real(x)	real(y)	real(x)
Imaginary part	imag(x)	i · real(y)	i · imag(x)
System from Eq. (7)	[Axλ⋅imag(Bx)]	A^Hy_1+λiB^Hreal(y_2)	A^HAx+λiB^Himag(Bx)
System fromreal Eq. (8)	[Areal(x)imag(x)]	real(A^Hy_1)+i⋅real(y_2)	real(A^HAreal(x))+i⋅imag(x)
System from Eq. (9)	[AxλCx−λD(Ex)¯]	A^Hy_1+λB^∗(y_2)	A^HAx+λB^∗(B(x))

Numerical example

To demonstrate the potential benefits of our proposed complex-valued approach, we will consider an instance of the problem described by Eq. (9). In this case, the use of complex-valued operations can lead to both a simpler problem formulation and faster numerical computations.

To address simplicity, we hope that it is obvious by inspection that the process of deriving à for this case (as given in Eq. (23), and needed for the conventional real-valued iterative computations) was non-trivial and labor-intensive, while the derivation of (·) and *(·) (as given in Table 1, and needed for the proposed new complex-valued iterative computations) was comparatively fast and easy.

To address the computational benefits of the proposed approach, we will consider a specific realization of Eq. (9), in which , , , , , and , with the real and imaginary parts of all of these vectors and matrices drawn at random from the i.i.d. Gaussian distribution. We then took b = Ax + n, and set λ = 10−3. For this random problem instance, we find the optimal nonlinear least-squares solution in four distinct ways:

- Conventional real-valued approach with matrices

We assume that A, C, D, and E are available to us in matrix form, such that it is straightforward to directly precompute the real-valued matrix from Eq. (23). We then use this precomputed matrix directly in iterative linear least-squares solution algorithms like Landweber iteration, CG, and LSQR. Although the form of this à matrix was complicated to derive, multiplications with the precomputed à and à matrices within each iteration should be very computationally efficient, particularly since we have taken 4 separate complex-valued matrices A, C, D, and E that were originally specified by a sum total of 1.12 × 108 complex-valued entries (2.24 × 108 real numbers), and replaced them with a single real-valued matrix specified by only 2 × 108 real numbers. Every matrix-vector multiplications involving à or à will therefore require 2 × 108 real-valued scalar multiplications.

- Proposed complex-valued approach with matrices

As in the previous case, we assume that A, C, D, and E are available to us in matrix form, which allows us to directly form the F and G matrices corresponding to the complex-valued real-linear formulation of the problem. Specifically, F was formed as and G was formed as

We then used these precomputed matrices to evaluate (·) and *(·) as needed in our proposed complex-valued iterative algorithms. These precomputed F and G matrices are each specified by 5×107 complex-valued entries (i.e., a sum total of 1×108 complex-valued entries or 2×108 real-valued entries considering F and G together). However, since one complex-valued scalar multiplication corresponds to four real-valued scalar multiplications, applying the (·) or *(·) operators to vectors will require 4×108 real-valued scalar multiplications, which is twice the number of multiplications required in the previous case.

- Conventional real-valued approach with function calls

We assume that we do not have direct access to the A, C, D, and E matrices, but are only given blackbox functions that calculate matrix-vector multiplications with these matrices and their conjugate transposes. As such, we implement matrix-vector multiplication with à (and similarly for Ã) naively in each iteration of the conventional iterative linear least-squares solution algorithms, using multiple calls to each of these functions as described in Sect. 2.2. This approach is not expected to be computationally efficient given the large number of function calls, although is simpler to implement than more advanced approaches that might be developed to exploit redundant computations within Eq. (23).

- Proposed complex-valued approach with function calls

As in the previous case, we assume that we do not have direct access to the A, C, D, and E matrices, but are only given blackbox functions that calculate matrix-vector multiplications with these matrices and their conjugate transposes. We implement the proposed complex-valued iterative algorithms using the techniques described in Sect. 3, using the expressions for (·) and *(·) given in Table 1. In this case, applying the (·) or *(·) operators to vectors will require 1.12 × 108 complex-valued scalar multiplications (equal to sum total of the number of entries in A, C, D, and E, which corresponds to 4.48 × 108 real-valued scalar multiplications (slightly larger than the proposed complex-valued approach with matrices).

For the sake of reproducible research, Matlab code corresponding to this example is included as supplementary material.

For each case, we ran 50 iterations of Landweber iteration and 15 iterations of CG and LSQR in MATLAB 2018b, on a system with an Intel Core i7–8700K 3.70 GHz CPU processor. For each approach, each algorithm, and at each iteration, we computed (1) the total cumulative number of real-valued scalar multiplications (with 1 complex-valued scalar multiplication equal to 4 real-valued scalar multiplications) used by the algorithm thus far; (2) the cost function value from Eq. (9) using the current estimate (either x or ); (3) the total computation time in seconds; and (4) the relative ℓ2-norm difference between the x value estimated from the proposed method with function calls and the other methods, where we define the relative ℓ2-norm difference between arbitrary vectors p and q as . To minimize random fluctuations in computation speed due to background processing, the computation times we report represent the average of 15 different identical trials.

Results for Landweber iteration and the CG algorithm are reported in Figs. 1 and 2, respectively. The results for LSQR were quite similar to the results for CG (as expected theoretically Paige and Saunders 1982), and have been omitted. Results confirm that, as should be expected from the theory, all of the different approaches yield virtually identical cost function values and virtually identical solution estimates x/ at each iteration for each of the different algorithms. There are some very minor differences on the order of 10−15, which can be attributed to numerical effects resulting from finite-precision arithmetic. In terms of computational complexity, we observe that the matrix-based approaches are generally associated with fewer multiplications than the implementations that use function calls, which should be expected because the matrix-based approaches were able to precompute simpler consolidated matrix representations [e.g., the à matrix from Eq. (21) or the F and G matrices from Eqs. (31) and (32)] that were not available to the function call approaches.

Fig. 1

Results for Landweber iteration. The plots show the total number of multiplications, the normalized cost function value (normalized so that the initial value is 1), the computation time in seconds, and the relative difference between the solution from the conventional method with matrices and solutions obtained with other methods

Fig. 2

Results for the conjugate gradient algorithm. The plots show the total number of multiplications, the normalized cost function value (normalized so that the initial value is 1), the computation time in seconds, and the relative difference between the solution from the conventional method with matrices and solutions obtained with other methods

The proposed approaches required a moderate number of multiplications, some-what intermediate between the conventional approach with matrices (which had the fewest multiplications, as expected based on our previous discussion of the efficiency of the conventional approach with precomputation) and the conventional approach with function calls (which had the most multiplications). However, in terms of actual computation time, we observe that the conventional approach with function calls was much slower than any of the other three methods, while the other three methods were all similar to one another. It is perhaps surprising that the computation times are not directly proportional to the number of multiplications, although this discrepancy is likely related to MATLAB’s use of efficient parallelized matrix multiplication libraries. Importantly, we observe that both variations of the proposed approach are quite fast, and have computation times that are quite similar to the conventional real-valued approach with matrices (which, as we mentioned, was expected to have excellent computational efficiency). There was negligible difference between the computation times assocociated with matrices and function call implementations of the proposed method, which was definitely not the case for the conventional approaches. And in terms of implementation, the proposed approach with function calls was the easiest to implement, since it didn’t require us to derive the forms of any special matrices like Ã, F, or G, we could just directly work with the individual original matrices A, C, D, and E.

Conclusion

This work proposed a new approach to solving nonlinear least-squares problems involving real-linear operators. The new approach allows the use of the original complex-valued operators without transforming them into an unwieldy real-valued form. Theoretically, the approach enables identical iterative results as the conventional real-valued transformation, but with much simpler implementation options and potentially much faster computations. We expect the proposed approach to be valuable for solving general complex-valued nonlinear least-squares problems involving real-linear operators. Note that the proposed complex-valued approach is also an integral but previously-undescribed component of the most recent version of an open-source MRI reconstruction software package released by the authors (Kim and Haldar 2018).