# tf.linalg.LinearOperatorCirculant3D

<br />

|---|
| [![](https://www.tensorflow.org/images/GitHub-Mark-32px.png) View source on GitHub](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator_circulant.py#L1114-L1272) |

`LinearOperator` acting like a nested block circulant matrix.

Inherits From: [`LinearOperator`](https://www.tensorflow.org/versions/r2.13/api_docs/python/tf/linalg/LinearOperator), [`Module`](https://www.tensorflow.org/versions/r2.13/api_docs/python/tf/Module)

#### View aliases


**Compat aliases for migration**

See
[Migration guide](https://www.tensorflow.org/guide/migrate) for
more details.

[`tf.compat.v1.linalg.LinearOperatorCirculant3D`](https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorCirculant3D)

<br />

    tf.linalg.LinearOperatorCirculant3D(
        spectrum,
        input_output_dtype=https://www.tensorflow.org/versions/r2.13/api_docs/python/tf/dtypes#complex64,
        is_non_singular=None,
        is_self_adjoint=None,
        is_positive_definite=None,
        is_square=True,
        name='LinearOperatorCirculant3D'
    )

This operator acts like a block circulant matrix `A` with
shape `[B1,...,Bb, N, N]` for some `b >= 0`. The first `b` indices index a
batch member. For every batch index `(i1,...,ib)`, `A[i1,...,ib, : :]` is
an `N x N` matrix. This matrix `A` is not materialized, but for
purposes of broadcasting this shape will be relevant.

#### Description in terms of block circulant matrices

If `A` is nested block circulant, with block sizes `N0, N1, N2`
(`N0 * N1 * N2 = N`):
`A` has a block structure, composed of `N0 x N0` blocks, with each
block an `N1 x N1` block circulant matrix.

For example, with `W`, `X`, `Y`, `Z` each block circulant,

    A = |W Z Y X|
        |X W Z Y|
        |Y X W Z|
        |Z Y X W|

Note that `A` itself will not in general be circulant.

#### Description in terms of the frequency spectrum

There is an equivalent description in terms of the \[batch\] spectrum `H` and
Fourier transforms. Here we consider `A.shape = [N, N]` and ignore batch
dimensions.

If `H.shape = [N0, N1, N2]`, (`N0 * N1 * N2 = N`):
Loosely speaking, matrix multiplication is equal to the action of a
Fourier multiplier: `A u = IDFT3[ H DFT3[u] ]`.
Precisely speaking, given `[N, R]` matrix `u`, let `DFT3[u]` be the
`[N0, N1, N2, R]` `Tensor` defined by re-shaping `u` to `[N0, N1, N2, R]` and
taking a three dimensional DFT across the first three dimensions. Let `IDFT3`
be the inverse of `DFT3`. Matrix multiplication may be expressed columnwise:

`(A u)_r = IDFT3[ H * (DFT3[u])_r ]`

#### Operator properties deduced from the spectrum.

- This operator is positive definite if and only if `Real{H} > 0`.

A general property of Fourier transforms is the correspondence between
Hermitian functions and real valued transforms.

Suppose `H.shape = [B1,...,Bb, N0, N1, N2]`, we say that `H` is a Hermitian
spectrum if, with `%` meaning modulus division,

    H[..., n0 % N0, n1 % N1, n2 % N2]
      = ComplexConjugate[ H[..., (-n0) % N0, (-n1) % N1, (-n2) % N2] ].

- This operator corresponds to a real matrix if and only if `H` is Hermitian.
- This operator is self-adjoint if and only if `H` is real.

See e.g. "Discrete-Time Signal Processing", Oppenheim and Schafer.

### Examples

See `LinearOperatorCirculant` and `LinearOperatorCirculant2D` for examples.

#### Performance

Suppose `operator` is a `LinearOperatorCirculant` of shape `[N, N]`,
and `x.shape = [N, R]`. Then

- `operator.matmul(x)` is `O(R*N*Log[N])`
- `operator.solve(x)` is `O(R*N*Log[N])`
- `operator.determinant()` involves a size `N` `reduce_prod`.

If instead `operator` and `x` have shape `[B1,...,Bb, N, N]` and
`[B1,...,Bb, N, R]`, every operation increases in complexity by `B1*...*Bb`.

#### Matrix property hints

This `LinearOperator` is initialized with boolean flags of the form `is_X`,
for `X = non_singular, self_adjoint, positive_definite, square`.
These have the following meaning

- If `is_X == True`, callers should expect the operator to have the property `X`. This is a promise that should be fulfilled, but is *not* a runtime assert. For example, finite floating point precision may result in these promises being violated.
- If `is_X == False`, callers should expect the operator to not have `X`.
- If `is_X == None` (the default), callers should have no expectation either way.

<br />

<br />

<br />

| ## Args ||
|---|---|
| `spectrum` | Shape `[B1,...,Bb, N0, N1, N2]` `Tensor`. Allowed dtypes: `float16`, `float32`, `float64`, `complex64`, `complex128`. Type can be different than `input_output_dtype` |
| `input_output_dtype` | `dtype` for input/output. |
| `is_non_singular` | Expect that this operator is non-singular. |
| `is_self_adjoint` | Expect that this operator is equal to its hermitian transpose. If `spectrum` is real, this will always be true. |
| `is_positive_definite` | Expect that this operator is positive definite, meaning the real part of all eigenvalues is positive. We do not require the operator to be self-adjoint to be positive-definite. See: https://en.wikipedia.org/wiki/Positive-definite_matrix #Extension_for_non_symmetric_matrices |
| `is_square` | Expect that this operator acts like square \[batch\] matrices. |
| `name` | A name to prepend to all ops created by this class. |

<br />

<br />

<br />

<br />

| ## Attributes ||
|---|---|
| `H` | Returns the adjoint of the current `LinearOperator`. <br /> Given `A` representing this `LinearOperator`, return `A*`. Note that calling `self.adjoint()` and `self.H` are equivalent. |
| `batch_shape` | `TensorShape` of batch dimensions of this `LinearOperator`. <br /> If this operator acts like the batch matrix `A` with `A.shape = [B1,...,Bb, M, N]`, then this returns `TensorShape([B1,...,Bb])`, equivalent to `A.shape[:-2]` |
| `block_depth` | Depth of recursively defined circulant blocks defining this `Operator`. <br /> With `A` the dense representation of this `Operator`, `block_depth = 1` means `A` is symmetric circulant. For example, A = |w z y x| |x w z y| |y x w z| |z y x w| `block_depth = 2` means `A` is block symmetric circulant with symmetric circulant blocks. For example, with `W`, `X`, `Y`, `Z` symmetric circulant, A = |W Z Y X| |X W Z Y| |Y X W Z| |Z Y X W| `block_depth = 3` means `A` is block symmetric circulant with block symmetric circulant blocks. |
| `block_shape` | <br /> <br /> |
| `domain_dimension` | Dimension (in the sense of vector spaces) of the domain of this operator. <br /> If this operator acts like the batch matrix `A` with `A.shape = [B1,...,Bb, M, N]`, then this returns `N`. |
| `dtype` | The `DType` of `Tensor`s handled by this `LinearOperator`. |
| `graph_parents` | List of graph dependencies of this `LinearOperator`. (deprecated) <br /> > [!WARNING] > **Deprecated:** THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Do not call `graph_parents`. |
| `is_non_singular` | <br /> |
| `is_positive_definite` | <br /> <br /> |
| `is_self_adjoint` | <br /> <br /> |
| `is_square` | Return `True/False` depending on if this operator is square. |
| `parameters` | Dictionary of parameters used to instantiate this `LinearOperator`. |
| `range_dimension` | Dimension (in the sense of vector spaces) of the range of this operator. <br /> If this operator acts like the batch matrix `A` with `A.shape = [B1,...,Bb, M, N]`, then this returns `M`. |
| `shape` | `TensorShape` of this `LinearOperator`. <br /> If this operator acts like the batch matrix `A` with `A.shape = [B1,...,Bb, M, N]`, then this returns `TensorShape([B1,...,Bb, M, N])`, equivalent to `A.shape`. |
| `spectrum` | <br /> <br /> |
| `tensor_rank` | Rank (in the sense of tensors) of matrix corresponding to this operator. <br /> If this operator acts like the batch matrix `A` with `A.shape = [B1,...,Bb, M, N]`, then this returns `b + 2`. |

<br />

## Methods

### `add_to_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1089-L1102)

    add_to_tensor(
        x, name='add_to_tensor'
    )

Add matrix represented by this operator to `x`. Equivalent to `A + x`.

<br />

<br />

<br />

| Args ||
|---|---|
| `x` | `Tensor` with same `dtype` and shape broadcastable to `self.shape`. |
| `name` | A name to give this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `Tensor` with broadcast shape and same `dtype` as `self`. ||

<br />

### `adjoint`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L945-L960)

    adjoint(
        name='adjoint'
    )

Returns the adjoint of the current `LinearOperator`.

Given `A` representing this `LinearOperator`, return `A*`.
Note that calling `self.adjoint()` and `self.H` are equivalent.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `LinearOperator` which represents the adjoint of this `LinearOperator`. ||

<br />

### `assert_hermitian_spectrum`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator_circulant.py#L464-L484)

    assert_hermitian_spectrum(
        name='assert_hermitian_spectrum'
    )

Returns an `Op` that asserts this operator has Hermitian spectrum.

This operator corresponds to a real-valued matrix if and only if its
spectrum is Hermitian.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name to give this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Op` that asserts this operator has Hermitian spectrum. ||

<br />

### `assert_non_singular`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L549-L567)

    assert_non_singular(
        name='assert_non_singular'
    )

Returns an `Op` that asserts this operator is non singular.

This operator is considered non-singular if

    ConditionNumber < max{100, range_dimension, domain_dimension} * eps,
    eps := np.finfo(self.dtype.as_numpy_dtype).eps

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A string name to prepend to created ops. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is singular. ||

<br />

### `assert_positive_definite`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L585-L600)

    assert_positive_definite(
        name='assert_positive_definite'
    )

Returns an `Op` that asserts this operator is positive definite.

Here, positive definite means that the quadratic form `x^H A x` has positive
real part for all nonzero `x`. Note that we do not require the operator to
be self-adjoint to be positive definite.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name to give this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not positive definite. ||

<br />

### `assert_self_adjoint`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L612-L626)

    assert_self_adjoint(
        name='assert_self_adjoint'
    )

Returns an `Op` that asserts this operator is self-adjoint.

Here we check that this operator is *exactly* equal to its hermitian
transpose.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A string name to prepend to created ops. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| An `Assert` `Op`, that, when run, will raise an `InvalidArgumentError` if the operator is not self-adjoint. ||

<br />

### `batch_shape_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L361-L376)

    batch_shape_tensor(
        name='batch_shape_tensor'
    )

Shape of batch dimensions of this operator, determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns a `Tensor` holding
`[B1,...,Bb]`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `block_shape_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator_circulant.py#L292-L296)

    block_shape_tensor()

Shape of the block dimensions of `self.spectrum`.

### `cholesky`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L990-L1013)

    cholesky(
        name='cholesky'
    )

Returns a Cholesky factor as a `LinearOperator`.

Given `A` representing this `LinearOperator`, if `A` is positive definite
self-adjoint, return `L`, where `A = L L^T`, i.e. the cholesky
decomposition.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `LinearOperator` which represents the lower triangular matrix in the Cholesky decomposition. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `ValueError` | When the `LinearOperator` is not hinted to be positive definite and self adjoint. |

<br />

### `cond`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1139-L1149)

    cond(
        name='cond'
    )

Returns the condition number of this linear operator.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. ||

<br />

### `convolution_kernel`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator_circulant.py#L419-L433)

    convolution_kernel(
        name='convolution_kernel'
    )

Convolution kernel corresponding to `self.spectrum`.

The `D` dimensional DFT of this kernel is the frequency domain spectrum of
this operator.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name to give this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with `dtype` `self.dtype`. ||

<br />

### `determinant`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L745-L762)

    determinant(
        name='det'
    )

Determinant for every batch member.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_square` is `False`. |

<br />

### `diag_part`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1040-L1066)

    diag_part(
        name='diag_part'
    )

Efficiently get the \[batch\] diagonal part of this operator.

If this operator has shape `[B1,...,Bb, M, N]`, this returns a
`Tensor` `diagonal`, of shape `[B1,...,Bb, min(M, N)]`, where
`diagonal[b1,...,bb, i] = self.to_dense()[b1,...,bb, i, i]`.

    my_operator = LinearOperatorDiag([1., 2.])

    # Efficiently get the diagonal
    my_operator.diag_part()
    ==> [1., 2.]

    # Equivalent, but inefficient method
    tf.linalg.diag_part(my_operator.to_dense())
    ==> [1., 2.]

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `diag_part` | A `Tensor` of same `dtype` as self. |

<br />

### `domain_dimension_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L448-L464)

    domain_dimension_tensor(
        name='domain_dimension_tensor'
    )

Dimension (in the sense of vector spaces) of the domain of this operator.

Determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `N`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `eigvals`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1107-L1124)

    eigvals(
        name='eigvals'
    )

Returns the eigenvalues of this linear operator.

If the operator is marked as self-adjoint (via `is_self_adjoint`)
this computation can be more efficient.

> [!NOTE]
> **Note:** This currently only supports self-adjoint operators.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb, N]` `Tensor` of same `dtype` as `self`. ||

<br />

### `inverse`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L965-L988)

    inverse(
        name='inverse'
    )

Returns the Inverse of this `LinearOperator`.

Given `A` representing this `LinearOperator`, return a `LinearOperator`
representing `A^-1`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `LinearOperator` representing inverse of this matrix. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `ValueError` | When the `LinearOperator` is not hinted to be `non_singular`. |

<br />

### `log_abs_determinant`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L774-L791)

    log_abs_determinant(
        name='log_abs_det'
    )

Log absolute value of determinant for every batch member.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `self.batch_shape` and same `dtype` as `self`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_square` is `False`. |

<br />

### `matmul`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L639-L692)

    matmul(
        x, adjoint=False, adjoint_arg=False, name='matmul'
    )

Transform \[batch\] matrix `x` with left multiplication: `x --> Ax`.

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    X = ... # shape [..., N, R], batch matrix, R > 0.

    Y = operator.matmul(X)
    Y.shape
    ==> [..., M, R]

    Y[..., :, r] = sum_j A[..., :, j] X[j, r]

<br />

<br />

<br />

| Args ||
|---|---|
| `x` | `LinearOperator` or `Tensor` with compatible shape and same `dtype` as `self`. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. |
| `adjoint_arg` | Python `bool`. If `True`, compute `A x^H` where `x^H` is the hermitian transpose (transposition and complex conjugation). |
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `LinearOperator` or `Tensor` with shape `[..., M, R]` and same `dtype` as `self`. ||

<br />

### `matvec`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L702-L735)

    matvec(
        x, adjoint=False, name='matvec'
    )

Transform \[batch\] vector `x` with left multiplication: `x --> Ax`.

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)

    X = ... # shape [..., N], batch vector

    Y = operator.matvec(X)
    Y.shape
    ==> [..., M]

    Y[..., :] = sum_j A[..., :, j] X[..., j]

<br />

<br />

<br />

| Args ||
|---|---|
| `x` | `Tensor` with compatible shape and same `dtype` as `self`. `x` is treated as a \[batch\] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, left multiply by the adjoint: `A^H x`. |
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| A `Tensor` with shape `[..., M]` and same `dtype` as `self`. ||

<br />

### `range_dimension_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L492-L508)

    range_dimension_tensor(
        name='range_dimension_tensor'
    )

Dimension (in the sense of vector spaces) of the range of this operator.

Determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `M`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `shape_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L327-L345)

    shape_tensor(
        name='shape_tensor'
    )

Shape of this `LinearOperator`, determined at runtime.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns a `Tensor` holding
`[B1,...,Bb, M, N]`, equivalent to [`tf.shape(A)`](https://www.tensorflow.org/versions/r2.13/api_docs/python/tf/shape).

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor` ||

<br />

### `solve`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L812-L887)

    solve(
        rhs, adjoint=False, adjoint_arg=False, name='solve'
    )

Solve (exact or approx) `R` (batch) systems of equations: `A X = rhs`.

The returned `Tensor` will be close to an exact solution if `A` is well
conditioned. Otherwise closeness will vary. See class docstring for details.

#### Examples:

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    # Solve R > 0 linear systems for every member of the batch.
    RHS = ... # shape [..., M, R]

    X = operator.solve(RHS)
    # X[..., :, r] is the solution to the r'th linear system
    # sum_j A[..., :, j] X[..., j, r] = RHS[..., :, r]

    operator.matmul(X)
    ==> RHS

<br />

<br />

<br />

| Args ||
|---|---|
| `rhs` | `Tensor` with same `dtype` as this operator and compatible shape. `rhs` is treated like a \[batch\] matrix meaning for every set of leading dimensions, the last two dimensions defines a matrix. See class docstring for definition of compatibility. |
| `adjoint` | Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. |
| `adjoint_arg` | Python `bool`. If `True`, solve `A X = rhs^H` where `rhs^H` is the hermitian transpose (transposition and complex conjugation). |
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `[...,N, R]` and same `dtype` as `rhs`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_non_singular` or `is_square` is False. |

<br />

### `solvevec`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L895-L943)

    solvevec(
        rhs, adjoint=False, name='solve'
    )

Solve single equation with best effort: `A X = rhs`.

The returned `Tensor` will be close to an exact solution if `A` is well
conditioned. Otherwise closeness will vary. See class docstring for details.

#### Examples:

    # Make an operator acting like batch matrix A.  Assume A.shape = [..., M, N]
    operator = LinearOperator(...)
    operator.shape = [..., M, N]

    # Solve one linear system for every member of the batch.
    RHS = ... # shape [..., M]

    X = operator.solvevec(RHS)
    # X is the solution to the linear system
    # sum_j A[..., :, j] X[..., j] = RHS[..., :]

    operator.matvec(X)
    ==> RHS

<br />

<br />

<br />

| Args ||
|---|---|
| `rhs` | `Tensor` with same `dtype` as this operator. `rhs` is treated like a \[batch\] vector meaning for every set of leading dimensions, the last dimension defines a vector. See class docstring for definition of compatibility regarding batch dimensions. |
| `adjoint` | Python `bool`. If `True`, solve the system involving the adjoint of this `LinearOperator`: `A^H X = rhs`. |
| `name` | A name scope to use for ops added by this method. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `Tensor` with shape `[...,N]` and same `dtype` as `rhs`. ||

<br />

<br />

<br />

<br />

| Raises ||
|---|---|
| `NotImplementedError` | If `self.is_non_singular` or `is_square` is False. |

<br />

### `tensor_rank_tensor`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L405-L419)

    tensor_rank_tensor(
        name='tensor_rank_tensor'
    )

Rank (in the sense of tensors) of matrix corresponding to this operator.

If this operator acts like the batch matrix `A` with
`A.shape = [B1,...,Bb, M, N]`, then this returns `b + 2`.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| `int32` `Tensor`, determined at runtime. ||

<br />

### `to_dense`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1031-L1034)

    to_dense(
        name='to_dense'
    )

Return a dense (batch) matrix representing this operator.

### `trace`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1071-L1083)

    trace(
        name='trace'
    )

Trace of the linear operator, equal to sum of `self.diag_part()`.

If the operator is square, this is also the sum of the eigenvalues.

<br />

<br />

<br />

| Args ||
|---|---|
| `name` | A name for this `Op`. |

<br />

<br />

<br />

<br />

| Returns ||
|---|---|
| Shape `[B1,...,Bb]` `Tensor` of same `dtype` as `self`. ||

<br />

### `__getitem__`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L1226-L1227)

    __getitem__(
        slices
    )

### `__matmul__`

[View source](https://github.com/tensorflow/tensorflow/blob/v2.13.1/tensorflow/python/ops/linalg/linear_operator.py#L694-L695)

    __matmul__(
        other
    )