def __init__(self, Lam):
"""
Initialize ``self``.
EXAMPLES::
sage: Lambda = RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
sage: V = IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3])
Some methods required by the category are not implemented::
sage: TestSuite(V).run() # known bug (#21387)
"""
CategoryObject.__init__(self, base=ZZ, category=Modules(ZZ))
self._Lam = Lam
self._P = Lam.parent()
self._Q = self._P.root_system.root_lattice()
# Store some extra simple computations that appear in tight loops
self._Lam_rho = self._Lam + self._P.rho()
self._cartan_matrix = self._P.root_system.cartan_matrix()
self._cartan_type = self._P.root_system.cartan_type()
self._classical_rank = self._cartan_type.classical().rank()
self._index_set = self._P.index_set()
self._index_set_classical = self._cartan_type.classical().index_set()
self._cminv = self._cartan_type.classical().cartan_matrix().inverse()
self._ddict = {}
self._mdict = {tuple(0 for i in self._index_set): 1}
# Coerce a classical root into the root lattice Q
from_cl_root = lambda h: self._Q._from_dict(h._monomial_coefficients)
self._classical_roots = [
from_cl_root(al) for al in self._Q.classical().roots()
]
self._classical_positive_roots = [
from_cl_root(al) for al in self._Q.classical().positive_roots()
]
self._a = self._cartan_type.a() # This is not cached
self._ac = self._cartan_type.dual().a() # This is not cached
self._eps = {i: self._a[i] / self._ac[i] for i in self._index_set}
E = Matrix.diagonal([self._eps[i] for i in self._index_set_classical])
self._ip = (self._cartan_type.classical().cartan_matrix() *
E).inverse()
# Extra data for the twisted cases
if not self._cartan_type.is_untwisted_affine():
self._classical_short_roots = frozenset(
al for al in self._classical_roots
if self._inner_qq(al, al) == 2)
def __init__(self, Lam):
"""
Initialize ``self``.
EXAMPLES::
sage: Lambda = RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
sage: V = IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3])
sage: TestSuite(V).run()
"""
CategoryObject.__init__(self, base=ZZ, category=Modules(ZZ))
if not Lam.parent().cartan_type().is_affine() or not Lam.parent(
)._extended:
raise ValueError(
"the parent of %s must be an extended affine root lattice" %
Lam)
self._Lam = Lam
self._P = Lam.parent()
self._Q = self._P.root_system.root_lattice()
self._cartan_matrix = self._P.root_system.cartan_matrix()
self._cartan_type = self._P.root_system.cartan_type()
if not self._cartan_type.is_untwisted_affine():
raise NotImplementedError(
"integrable representations are only implemented for untwisted affine types"
)
self._classical_rank = self._cartan_type.classical().rank()
self._index_set = self._P.index_set()
self._index_set_classical = self._cartan_type.classical().index_set()
self._cminv = self._cartan_type.classical().cartan_matrix().inverse()
self._ddict = {}
self._mdict = {tuple(0 for i in self._index_set): 1}
# Coerce a classical root into the root lattice Q
from_cl_root = lambda h: self._Q._from_dict(h._monomial_coefficients)
self._classical_roots = [
from_cl_root(al) for al in self._Q.classical().roots()
]
self._classical_positive_roots = [
from_cl_root(al) for al in self._Q.classical().positive_roots()
]
self._a = self._cartan_type.a() # This is not cached
self._ac = self._cartan_type.dual().a() # This is not cached
self._eps = {i: self._a[i] / self._ac[i] for i in self._index_set}
self._coxeter_number = sum(self._a)
self._dual_coxeter_number = sum(self._ac)
E = Matrix.diagonal([self._eps[i] for i in self._index_set_classical])
self._ip = (self._cartan_type.classical().cartan_matrix() *
E).inverse()
def __init__(self, Lam):
"""
Initialize ``self``.
EXAMPLES::
sage: Lambda = RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
sage: V = IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3])
Some methods required by the category are not implemented::
sage: TestSuite(V).run() # known bug (#21387)
"""
CategoryObject.__init__(self, base=ZZ, category=Modules(ZZ))
self._Lam = Lam
self._P = Lam.parent()
self._Q = self._P.root_system.root_lattice()
# Store some extra simple computations that appear in tight loops
self._Lam_rho = self._Lam + self._P.rho()
self._cartan_matrix = self._P.root_system.cartan_matrix()
self._cartan_type = self._P.root_system.cartan_type()
self._classical_rank = self._cartan_type.classical().rank()
self._index_set = self._P.index_set()
self._index_set_classical = self._cartan_type.classical().index_set()
self._cminv = self._cartan_type.classical().cartan_matrix().inverse()
self._ddict = {}
self._mdict = {tuple(0 for i in self._index_set): 1}
# Coerce a classical root into the root lattice Q
from_cl_root = lambda h: self._Q._from_dict(h._monomial_coefficients)
self._classical_roots = [from_cl_root(al)
for al in self._Q.classical().roots()]
self._classical_positive_roots = [from_cl_root(al)
for al in self._Q.classical().positive_roots()]
self._a = self._cartan_type.a() # This is not cached
self._ac = self._cartan_type.dual().a() # This is not cached
self._eps = {i: self._a[i] / self._ac[i] for i in self._index_set}
E = Matrix.diagonal([self._eps[i] for i in self._index_set_classical])
self._ip = (self._cartan_type.classical().cartan_matrix()*E).inverse()
# Extra data for the twisted cases
if not self._cartan_type.is_untwisted_affine():
self._classical_short_roots = frozenset(al for al in self._classical_roots
if self._inner_qq(al,al) == 2)
def __init__(self, Lam):
"""
Initialize ``self``.
EXAMPLES::
sage: Lambda = RootSystem(['A',3,1]).weight_lattice(extended=true).fundamental_weights()
sage: V = IntegrableRepresentation(Lambda[1]+Lambda[2]+Lambda[3])
sage: TestSuite(V).run()
"""
CategoryObject.__init__(self, base=ZZ, category=Modules(ZZ))
if not Lam.parent().cartan_type().is_affine() or not Lam.parent()._extended:
raise ValueError("the parent of %s must be an extended affine root lattice"%Lam)
self._Lam = Lam
self._P = Lam.parent()
self._Q = self._P.root_system.root_lattice()
self._cartan_matrix = self._P.root_system.cartan_matrix()
self._cartan_type = self._P.root_system.cartan_type()
if not self._cartan_type.is_untwisted_affine():
raise NotImplementedError("integrable representations are only implemented for untwisted affine types")
self._classical_rank = self._cartan_type.classical().rank()
self._index_set = self._P.index_set()
self._index_set_classical = self._cartan_type.classical().index_set()
self._cminv = self._cartan_type.classical().cartan_matrix().inverse()
self._ddict = {}
self._mdict = {tuple(0 for i in self._index_set): 1}
# Coerce a classical root into the root lattice Q
from_cl_root = lambda h: self._Q._from_dict(h._monomial_coefficients)
self._classical_roots = [from_cl_root(al)
for al in self._Q.classical().roots()]
self._classical_positive_roots = [from_cl_root(al)
for al in self._Q.classical().positive_roots()]
self._a = self._cartan_type.a() # This is not cached
self._ac = self._cartan_type.dual().a() # This is not cached
self._eps = {i: self._a[i] / self._ac[i] for i in self._index_set}
self._coxeter_number = sum(self._a)
self._dual_coxeter_number = sum(self._ac)
E = Matrix.diagonal([self._eps[i] for i in self._index_set_classical])
self._ip = (self._cartan_type.classical().cartan_matrix()*E).inverse()
def __init__(self, A, M):
"""
Initialize ``self``.
EXAMPLES::
sage: SGA = SymmetricGroupAlgebra(QQ, 3)
sage: T = SGA.trivial_representation()
sage: H = SGA.hochschild_complex(T)
We skip the category test because the category containment
tests assumes ``H`` is an instance of :class:`Parent`::
sage: TestSuite(H).run(skip="_test_category")
sage: H.category() == ChainComplexes(QQ)
True
sage: H in ChainComplexes(QQ) # known bug
True
"""
self._A = A
self._M = M
CategoryObject.__init__(self, base=A.base_ring(),
category=ChainComplexes(A.base_ring()))
def __init__(self, A, M):
"""
Initialize ``self``.
EXAMPLES::
sage: SGA = SymmetricGroupAlgebra(QQ, 3)
sage: T = SGA.trivial_representation()
sage: H = SGA.hochschild_complex(T)
sage: H.category()
Category of chain complexes over Rational Field
sage: H in ChainComplexes(QQ)
True
Some methods required by the category are not implemented::
sage: TestSuite(H).run() # known bug (#21386)
"""
self._A = A
self._M = M
CategoryObject.__init__(self, base=A.base_ring(),
category=ChainComplexes(A.base_ring()))
def __init__(self, A, M):
"""
Initialize ``self``.
EXAMPLES::
sage: SGA = SymmetricGroupAlgebra(QQ, 3)
sage: T = SGA.trivial_representation()
sage: H = SGA.hochschild_complex(T)
We skip the category test because the category containment
tests assumes ``H`` is an instance of :class:`Parent`::
sage: TestSuite(H).run(skip="_test_category")
sage: H.category() == ChainComplexes(QQ)
True
sage: H in ChainComplexes(QQ) # known bug
True
"""
self._A = A
self._M = M
CategoryObject.__init__(self,
base=A.base_ring(),
category=ChainComplexes(A.base_ring()))
def __init__(self, A, M):
"""
Initialize ``self``.
EXAMPLES::
sage: SGA = SymmetricGroupAlgebra(QQ, 3)
sage: T = SGA.trivial_representation()
sage: H = SGA.hochschild_complex(T)
sage: H.category()
Category of chain complexes over Rational Field
sage: H in ChainComplexes(QQ)
True
Some methods required by the category are not implemented::
sage: TestSuite(H).run() # known bug (#21386)
"""
self._A = A
self._M = M
CategoryObject.__init__(self,
base=A.base_ring(),
category=ChainComplexes(A.base_ring()))
def __init__(self, range, modulus):
self._range = range
self._mod = modulus
CategoryObject.__init__(self, category=Gradings())
def __init__(self,
rank,
name,
base_space,
field='real',
latex_name=None,
category=None,
unique_tag=None):
r"""
Construct a topological vector bundle.
TESTS::
sage: M = Manifold(2, 'M', structure='top')
sage: from sage.manifolds.vector_bundle import TopologicalVectorBundle
sage: TopologicalVectorBundle(2, 'E', M)
Topological real vector bundle E -> M of rank 2 over the base space
2-dimensional topological manifold M
"""
if base_space is None:
raise ValueError("a base space must be provided")
###
# Handle the field:
if field == 'real':
self._field = RR
self._field_type = field
elif field == 'complex':
self._field = CC
self._field_type = field
else:
self._field = field
if isinstance(field, RealField_class):
self._field_type = 'real'
elif isinstance(field, ComplexField_class):
self._field_type = 'complex'
else:
self._field_type = 'neither_real_nor_complex'
bs_field = base_space.base_field()
if not bs_field.is_subring(self._field):
raise ValueError("for concrete implementation, manifold's base "
"field must be a subfield of the vector bundle's "
"base field")
###
# Get the category:
if category is None:
category = VectorBundles(base_space, self._field)
CategoryObject.__init__(self, base=self._field, category=category)
# Check rank:
if not isinstance(rank, (int, Integer)):
raise TypeError("the rank must be an integer")
if rank < 1:
raise ValueError("the rank must be strictly positive")
###
# Define remaining attributes:
self._rank = rank
self._diff_degree = 0
self._base_space = base_space
self._total_space = None
###
# Set names:
self._name = name
if latex_name is None:
self._latex_name = self._name
else:
self._latex_name = latex_name
###
# Initialize derived quantities like frames and trivializations:
self._init_derived()
