def __init__(self, R, A): """ Initialize ``self``. TESTS:: sage: C4 = graphs.CycleGraph(4) sage: A = groups.misc.RightAngledArtin(C4) sage: H = A.cohomology() sage: TestSuite(H).run() """ if R not in Fields(): raise NotImplementedError( "only implemented with coefficients in a field") self._group = A names = tuple(['e' + name[1:] for name in A.variable_names()]) from sage.graphs.independent_sets import IndependentSets from sage.sets.finite_enumerated_set import FiniteEnumeratedSet indices = [tuple(ind_set) for ind_set in IndependentSets(A._graph)] indices = FiniteEnumeratedSet(indices) cat = AlgebrasWithBasis( R.category()).Super().Graded().FiniteDimensional() CombinatorialFreeModule.__init__(self, R, indices, category=cat, prefix='H') self._assign_names(names)
def __init__(self, R, names): r""" Initialize ``self``. EXAMPLES:: sage: F = ShuffleAlgebra(QQ, 'xyz'); F Shuffle Algebra on 3 generators ['x', 'y', 'z'] over Rational Field sage: TestSuite(F).run() TESTS:: sage: ShuffleAlgebra(24, 'toto') Traceback (most recent call last): ... TypeError: argument R must be a ring """ if R not in Rings(): raise TypeError("argument R must be a ring") self._alphabet = names self.__ngens = self._alphabet.cardinality() CombinatorialFreeModule.__init__(self, R, Words(names, infinite=False), latex_prefix="", category=(AlgebrasWithBasis(R), CommutativeAlgebras(R), CoalgebrasWithBasis(R)))
def __init__(self, R, n, names): """ The free algebra on `n` generators over a base ring. EXAMPLES:: sage: F.<x,y,z> = FreeAlgebra(QQ, 3); F # indirect doctest Free Algebra on 3 generators (x, y, z) over Rational Field TESTS: Note that the following is *not* the recommended way to create a free algebra:: sage: from sage.algebras.free_algebra import FreeAlgebra_generic sage: FreeAlgebra_generic(ZZ, 3, 'abc') Free Algebra on 3 generators (a, b, c) over Integer Ring """ if R not in Rings(): raise TypeError("Argument R must be a ring.") self.__ngens = n indices = FreeMonoid(n, names=names) cat = AlgebrasWithBasis(R) CombinatorialFreeModule.__init__(self, R, indices, prefix='F', category=cat) self._assign_names(indices.variable_names())
def __init__(self, R, n, names): """ The free algebra on `n` generators over a base ring. INPUT: - ``R`` - ring - ``n`` - an integer - ``names`` - generator names EXAMPLES:: sage: F.<x,y,z> = FreeAlgebra(QQ, 3); F # indirect doctet Free Algebra on 3 generators (x, y, z) over Rational Field TEST: Note that the following is *not* the recommended way to create a free algebra. :: sage: from sage.algebras.free_algebra import FreeAlgebra_generic sage: FreeAlgebra_generic(ZZ,3,'abc') Free Algebra on 3 generators (a, b, c) over Integer Ring """ if not isinstance(R, Ring): raise TypeError("Argument R must be a ring.") self.__ngens = n #sage.structure.parent_gens.ParentWithGens.__init__(self, R, names) self._basis_keys = FreeMonoid(n, names=names) Algebra.__init__(self, R, names, category=AlgebrasWithBasis(R))
def super_categories(self): """ EXAMPLES:: sage: MonoidAlgebras(QQ).super_categories() [Category of algebras with basis over Rational Field] """ from sage.categories.algebras_with_basis import AlgebrasWithBasis R = self.base_ring() return [AlgebrasWithBasis(R)]
def __init__(self, R, names): """ Initialize ``self``. EXAMPLES:: sage: D = ShuffleAlgebra(QQ, 'ab').dual_pbw_basis() sage: TestSuite(D).run() """ self._alphabet = names self._alg = ShuffleAlgebra(R, names) CombinatorialFreeModule.__init__(self, R, Words(names), prefix='S', category=(AlgebrasWithBasis(R), CommutativeAlgebras(R), CoalgebrasWithBasis(R)))
def __init__(self, R, names=None): r""" Initialize ``self``. EXAMPLES:: sage: R.<x,y,z> = QQ[] sage: W = DifferentialWeylAlgebra(R) sage: TestSuite(W).run() """ self._n = len(names) self._poly_ring = PolynomialRing(R, names) names = names + tuple('d' + n for n in names) if len(names) != self._n * 2: raise ValueError("variable names cannot differ by a leading 'd'") # TODO: Make this into a filtered algebra under the natural grading of # x_i and dx_i have degree 1 # Filtered is not included because it is a supercategory of super if R.is_field(): cat = AlgebrasWithBasis(R).NoZeroDivisors().Super() else: cat = AlgebrasWithBasis(R).Super() Algebra.__init__(self, R, names, category=cat)
def __init__(self, alg): """ Initialize ``self``. EXAMPLES:: sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: TestSuite(PBW).run() """ R = alg.base_ring() self._alg = alg category = AlgebrasWithBasis(R) CombinatorialFreeModule.__init__(self, R, alg.monoid(), prefix='PBW', category=category) self._assign_names(alg.variable_names())
def __init__(self, base_ring, q, prefix='H'): """ Initialize ``self``. EXAMPLES:: sage: R.<q> = ZZ[] sage: H = HallAlgebra(R, q) sage: TestSuite(H).run() sage: R = PolynomialRing(ZZ, 'q').fraction_field() sage: q = R.gen() sage: H = HallAlgebra(R, q) sage: TestSuite(H).run() # long time sage: R.<q> = LaurentPolynomialRing(ZZ) sage: H = HallAlgebra(R, q) sage: TestSuite(H).run() # long time """ self._q = q try: q_inverse = q**-1 if not q_inverse in base_ring: hopf_structure = False else: hopf_structure = True except Exception: hopf_structure = False if hopf_structure: category = HopfAlgebrasWithBasis(base_ring) else: category = AlgebrasWithBasis(base_ring) CombinatorialFreeModule.__init__(self, base_ring, Partitions(), prefix=prefix, bracket=False, sorting_key=cmp_to_key(transpose_cmp), category=category) # Coercions I = self.monomial_basis() M = I.module_morphism(I._to_natural_on_basis, codomain=self, triangular='upper', unitriangular=True, inverse_on_support=lambda x: x.conjugate(), invertible=True) M.register_as_coercion() (~M).register_as_coercion()
def __init__(self, field, relations, names): """ The finitely presented algebra equivalent to the free algebra over `field` generated by `names` modulo the ideal generated by `relations`. """ if field not in Fields: raise TypeError('Base ring must be a field.') if type(relations) == str: relations = tuple(relations.split(',')) elif type(relations) == list: relations = tuple(relations) elif not isinstance(relations, tuple): raise TypeError( 'Relations must be given as a list, tuple, or string.') if type(names) == str: names = tuple(names.split(',')) elif type(names) == list: names = tuple(names) elif not isinstance(names, tuple): raise TypeError( 'Generators must be given as a list, tuple, or string.') self._ngens = len(names) self._nrels = len(relations) self._free_alg = FreeAlgebra(field, self._ngens, names) self._ideal = self._free_alg.ideal(relations) self._reduce = [] for f in self._ideal.gens(): mons = f.monomials() if len(mons) == 1: self._reduce.append([_to_word(f), Word(''), field.zero()]) if len(mons) == 2: coeffs = f.coefficients() if mons[0] < mons[1]: self._reduce.append([ _to_word(mons[1]), _to_word(mons[0]), -coeffs[0] * coeffs[1]**(-1) ]) elif mons[0] > mons[1]: self._reduce.append([ _to_word(mons[0]), _to_word(mons[1]), -coeffs[1] * coeffs[0]**(-1) ]) QuotientRing_nc.__init__(self, self._free_alg, self._ideal, names, category=AlgebrasWithBasis(field))
def __init__(self, base_ring, q, prefix='I'): """ Initialize ``self``. EXAMPLES:: sage: R.<q> = ZZ[] sage: I = HallAlgebra(R, q).monomial_basis() sage: TestSuite(I).run() sage: R = PolynomialRing(ZZ, 'q').fraction_field() sage: q = R.gen() sage: I = HallAlgebra(R, q).monomial_basis() sage: TestSuite(I).run() sage: R.<q> = LaurentPolynomialRing(ZZ) sage: I = HallAlgebra(R, q).monomial_basis() sage: TestSuite(I).run() """ self._q = q try: q_inverse = q**-1 if not q_inverse in base_ring: hopf_structure = False else: hopf_structure = True except Exception: hopf_structure = False if hopf_structure: category = HopfAlgebrasWithBasis(base_ring) else: category = AlgebrasWithBasis(base_ring) CombinatorialFreeModule.__init__(self, base_ring, Partitions(), prefix=prefix, bracket=False, category=category) # Coercions if hopf_structure: e = SymmetricFunctions(base_ring).e() f = lambda la: q**sum(-((r * (r - 1)) // 2) for r in la) M = self.module_morphism(diagonal=f, codomain=e) M.register_as_coercion() (~M).register_as_coercion()
def extra_super_categories(self): """ EXAMPLES:: sage: Semigroups().Algebras(QQ).extra_super_categories() [Category of algebras with basis over Rational Field] sage: Semigroups().Algebras(QQ).super_categories() [Category of algebras with basis over Rational Field, Category of set algebras over Rational Field] sage: Semigroups().example().algebra(ZZ).categories() [Category of semigroup algebras over Integer Ring, Category of algebras with basis over Integer Ring, ... Category of objects] FIXME: that should be non unital algebras! """ from sage.categories.algebras_with_basis import AlgebrasWithBasis return [AlgebrasWithBasis(self.base_ring())]
def extra_super_categories(self): """ EXAMPLES:: sage: Monoids().Algebras(QQ).extra_super_categories() [Category of algebras with basis over Rational Field] sage: Monoids().Algebras(QQ).super_categories() [Category of semigroup algebras over Rational Field] sage: Monoids().example().algebra(ZZ).categories() [Category of monoid algebras over Integer Ring, Category of semigroup algebras over Integer Ring, Category of algebras with basis over Integer Ring, ... Category of objects] """ from sage.categories.algebras_with_basis import AlgebrasWithBasis return [AlgebrasWithBasis(self.base_ring())]
def __init__(self, R, n, r): """ Initialize ``self``. TESTS:: sage: S = SchurAlgebra(ZZ, 2, 2) sage: TestSuite(S).run() :: sage: SchurAlgebra(ZZ, -2, 2) Traceback (most recent call last): ... ValueError: n (=-2) must be a positive integer sage: SchurAlgebra(ZZ, 2, -2) Traceback (most recent call last): ... ValueError: r (=-2) must be a non-negative integer sage: SchurAlgebra('niet', 2, 2) Traceback (most recent call last): ... ValueError: R (=niet) must be a commutative ring """ if n not in ZZ or n <= 0: raise ValueError("n (={}) must be a positive integer".format(n)) if r not in ZZ or r < 0: raise ValueError( "r (={}) must be a non-negative integer".format(r)) if not R in Rings.Commutative(): raise ValueError("R (={}) must be a commutative ring".format(R)) self._n = n self._r = r CombinatorialFreeModule.__init__( self, R, schur_representative_indices(n, r), prefix='S', bracket=False, category=AlgebrasWithBasis(R).FiniteDimensional())