elementary_vectors.functions¶

Computing elementary vectors

Functions

`elementary_vectors`(M[, kernel, generator])	Compute elementary vectors of a subspace determined by a matrix or a list of maximal minors.
`kernel_matrix_using_elementary_vectors`(M)	Division-free computation of the right kernel based on elementary vectors.

Classes

ElementaryVectors(M)

A class used to compute elementary vectors.

class elementary_vectors.functions.ElementaryVectors(M)¶

A class used to compute elementary vectors.

Whenever a maximal minor is computed, it is stored in a dictionary for efficient reuse. Supports elementary vectors in the kernel and row space.

EXAMPLES:

sage: from elementary_vectors.functions import ElementaryVectors
sage: M = matrix([[1, 2, 4, 1, -1], [0, 1, 2, 3, 4]])
sage: evs = ElementaryVectors(M)
sage: evs.elements()
[(0, -2, 1, 0, 0),
 (5, -3, 0, 1, 0),
 (9, -4, 0, 0, 1),
 (10, 0, -3, 2, 0),
 (18, 0, -4, 0, 2),
 (7, 0, 0, -4, 3),
 (0, 7, 0, -9, 5),
 (0, 0, 7, -18, 10)]
sage: evs.elements(prevent_multiples=False)
[(0, -2, 1, 0, 0),
 (5, -3, 0, 1, 0),
 (9, -4, 0, 0, 1),
 (10, 0, -3, 2, 0),
 (18, 0, -4, 0, 2),
 (7, 0, 0, -4, 3),
 (0, 10, -5, 0, 0),
 (0, 18, -9, 0, 0),
 (0, 7, 0, -9, 5),
 (0, 0, 7, -18, 10)]
sage: evs.elements(kernel=False)
[(0, -1, -2, -3, -4), (1, 0, 0, -5, -9), (3, 5, 10, 0, -7), (4, 9, 18, 7, 0)]
sage: evs.elements(kernel=False, prevent_multiples=False)
[(0, -1, -2, -3, -4),
 (1, 0, 0, -5, -9),
 (2, 0, 0, -10, -18),
 (3, 5, 10, 0, -7),
 (4, 9, 18, 7, 0)]

sage: evs = ElementaryVectors(M)
sage: evs.minor([0, 2])
2
sage: evs.element([0, 2, 3])
(10, 0, -3, 2, 0)
sage: evs.element([0])
(0, -1, -2, -3, -4)
sage: evs.element_kernel([0, 2, 3])
(10, 0, -3, 2, 0)
sage: evs.element_row_space([0])
(0, -1, -2, -3, -4)
sage: evs.random_element() # random
(0, 0, 7, -18, 10)
sage: evs.random_element(kernel=False) # random
(3, 5, 10, 0, -7)

element(indices: list, kernel: Optional[bool] = None, prevent_multiple: bool = False)¶: Compute the elementary vector corresponding to a list of indices.

Note

Raises a ValueError if the indices correspond to the zero vector.

element_kernel(indices: list, prevent_multiple: bool = False)¶: Compute the elementary vector corresponding to a list of indices.

Note

Raises a ValueError if the indices correspond to the zero vector.

element_row_space(indices: list, prevent_multiple: bool = False)¶

Compute the elementary vector in the row space corresponding to the given indices.

INPUT:

- ``indices`` -- a list of ``rank - 1``elements

elements(kernel: bool = True, prevent_multiples: bool = True) → list¶: Return a list of elementary vectors

elements_with_smaller_support(kernel: bool = True) → collections.abc.Generator¶

Generator of elementary vectors with smaller than usual support.

EXAMPLES:

sage: from elementary_vectors import *
sage: M = matrix([[1, 0, 1, 0], [0, 0, 1, 1]])
sage: evs = ElementaryVectors(M)
sage: list(evs.elements_with_smaller_support())
[(0, -1, 0, 0)]
sage: list(evs.elements_with_smaller_support(kernel=False))
[(0, 0, -1, -1), (1, 0, 0, -1), (1, 0, 1, 0)]

sage: M = matrix([[1, 1, 1, 0], [0, 1, 1, 1]])
sage: evs = ElementaryVectors(M)
sage: list(evs.elements_with_smaller_support())
[(0, -1, 1, 0)]
sage: list(evs.elements_with_smaller_support(kernel=False))
[(1, 0, 0, -1)]

generator(kernel: bool = True, prevent_multiples: bool = True, reverse: bool = False) → collections.abc.Generator¶: Return a generator of elementary vectors

index_sets_from_minor(indices: list, kernel: bool = True) → collections.abc.Generator[list]¶: Generator of index sets corresponding to elementary vectors involving given minor.

minor(indices)¶

Compute a minor given by indices

The minor is cached for efficient reuse.

TESTS:

sage: from elementary_vectors.functions import ElementaryVectors
sage: M = matrix([[1, 2, 4, 1, -1], [0, 1, 2, 3, 4]])
sage: evs = ElementaryVectors(M)
sage: evs.minors
{}
sage: evs.minor([0, 1])
1
sage: evs.minors
{(0, 1): 1}
sage: evs.minor([2, 4])
18
sage: evs.minors
{(0, 1): 1, (2, 4): 18}

random_element(kernel: bool = True)¶: Return a random elementary vector

Note

If no elementary vector exists or the zero vector has been generated, None is returned.

set_combinations(combinations=None) → None¶: Set or reset combinations.

set_combinations_dual(combinations=None) → None¶: Set or reset combinations.

elementary_vectors.functions.elementary_vectors(M, kernel: bool = True, generator: bool = False)¶

Compute elementary vectors of a subspace determined by a matrix or a list of maximal minors.

INPUT:

M – a matrix
kernel – a boolean (default: True)
generator – a boolean (default: False)

OUTPUT: Return a list of elementary vectors in the kernel of a matrix given by the matrix M. To compute the elementary vectors in the row space, pass false for kernel.

If generator is true, the output will be a generator object instead of a list.

EXAMPLES:

sage: from elementary_vectors import *
sage: M = matrix([[1, 2, 0, 0], [0, 1, 2, 3]])
sage: M
[1 2 0 0]
[0 1 2 3]
sage: elementary_vectors(M)
[(4, -2, 1, 0), (6, -3, 0, 1), (0, 0, -3, 2)]

By default, the elementary vectors in the kernel are computed. To consider the row space, pass kernel=False:

sage: elementary_vectors(M, kernel=False)
[(0, -1, -2, -3), (1, 0, -4, -6), (2, 4, 0, 0)]

We can also compute elementary vectors over a finite field:

sage: B = matrix(GF(7), [[1, 2, 3, 4, 0], [0, 5, 2, 3, 3]])
sage: B
[1 2 3 4 0]
[0 5 2 3 3]
sage: elementary_vectors(B)
[(3, 5, 5, 0, 0),
 (0, 4, 0, 5, 0),
 (6, 4, 0, 0, 5),
 (1, 0, 4, 2, 0),
 (2, 0, 4, 0, 2),
 (5, 0, 0, 4, 3),
 (0, 2, 1, 0, 3),
 (0, 0, 5, 5, 1)]

Variables are also supported:

sage: var('a, b')
(a, b)
sage: M = matrix([[1, 2, a, 0], [0, 1, 2, b]])
sage: M
[1 2 a 0]
[0 1 2 b]
sage: elementary_vectors(M)
[(-a + 4, -2, 1, 0), (2*b, -b, 0, 1), (a*b, 0, -b, 2), (0, a*b, -2*b, -a + 4)]

TESTS:

sage: elementary_vectors(random_matrix(QQ, 0, 4))
[(1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)]
sage: elementary_vectors(matrix([[1, 0, 0], [0, 0, 0]]))
[(0, -1, 0), (0, 0, -1)]

elementary_vectors.functions.kernel_matrix_using_elementary_vectors(M)¶

Division-free computation of the right kernel based on elementary vectors.

INPUT:

M – a matrix

OUTPUT: A right kernel matrix of M. Also works for symbolic matrices.

Note

A ValueError is returned if M has no constant nonzero maximal minor.

EXAMPLES:

sage: from elementary_vectors import *
sage: M = matrix([[1, 0, 1, -1, 0], [0, 1, 1, 1, -1]])
sage: M
[ 1  0  1 -1  0]
[ 0  1  1  1 -1]
sage: kernel_matrix_using_elementary_vectors(M)
[1 0 0 1 1]
[0 1 0 0 1]
[0 0 1 1 2]
sage: M = matrix([[1, 1, -1, -1, 0], [2, 1, -1, 0, 1], [1, 1, 1, 1, 1]])
sage: M
[ 1  1 -1 -1  0]
[ 2  1 -1  0  1]
[ 1  1  1  1  1]
sage: kernel_matrix_using_elementary_vectors(M)
[-1  0  0 -1  2]
[ 0 -1  1 -2  2]
sage: var('a')
a
sage: M = matrix([[1, 0, 1, -1, 0], [0, 1, a, 1, -1]])
sage: M
[ 1  0  1 -1  0]
[ 0  1  a  1 -1]
sage: kernel_matrix_using_elementary_vectors(M)
[    1     0     0     1     1]
[    0     1     0     0     1]
[    0     0     1     1 a + 1]

TESTS:

sage: kernel_matrix_using_elementary_vectors(identity_matrix(3, 3))
[]
sage: _.dimensions()
(0, 3)
sage: kernel_matrix_using_elementary_vectors(matrix(0, 3))
[1 0 0]
[0 1 0]
[0 0 1]

elementary_vectors.functions¶

Previous topic

Next topic

This Page