Save the date! Google I/O returns May 18-20

# tf.linalg.LinearOperatorKronecker

Kronecker product between two `LinearOperators`.

Inherits From: `LinearOperator`

This operator composes one or more linear operators `[op1,...,opJ]`, building a new `LinearOperator` representing the Kronecker product: `op1 x op2 x .. opJ` (we omit parentheses as the Kronecker product is associative).

If `opj` has shape `batch_shape_j + [M_j, N_j]`, then the composed operator will have shape equal to `broadcast_batch_shape + [prod M_j, prod N_j]`, where the product is over all operators.

``````# Create a 4 x 4 linear operator composed of two 2 x 2 operators.
operator_1 = LinearOperatorFullMatrix([[1., 2.], [3., 4.]])
operator_2 = LinearOperatorFullMatrix([[1., 0.], [2., 1.]])
operator = LinearOperatorKronecker([operator_1, operator_2])

operator.to_dense()
==> [[1., 0., 2., 0.],
[2., 1., 4., 2.],
[3., 0., 4., 0.],
[6., 3., 8., 4.]]

operator.shape
==> [4, 4]

operator.log_abs_determinant()
==> scalar Tensor

x = ... Shape [4, 2] Tensor
operator.matmul(x)
==> Shape [4, 2] Tensor

# Create a [2, 3] batch of 4 x 5 linear operators.
matrix_45 = tf.random.normal(shape=[2, 3, 4, 5])
operator_45 = LinearOperatorFullMatrix(matrix)

# Create a [2, 3] batch of 5 x 6 linear operators.
matrix_56 = tf.random.normal(shape=[2, 3, 5, 6])
operator_56 = LinearOperatorFullMatrix(matrix_56)

# Compose to create a [2, 3] batch of 20 x 30 operators.
operator_large = LinearOperatorKronecker([operator_45, operator_56])

# Create a shape [2, 3, 20, 2] vector.
x = tf.random.normal(shape=[2, 3, 6, 2])
operator_large.matmul(x)
==> Shape [2, 3, 30, 2] Tensor
``````

#### Performance

The performance of `LinearOperatorKronecker` on any operation is equal to the sum of the individual operators' operations.

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

`operators` Iterable of `LinearOperator` objects, each with the same `dtype` and composable shape, representing the Kronecker factors.
`is_non_singular` Expect that this operator is non-singular.
`is_self_adjoint` Expect that this operator is equal to its hermitian transpose.
`is_positive_definite` Expect that this operator is positive definite, meaning 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. 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 for this `LinearOperator`. Default is the individual operators names joined with `_x_`.

`TypeError` If all operators do not have the same `dtype`.
`ValueError` If `operators` is empty.

`H` Returns the adjoint of the current `LinearOperator`.

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

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]`

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

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)

`is_non_singular`

`is_positive_definite`

`is_self_adjoint`

`is_square` Return `True/False` depending on if this operator is square.
`operators`

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

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

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

`tensor_rank` 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`.

## Methods

### `add_to_tensor`

View source

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

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

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

### `adjoint`

View source

Returns the adjoint of the current `LinearOperator`.

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

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

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

### `assert_non_singular`

View source

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
``````

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

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

### `assert_positive_definite`

View source

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.

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

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

### `assert_self_adjoint`

View source

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

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

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

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

### `batch_shape_tensor`

View source

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]`.

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

Returns
`int32` `Tensor`

### `cholesky`

View source

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.

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

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

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

### `cond`

View source

Returns the condition number of this linear oper