Coverage for local/lib/python2.7/site-packages/sage/combinat/free

2*B[1] # B[3] # B[5] + 2*B[1] # B[3] # B[6] + B[1] # B[4] # B[5] + B[1] # B[4] # B[6] + 4*B[2] # B[3] # B[5] + 4*B[2] # B[3] # B[6] + 2*B[2] # B[4] # B[5] + 2*B[2] # B[4] # B[6]

sage: phi_fg_h = FGH.tensor_constructor((FG, H))

sage: phi_fg_h(phi_fg(f, g), h)

2*B[1] # B[3] # B[5] + 2*B[1] # B[3] # B[6] + B[1] # B[4] # B[5] + B[1] # B[4] # B[6] + 4*B[2] # B[3] # B[5] + 4*B[2] # B[3] # B[6] + 2*B[2] # B[4] # B[5] + 2*B[2] # B[4] # B[6]

"""

assert(module in ModulesWithBasis(self.base_ring()) for module in modules)

assert(tensor(modules) == self)

# a list l such that l[i] is True if modules[i] is readily a tensor product

is_tensor = [isinstance(module, CombinatorialFreeModule_Tensor) for module in modules]

# the tensor_constructor, on basis elements

result = self.monomial * CartesianProductWithFlattening(is_tensor) #.

# TODO: make this into an element of Hom( A x B, C ) when those will exist

for i in range(0, len(modules)):

result = modules[i]._module_morphism(result, position = i, codomain = self)

return result

def _tensor_of_elements(self, elements):

"""

Returns the tensor product of the specified elements.

The result should be in ``self``.

EXAMPLES::

sage: F = CombinatorialFreeModule(ZZ, [1,2]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [3,4]); G.__custom_name = "G"

sage: H = CombinatorialFreeModule(ZZ, [5,6]); H.rename("H")

sage: f = F.monomial(1) + 2 * F.monomial(2)

sage: g = 2*G.monomial(3) + G.monomial(4)

sage: h = H.monomial(5) + H.monomial(6)

sage: GH = tensor([G, H])

sage: gh = GH._tensor_of_elements([g, h]); gh

2*B[3] # B[5] + 2*B[3] # B[6] + B[4] # B[5] + B[4] # B[6]

sage: FGH = tensor([F, G, H])

sage: FGH._tensor_of_elements([f, g, h])

2*B[1] # B[3] # B[5] + 2*B[1] # B[3] # B[6] + B[1] # B[4] # B[5] + B[1] # B[4] # B[6] + 4*B[2] # B[3] # B[5] + 4*B[2] # B[3] # B[6] + 2*B[2] # B[4] # B[5] + 2*B[2] # B[4] # B[6]

sage: FGH._tensor_of_elements([f, gh])

2*B[1] # B[3] # B[5] + 2*B[1] # B[3] # B[6] + B[1] # B[4] # B[5] + B[1] # B[4] # B[6] + 4*B[2] # B[3] # B[5] + 4*B[2] # B[3] # B[6] + 2*B[2] # B[4] # B[5] + 2*B[2] # B[4] # B[6]

"""

return self.tensor_constructor(tuple(element.parent() for element in elements))(*elements)

def _coerce_map_from_(self, R):

"""

Return ``True`` if there is a coercion from ``R`` into ``self`` and

``False`` otherwise. The things that coerce into ``self`` are:

- Anything with a coercion into ``self.base_ring()``.

- A tensor algebra whose factors have a coercion into the

corresponding factors of ``self``.

TESTS::

sage: C = CombinatorialFreeModule(ZZ, ZZ)

sage: C2 = CombinatorialFreeModule(ZZ, NN)

sage: M = C.module_morphism(lambda x: C2.monomial(abs(x)), codomain=C2)

sage: M.register_as_coercion()

sage: C2(C.basis()[3])

B[3]

sage: C2(C.basis()[3] + C.basis()[-3])

2*B[3]

sage: S = C.tensor(C)

sage: S2 = C2.tensor(C2)

sage: S2.has_coerce_map_from(S)

True

sage: S.has_coerce_map_from(S2)

False

sage: S.an_element()

3*B[0] # B[-1] + 2*B[0] # B[0] + 2*B[0] # B[1]

sage: S2(S.an_element())

2*B[0] # B[0] + 5*B[0] # B[1]

sage: C = CombinatorialFreeModule(ZZ, Set([1,2]))

sage: D = CombinatorialFreeModule(ZZ, Set([2,4]))

sage: f = C.module_morphism(on_basis=lambda x: D.monomial(2*x), codomain=D)

sage: f.register_as_coercion()

sage: T = tensor((C,C))

sage: p = D.an_element()

sage: T(tensor((p,p)))

Traceback (most recent call last):

...

NotImplementedError

sage: T = tensor((D,D))

sage: p = C.an_element()

sage: T(tensor((p,p)))

4*B[2] # B[2] + 4*B[2] # B[4] + 4*B[4] # B[2] + 4*B[4] # B[4]

"""

if R in ModulesWithBasis(self.base_ring()).TensorProducts() \

and isinstance(R, CombinatorialFreeModule_Tensor) \

and len(R._sets) == len(self._sets) \

and all(self._sets[i].has_coerce_map_from(M)

for i,M in enumerate(R._sets)):

modules = R._sets

vector_map = [self._sets[i]._internal_coerce_map_from(M)

for i,M in enumerate(modules)]

return R.module_morphism(lambda x: self._tensor_of_elements(

[vector_map[i](M.monomial(x[i]))

for i,M in enumerate(modules)]),

codomain=self)

return super(CombinatorialFreeModule_Tensor, self)._coerce_map_from_(R)

class CartesianProductWithFlattening(object):

"""

A class for Cartesian product constructor, with partial flattening

"""

def __init__(self, flatten):

"""

INPUT:

- ``flatten`` -- a tuple of booleans

This constructs a callable which accepts ``len(flatten)``

arguments, and builds a tuple out them. When ``flatten[i]``,

the i-th argument itself should be a tuple which is flattened

in the result.

sage: from sage.combinat.free_module import CartesianProductWithFlattening

sage: CartesianProductWithFlattening([True, False, True, True])

<sage.combinat.free_module.CartesianProductWithFlattening object at ...>

"""

self._flatten = flatten

def __call__(self, *indices):

"""

EXAMPLES::

sage: from sage.combinat.free_module import CartesianProductWithFlattening

sage: cp = CartesianProductWithFlattening([True, False, True, True])

sage: cp((1,2), (3,4), (5,6), (7,8))

(1, 2, (3, 4), 5, 6, 7, 8)

sage: cp((1,2,3), 4, (5,6), (7,8))

(1, 2, 3, 4, 5, 6, 7, 8)

"""

return sum( (i if flatten else (i,) for (i,flatten) in zip(indices, self._flatten) ), ())

# TODO: find a way to avoid this hack to allow for cross references

CombinatorialFreeModule.Tensor = CombinatorialFreeModule_Tensor

class CombinatorialFreeModule_CartesianProduct(CombinatorialFreeModule):

"""

An implementation of Cartesian products of modules with basis

EXAMPLES:

We construct two free modules, assign them short names, and construct their Cartesian product::

sage: F = CombinatorialFreeModule(ZZ, [4,5]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [4,6]); G.__custom_name = "G"

sage: H = CombinatorialFreeModule(ZZ, [4,7]); H.__custom_name = "H"

sage: S = cartesian_product([F, G])

sage: S

F (+) G

sage: S.basis()

Lazy family (Term map from Disjoint union of Family ({4, 5}, {4, 6}) to F (+) G(i))_{i in Disjoint union of Family ({4, 5}, {4, 6})}

Note that the indices of the basis elements of F and G intersect non

trivially. This is handled by forcing the union to be disjoint::

sage: list(S.basis())

[B[(0, 4)], B[(0, 5)], B[(1, 4)], B[(1, 6)]]

We now compute the Cartesian product of elements of free modules::

sage: f = F.monomial(4) + 2 * F.monomial(5)

sage: g = 2*G.monomial(4) + G.monomial(6)

sage: h = H.monomial(4) + H.monomial(7)

sage: cartesian_product([f,g])

B[(0, 4)] + 2*B[(0, 5)] + 2*B[(1, 4)] + B[(1, 6)]

sage: cartesian_product([f,g,h])

B[(0, 4)] + 2*B[(0, 5)] + 2*B[(1, 4)] + B[(1, 6)] + B[(2, 4)] + B[(2, 7)]

sage: cartesian_product([f,g,h]).parent()

F (+) G (+) H

TODO: choose an appropriate semantic for Cartesian products of Cartesian products (associativity?)::

sage: S = cartesian_product([cartesian_product([F, G]), H]) # todo: not implemented

F (+) G (+) H

"""

def __init__(self, modules, **options):

r"""

TESTS::

sage: F = CombinatorialFreeModule(ZZ, [2,4,5])

sage: G = CombinatorialFreeModule(ZZ, [2,4,7])

sage: C = cartesian_product([F, G]) ; C

Free module generated by {2, 4, 5} over Integer Ring (+) Free module generated by {2, 4, 7} over Integer Ring

sage: TestSuite(C).run()

"""

assert(len(modules) > 0) # TODO: generalize to a family or tuple

R = modules[0].base_ring()

assert(all(module in ModulesWithBasis(R)) for module in modules)

# should check the base ring

self._sets = modules

CombinatorialFreeModule.__init__(self, R,

DisjointUnionEnumeratedSets(

[module.basis().keys() for module in modules], keepkey=True),

**options)

def _sets_keys(self):

"""

In waiting for self._sets.keys()

TESTS::

sage: F = CombinatorialFreeModule(ZZ, [2,4,5])

sage: G = CombinatorialFreeModule(ZZ, [2,4,7])

sage: CP = cartesian_product([F, G])

sage: CP._sets_keys()

[0, 1]

"""

return list(range(len(self._sets)))

def _repr_(self):

"""

TESTS::

sage: F = CombinatorialFreeModule(ZZ, [2,4,5])

sage: CP = cartesian_product([F, F]); CP # indirect doctest

Free module generated by {2, 4, 5} over Integer Ring (+) Free module generated by {2, 4, 5} over Integer Ring

sage: F.__custom_name = "F"; CP

F (+) F

"""

from sage.categories.cartesian_product import cartesian_product

return cartesian_product.symbol.join(["%s"%module for module in self._sets])

# TODO: make this overridable by setting _name

@cached_method

def cartesian_embedding(self, i):

"""

Return the natural embedding morphism of the ``i``-th

Cartesian factor (summand) of ``self`` into ``self``.

INPUT:

- ``i`` -- an integer

EXAMPLES::

sage: F = CombinatorialFreeModule(ZZ, [4,5]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [4,6]); G.__custom_name = "G"

sage: S = cartesian_product([F, G])

sage: phi = S.cartesian_embedding(0)

sage: phi(F.monomial(4) + 2 * F.monomial(5))

B[(0, 4)] + 2*B[(0, 5)]

sage: phi(F.monomial(4) + 2 * F.monomial(6)).parent() == S

True

TESTS::

sage: phi(G.monomial(4))

Traceback (most recent call last):

...

AssertionError

"""

assert i in self._sets_keys()

return self._sets[i]._module_morphism(lambda t: self.monomial((i, t)),

codomain = self)

summand_embedding = cartesian_embedding

@cached_method

def cartesian_projection(self, i):

"""

Return the natural projection onto the `i`-th Cartesian factor

(summand) of ``self``.

INPUT:

- ``i`` -- an integer

EXAMPLES::

sage: F = CombinatorialFreeModule(ZZ, [4,5]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [4,6]); G.__custom_name = "G"

sage: S = cartesian_product([F, G])

sage: x = S.monomial((0,4)) + 2 * S.monomial((0,5)) + 3 * S.monomial((1,6))

sage: S.cartesian_projection(0)(x)

B[4] + 2*B[5]

sage: S.cartesian_projection(1)(x)

3*B[6]

sage: S.cartesian_projection(0)(x).parent() == F

True

sage: S.cartesian_projection(1)(x).parent() == G

True

"""

assert i in self._sets_keys()

module = self._sets[i]

return self._module_morphism(lambda j_t: module.monomial(j_t[1]) if i == j_t[0] else module.zero(), codomain = module)

summand_projection = cartesian_projection

def _cartesian_product_of_elements(self, elements):

"""

Return the Cartesian product of the elements.

INPUT:

- ``elements`` -- a tuple with one element of each Cartesian

factor of ``self``

EXAMPLES::

sage: F = CombinatorialFreeModule(ZZ, [4,5]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [4,6]); G.__custom_name = "G"

sage: S = cartesian_product([F, G])

sage: f = F.monomial(4) + 2 * F.monomial(5)

sage: g = 2*G.monomial(4) + G.monomial(6)

sage: S._cartesian_product_of_elements([f, g])

B[(0, 4)] + 2*B[(0, 5)] + 2*B[(1, 4)] + B[(1, 6)]

sage: S._cartesian_product_of_elements([f, g]).parent() == S

True

"""

return self.sum(self.summand_embedding(i)(elements[i]) for i in self._sets_keys())

def cartesian_factors(self):

"""

Return the factors of the Cartesian product.

EXAMPLES::

sage: F = CombinatorialFreeModule(ZZ, [4,5]); F.__custom_name = "F"

sage: G = CombinatorialFreeModule(ZZ, [4,6]); G.__custom_name = "G"

sage: S = cartesian_product([F, G])

sage: S.cartesian_factors()

(F, G)

"""

return self._sets

class Element(CombinatorialFreeModule.Element): # TODO: get rid of this inheritance

pass

CombinatorialFreeModule.CartesianProduct = CombinatorialFreeModule_CartesianProduct

Coverage for local/lib/python2.7/site-packages/sage/combinat/free_module.py : 65%

325 statements 212 run 113 missing 0 excluded