tf.linalg.LinearOperatorBlockLowerTriangular

Combines LinearOperators into a blockwise lower-triangular matrix.

Inherits From: LinearOperator

View aliases

Compat aliases for migration

tf.compat.v1.linalg.LinearOperatorBlockLowerTriangular

tf.linalg.LinearOperatorBlockLowerTriangular(
    operators, is_non_singular=None, is_self_adjoint=None,
    is_positive_definite=None, is_square=None,
    name='LinearOperatorBlockLowerTriangular'
)

This operator is initialized with a nested list of linear operators, which are combined into a new LinearOperator whose underlying matrix representation is square and has each operator on or below the main diagonal, and zero's elsewhere. Each element of the outer list is a list of LinearOperators corresponding to a row-partition of the blockwise structure. The number of LinearOperators in row-partion i must be equal to i.

For example, a blockwise 3 x 3 LinearOperatorBlockLowerTriangular is initialized with the list [[op_00], [op_10, op_11], [op_20, op_21, op_22]], where the op_ij, i < 3, j <= i, are LinearOperator instances. The LinearOperatorBlockLowerTriangular behaves as the following blockwise matrix, where 0 represents appropriately-sized [batch] matrices of zeros:

[[op_00,     0,     0],
 [op_10, op_11,     0],
 [op_20, op_21, op_22]]

Each op_jj on the diagonal is required to represent a square matrix, and hence will have shape batch_shape_j + [M_j, M_j]. LinearOperators in row j of the blockwise structure must have range_dimension equal to that of op_jj, and LinearOperators in column j must have domain_dimension equal to that of op_jj.

If each op_jj on the diagonal has shape batch_shape_j + [M_j, M_j], then the combined operator has shape broadcast_batch_shape + [sum M_j, sum M_j], where broadcast_batch_shape is the mutual broadcast of batch_shape_j, j = 0, 1, ..., J, assuming the intermediate batch shapes broadcast. Even if the combined shape is well defined, the combined operator's methods may fail due to lack of broadcasting ability in the defining operators' methods.

For example, to create a 4 x 4 linear operator combined of three 2 x 2 operators:

operator_0 = tf.linalg.LinearOperatorFullMatrix([[1., 2.], [3., 4.]]) operator_1 = tf.linalg.LinearOperatorFullMatrix([[1., 0.], [0., 1.]]) operator_2 = tf.linalg.LinearOperatorLowerTriangular([[5., 6.], [7., 8]]) operator = LinearOperatorBlockLowerTriangular( ... [[operator_0], [operator_1, operator_2]])

operator.to_dense()
<tf.Tensor: shape=(4, 4), dtype=float32, numpy=
array([[1., 2., 0., 0.],
       [3., 4., 0., 0.],
       [1., 0., 5., 0.],
       [0., 1., 7., 8.]], dtype=float32)>

operator.shape
TensorShape([4, 4])

operator.log_abs_determinant()
<tf.Tensor: shape=(), dtype=float32, numpy=4.3820267>

x0 = [[1., 6.], [-3., 4.]]
x1 = [[0., 2.], [4., 0.]]
x = tf.concat([x0, x1], 0)  # Shape [2, 4] Tensor
operator.matmul(x)
<tf.Tensor: shape=(4, 2), dtype=float32, numpy=
array([[-5., 14.],
       [-9., 34.],
       [ 1., 16.],
       [29., 18.]], dtype=float32)>

The above matmul is equivalent to:

tf.concat([operator_0.matmul(x0), ... operator_1.matmul(x0) + operator_2.matmul(x1)], axis=0)

Shape compatibility

This operator acts on [batch] matrix with compatible shape. x is a batch matrix with compatible shape for matmul and solve if

operator.shape = [B1,...,Bb] + [M, N],  with b >= 0
x.shape =        [B1,...,Bb] + [N, R],  with R >= 0.

For example:

Create a [2, 3] batch of 4 x 4 linear operators:

matrix_44 = tf.random.normal(shape=[2, 3, 4, 4]) operator_44 = tf.linalg.LinearOperatorFullMatrix(matrix_44)

Create a [1, 3] batch of 5 x 4 linear operators:

matrix_54 = tf.random.normal(shape=[1, 3, 5, 4]) operator_54 = tf.linalg.LinearOperatorFullMatrix(matrix_54)

Create a [1, 3] batch of 5 x 5 linear operators:

matrix_55 = tf.random.normal(shape=[1, 3, 5, 5]) operator_55 = tf.linalg.LinearOperatorFullMatrix(matrix_55)

Combine to create a [2, 3] batch of 9 x 9 operators:

operator_99 = LinearOperatorBlockLowerTriangular( ... [[operator_44], [operator_54, operator_55]]) operator_99.shape TensorShape([2, 3, 9, 9])

Create a shape [2, 1, 9] batch of vectors and apply the operator to it.

x = tf.random.normal(shape=[2, 1, 9]) y = operator_99.matvec(x) y.shape TensorShape([2, 3, 9])

Performance

Suppose operator is a LinearOperatorBlockLowerTriangular consisting of D row-partitions and D column-partitions, such that the total number of operators is N = D * (D + 1) // 2.

operator.matmul has complexity equal to the sum of the matmul complexities of the individual operators.
operator.solve has complexity equal to the sum of the solve complexities of the operators on the diagonal and the matmul complexities of the operators off the diagonal.
operator.determinant has complexity equal to the sum of the determinant complexities of the operators on the diagonal.

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.

Args
`operators`	Iterable of iterables of `LinearOperator` objects, each with the same `dtype`. Each element of `operators` corresponds to a row- partition, in top-to-bottom order. The operators in each row-partition are filled in left-to-right. For example, `operators = [[op_0], [op_1, op_2], [op_3, op_4, op_5]]` creates a `LinearOperatorBlockLowerTriangular` with full block structure `[[op_0, 0, 0], [op_1, op_2, 0], [op_3, op_4, op_5]]`. The number of operators in the `i`th row must be equal to `i`, such that each operator falls on or below the diagonal of the blockwise structure. `LinearOperator`s that fall on the diagonal (the last elements of each row) must be square. The other `LinearOperator`s must have domain dimension equal to the domain dimension of the `LinearOperator`s in the same column-partition, and range dimension equal to the range dimension of the `LinearOperator`s in the same row-partition.
`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. This will raise a `ValueError` if set to `False`.
`name`	A name for this `LinearOperator`.

Raises
`TypeError`	If all operators do not have the same `dtype`.
`ValueError`	If `operators` is empty, contains an erroneous number of elements, or contains operators with incompatible shapes.

Attributes
`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) Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version. Instructions for updating: Do not call `graph_parents`.
`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`.

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

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

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

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.

tf.linalg.LinearOperatorBlockLowerTriangular

View aliases

Shape compatibility

For example:

Performance

Matrix property hints

Args

Raises

Attributes

Methods

add_to_tensor

adjoint

assert_non_singular

assert_positive_definite

assert_self_adjoint

batch_shape_tensor

cholesky

cond

determinant

diag_part

domain_dimension_tensor

eigvals

inverse

log_abs_determinant

matmul

matvec

range_dimension_tensor

shape_tensor

solve

Examples:

solvevec

Examples:

tensor_rank_tensor

to_dense

trace

__matmul__

`add_to_tensor`

`adjoint`

`assert_non_singular`

`assert_positive_definite`

`assert_self_adjoint`

`batch_shape_tensor`

`cholesky`

`cond`

`determinant`

`diag_part`

`domain_dimension_tensor`

`eigvals`

`inverse`

`log_abs_determinant`

`matmul`

`matvec`

`range_dimension_tensor`

`shape_tensor`

`solve`

`solvevec`

`tensor_rank_tensor`

`to_dense`

`trace`

`matmul`