Clifford orders over rings of integers

Throughout this page we make the additional assumption that the Dedekind domain $R$ is the ring of integers $\mathcal{O}_K$ of the algebraic number field $K$. For Clifford orders over rings of integers, excluding $\mathbb{Z}$, we introduce the following new types:

CliffordOrder{T, C} <: Hecke.AbstractAssociativeAlgebra{T} for Clifford orders
CliffordOrderElem{T, C, S} <: Hecke.AbstractAssociativeAlgebraElem{T} for elements of Clifford orders

Here, T is the element type of the base ring $\mathcal{O}_K$ and C is the type of the Clifford algebra of the ambient space of the underlying even $\mathcal{O}_K$-lattice, respectively. Moreover, $S$ is the element type of $K$. It is used for storing coefficients of elements with respect to some pseudo-basis of the Clifford order, as these need not lie in $\mathcal{O}_K$.

In addition to that we introduce the following new types for Clifford orders over $\mathbb{Z}$:

ZZCliffordOrder <: Hecke.AbstractAssociativeAlgebra{ZZRingElem} for Clifford orders
ZZCliffordOrderElem <: Hecke.AbstractAssociativeAlgebraElem{ZZRingElem} for elements of Clifford orders

Depending on whether the given even lattice is defined over $\mathcal{O}_K$ or $\mathbb{Z}$, we provide a corresponding constructor to return its Clifford order.

clifford_order — Method

clifford_order(ls::QuadLat) -> CliffordOrder

Return the Clifford order of the even lattice ls. If the lattice is not even an error is raised.

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(lattice(quadratic_space(K, 2*identity_matrix(K, 2))))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [2   0]
  [0   2]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <1>//1
   <1>//1

julia> ql = quadratic_lattice(K, pseudo_matrix(K[1 0 ;0 1], [ideal(OK, OK(1)), ideal(OK, [OK(2), a + 1])]); gram = K[0 1; 1 0]);

julia> clifford_order(ql)
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <1>//1
   <2, sqrt(-5) + 1>//1

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

clifford_order — Method

clifford_order(ls::ZZLat) -> ZZCliffordOrder

Return the Clifford order of the even integer lattice ls. If the lattice is not even, an error is raised.

Examples

julia> C = clifford_order(root_lattice(:E,8))
Clifford order of even integer lattice with Gram matrix
  [ 2   -1    0    0    0    0    0    0]
  [-1    2   -1    0    0    0    0    0]
  [ 0   -1    2   -1    0    0    0   -1]
  [ 0    0   -1    2   -1    0    0    0]
  [ 0    0    0   -1    2   -1    0    0]
  [ 0    0    0    0   -1    2   -1    0]
  [ 0    0    0    0    0   -1    2    0]
  [ 0    0   -1    0    0    0    0    2]

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Element construction

Let $L$ be an even $R$-lattice with ambient space $V = KL$ and suppose that the Clifford order $C(L)$ was constructed with respect to the implicitly chosen pseudo-basis $(e_i, \mathfrak{a}_i)_{i \in \underline{n}}$ of $L$. An element $a$ in the Clifford order $C(L)$ is stored as it would be as an element of $C(V)$; as a vector of length $2^n$ with entries in $K$. This vector is the coefficient vector of $a$ with respect to the $K$-basis $(e_I \mid I \subseteq \underline{n})$ of $C(V)$. Upon creation and whenever performing any arithmetic operations with $a \in C(L)$, checks are performed to ensure that the coefficient of $e_I$ in this representation of $a$ is actually contained in $\mathfrak{a}_I$.

Ordering of the basis elements of the Clifford order

We use the exact same ordering of the basis elements $e_I$: They are enumerated in increasing order of the integer represented by the characteristic vectors of subsets $I$, read as a binary number with the first entry being the least significant bit.

We provide multiple ways of directly constructing elements of a given Clifford order

(C::Union{CliffordOrder, ZZCliffordOrder})() returns the zero element of the Clifford order C
(C::Union{CliffordOrder, ZZCliffordOrder})(a::T) returns a as an element of C, if possible
(C::Union{CliffordOrder, ZZCliffordOrder})(coeffs::Vector) returns the element in C with coefficient vector coeffs

(Pseudo-)basis and (pseudo-)generators

Recall that over the integers, every even $\mathbb{Z}$-lattice is free, so the theory is very similar to the one over number fields. In particular, its Clifford order is free of rank $2^n$, has the $\mathbb{Z}$-basis $(e_I \mid I \subseteq \underline{n})$ and is generated as a $\mathbb{Z}$-algebra by $\lbrace e_i \mid i \in \underline{n}\rbrace$. We provide the following methods to access these canonical basis elements and generators of the Clifford order.

basis — Method

basis(C::ZZCliffordOrder, i::Int) -> ZZCliffordOrderElem

Return the i-th canonical basis element of C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

basis — Method

basis(C::ZZCliffordOrder) -> Vector{ZZCliffordOrderElem}

Return the canonical basis of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

gen — Method

gen(C::ZZCliffordOrder, i::Int) -> ZZCliffordOrderElem

Return the i-th element of the canonical multiplicative generating set of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

gens — Method

gens(C::ZZCliffordOrder) -> Vector{ZZCliffordOrderElem}

Return the vector of canonical algebra generators of the Clifford order C, i.e., if gram_matrix(C) is the Gram matrix of the underlying quadratic lattice with respect to the basis (e1,...,en) then the vector of images under the canonical embedding into the Clifford order is returned. "

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Over the ring of integers $\mathcal{O}_K \neq \mathbb{Z}$, the Clifford order has the pseudo-basis $(e_I, \mathfrak{a}_I)_{I \subseteq \underline{n}}$ and has the pseudo-generating system $\lbrace e_i, \mathfrak{a}_i \rbrace_{i \in \underline{n}}$ as $\mathcal{O}_K$-algebra. We provide the following methods to access these canonical pseudo-basis elements and generators of the Clifford order.

pseudo_basis — Method

pseudo_basis(C::CliffordOrder, i::Int) -> Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}

Return the i-th canonical pseudo-basis element of C. The first coordinate is returned as an element of ambient_algebra(C).

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> pseudo_basis(C, 1)
([1, 0, 0, 0], <1>//1)

julia> pseudo_basis(C, 2)
([0, 1, 0, 0], <2>//1)

julia> pseudo_basis(C, 3)
([0, 0, 1, 0], <3>//1)

julia> pseudo_basis(C, 4)
([0, 0, 0, 1], <36, 3162>//1)

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

pseudo_basis — Method

pseudo_basis(C::CliffordOrder) -> Vector{Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}}

Return the canonical pseudo-basis of the Clifford order C.

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> pseudo_basis(C)
4-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([1, 0, 0, 0], <1>//1)
 ([0, 1, 0, 0], <2>//1)
 ([0, 0, 1, 0], <3>//1)
 ([0, 0, 0, 1], <36, 3162>//1)

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

pseudo_gen — Method

pseudo_gen(C::CliffordOrder, i::Int) -> Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}

Return the i-th pseudo-element of the canonical algebra pseudo-generating set of the Clifford order C. The first coordinate is returned as an element of ambient_algebra(C).

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(identity_matrix(K, 3), [ideal(OK, OK(2)), ideal(OK, OK(3)), ideal(OK, OK(5))]); gram = K[0 0 1; 0 2 0; 1 0 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   0   1]
  [0   2   0]
  [1   0   0]
and coefficient ideals of the lattice
  3-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1
   <5>//1

julia> pseudo_gen(C, 1)
([0, 1, 0, 0, 0, 0, 0, 0], <2>//1)

julia> pseudo_gen(C, 2)
([0, 0, 1, 0, 0, 0, 0, 0], <3>//1)

julia> pseudo_gen(C, 3)
([0, 0, 0, 0, 1, 0, 0, 0], <5>//1)

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

pseudo_gens — Method

pseudo_gens(C::CliffordOrder) -> Vector{Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}}

Return the canonical algebra pseudo-generating set of the Clifford order C.

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(identity_matrix(K, 3), [ideal(OK, OK(2)), ideal(OK, OK(3)), ideal(OK, OK(5))]); gram = K[0 0 1; 0 2 0; 1 0 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   0   1]
  [0   2   0]
  [1   0   0]
and coefficient ideals of the lattice
  3-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1
   <5>//1

julia> pseudo_gens(C)
3-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([0, 1, 0, 0, 0, 0, 0, 0], <2>//1)
 ([0, 0, 1, 0, 0, 0, 0, 0], <3>//1)
 ([0, 0, 0, 0, 1, 0, 0, 0], <5>//1)

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Return type of pseudo-elements

In the methods above, the $e_I$ or $e_i$ are returned as elements of the ambient algebra. This is because they need not lie in the Clifford order themselves. In fact, this is the case if and only if $1$ lies in the associated fractional ideal $\mathfrak{a}_I$ or $\mathfrak{a}_i$. In contrast, the methods for Clifford orders over the integers will always return the basis elements and generators as elements of the Clifford order, not the ambient algebra.

Basic methods for Clifford orders

zero — Method

zero(C::CliffordOrder) -> CliffordOrderElem
zero(C::ZZCliffordOrder) -> ZZCliffordOrderElem

Return the additive identity of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

one — Method

one(C::CliffordOrder) -> CliffordOrderElem
one(C::ZZCliffordOrder) -> ZZCliffordOrderElem

Return the multiplicative identity of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

base_ring — Method

base_ring(C::CliffordOrder) -> Ring
base_ring(C::ZZCliffordOrder) -> ZZRing

Return the base ring of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

lattice — Method

lattice(C::CliffordOrder) -> QuadLat
lattice(C::ZZCliffordOrder) -> ZZLat

Return the underlying even quadratic lattice of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

gram_matrix — Method

gram_matrix(C::CliffordOrder) -> MatElem
gram_matrix(C::ZZCliffordOrder) -> QQMatrix

Return the Gram matrix with respect to the fixed pseudo-basis of the Clifford order C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

rank — Method

rank(C::Union{CliffordOrder, ZZCliffordOrder}) -> Int

Return the rank of the Clifford order C over its base ring.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

is_commutative — Method

is_commutative(C::Union{CliffordOrder, ZZCliffordOrder}) -> Bool

Return true if C is commutative and false otherwise.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Basic methods for elements of a Clifford order

parent — Method

parent(x::CliffordOrderElem) -> CliffordOrder
parent(x::ZZCliffordOrderElem) -> ZZCliffordOrder

Return the Clifford order containing x.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

coeff — Method

coeff(x::CliffordOrderElem, i::Int) -> RingElem
coeff(x::ZZCliffordOrderElem, i::Int) -> ZZRingElem

Return the i-th coefficient of the element x.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

coefficients — Method

coefficients(x::CliffordOrderElem) -> Vector{NumFieldElem}
coefficients(x::ZZCliffordOrderElem) -> Vector{QQFieldElem}

Return the coefficient vector of x with respect to the canonical (pseudo-)basis of its parent Clifford order.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

In addition to the above coeff-method, you can also use standard indexing syntax to conveniently access and modify the coefficients of an element of a Clifford order. When modifying coefficients this way, it is verified that the new coefficient is valid. For CliffordOrderElem, it is checked that the value lies within the associated fractional ideal of that entry. For ZZCliffordOrderElem, it is checked that the value is an integer.

#Access the third entry of an element x of a Clifford order
x[3]

#Modify the third entry of an element x of a Clifford order
x[3] = 2

Containment and conversion

Elements of the ambient Clifford algebra $C(V)$ can be tested for membership in the Clifford order $C(L)$.

in — Method

in(x::CliffordAlgebraElem, C::CliffordOrder) -> Bool
in(x::CliffordAlgebraElem, C::ZZCliffordOrder) -> Bool

Return true if the element x is contained in the Clifford order C.

Examples

For Clifford orders over rings of integers, it is tested if all coefficients of a given element lie in fractional ideal associated to the entry.

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> x = pseudo_basis(C, 2)[1]
[0, 1, 0, 0]

julia> x in C
false

julia> 2*x in C
true

For Clifford order over the integers, it is tested of all coefficients of a given elements are integers.

julia> C = clifford_order(root_lattice(:A, 2))
Clifford order of even integer lattice with Gram matrix
  [ 2   -1]
  [-1    2]

julia> CA = ambient_algebra(C); (x, y) = CA([6//3, 0, -4//2, 6]), CA([1, 4, 5//2, -2])
([2, 0, -2, 6], [1, 4, 5//2, -2])

julia> x in C
true

julia> y in C
false

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Additionally, we provide the following constructors to transition elements between the algebra and the order, raising an error if an algebra element is not contained in the order:

(C::CliffordAlgebra)(x::Union{CliffordOrderElem, ZZCliffordOrderElem})
(C::Union{CliffordOrder, ZZCliffordOrder})(x::CliffordAlgebraElem)

Functionality for graded parts

The Clifford order $C(L)$ inherits the $\mathbb{Z}/2\mathbb{Z}$-grading $C(L) = C_0(L) \oplus C_1(L)$ from the $\mathbb{Z}/2\mathbb{Z}$-grading $C(V) = C_0(V) \oplus C_1(V)$ via $C_i(L) = C_i(V) \cap C(L)$, for $i \in \lbrace 0, 1 \rbrace$. A pseudo-generating set of $C_i(L)$ is given by the set of pseudo-basis elements $(e_I, \mathfrak{a}_I)$ of $C(L)$ with $I \: \mathrm{mod} \: 2 = i$. Thus, $C_0(L)$ and $C_1(L)$ are $\mathcal{O}_K$-submodules of $C(L)$ of rank $2^{n-1}$. Moreover, $C_0(L)$ is an $\mathcal{O}_K$-suborder of $C(L)$, called the even Clifford order of $L$ and the odd part $C_1(L)$ is a $C_0(L)$-bimodule.

Currently, we only provide the following basic functionality on elements for the graded parts of the Clifford order:

even_coefficients — Method

even_coefficients(x::CliffordOrderElem) -> Vector{NumFieldElem}
even_coefficients(x::ZZCliffordOrderElem) -> Vector{QQFieldElem}

Return the coefficient vector of x with respect to the canonical (pseudo-)basis of its parent Clifford order, but with all its coefficients that correspond to basis elements with odd grading set to zero.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

even_part — Method

even_part(x::CliffordOrderElem) -> CliffordOrderElem
even_part(x::ZZCliffordOrderElem) -> ZZCliffordOrderElem

Return the projection of x onto the even Clifford order.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

is_even — Method

is_even(x::Union{CliffordOrderElem, ZZCliffordOrderElem}) -> Bool

Return 'true' if 'x' is even, i.e. if even_part(x) and x coincide. Otherwise, return false.

odd_coefficients — Method

odd_coefficients(x::CliffordOrderElem) -> Vector{NumFieldElem}
odd_coefficients(x::ZZCliffordOrderElem) -> Vector{QQFieldElem}

Return the coefficient vector of x with respect to the canonical (pseudo-)basis of its parent Clifford order, but with all its coefficients that correspond to basis elements with even grading set to zero.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

odd_part — Method

odd_part(x::CliffordOrderElem) -> CliffordOrderElem
odd_part(x::ZZCliffordOrderElem) -> ZZCliffordOrderElem

Return the projection of x onto the odd Clifford order.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

is_odd — Method

is_odd(x::Union{CliffordOrderElem, ZZCliffordOrderElem}) -> Bool

Return 'true' if 'x' is odd, i.e. if odd_part(x) and x coincide. Otherwise, return false.

Center, centroid and quadratic discriminant

Similar to the field case, the centroid of the even lattice $L = (L,q)$ (or of $C = C(L)$), denoted by $\mathcal{Z}(L)$, is the centraliser of $C_0(L)$ in $C$. Thus, we have $\mathcal{Z}(L) = \mathcal{Z}(V) \cap C(L)$. Unless $n = \mathrm{dim}(V) = \mathrm{rank}(L) = 0$, in which case $C(L) = C_0(L) = \mathcal{Z}(L) \cong \mathcal{O}_K$, the centroid is always an $\mathcal{O}_K$-order in the separable quadratic $K$-algebra $\mathcal{Z}(V)$. This means that

\[\mathcal{Z}(L) = \mathcal{O}_K\cdot 1_C \oplus \mathfrak{a}x\]

with a fractional ideal $\mathfrak{a}$ and some root $x \in C(V)$ of the polynomial $X^2 - tX + n \in K[X]$, where $t \in \mathfrak{a}^{-1}$ and $n \in \mathfrak{a}^{-2}$. Every such quadratic $\mathcal{O}_K$-order $\Lambda$ contains a unique maximal orthogonal suborder, denoted by $\Lambda^o$, where orthogonal means that one can choose $t = 0$ in the above representation and maximal is meant with respect to set inclusion. If we write $\Lambda^o = \mathcal{O}_K \cdot 1_\Lambda \oplus \mathfrak{b}z$ with $z \in K\Lambda$ satisfying $z^2 - d \in K^\times$, then $\mathcal{Z}(L)^o$ is determined as an $\mathcal{O}_K$-algebra up to isomorphism by the fractional ideal $\mathfrak{b}^2 n$ and the $K$-square class of $d$. The pair $(\mathfrak{b}^2 n, d(K^\times)^2)$ is called the quadratic discriminant of $\Lambda$.

The quadratic discriminant of the lattice $L$ (or of $C$), denoted by $\mathrm{disq}(L)$, is defined as the quadratic discriminant of its centroid $\mathcal{Z}(L)$.

Quadratic discriminant over principal ideal domains

Unlike the field case where the quadratic discriminant is simply a square class, for an even lattice it is a pair living in $\mathcal{I}(\mathcal{O}_K) \times K^\times/(K^\times)^2$, where $\mathcal{I}(\mathcal{O}_K)$ is the group of fractional ideals of $\mathcal{O}_K$.

If $\mathcal{O}_K$ is a principal ideal domain, the quadratic discriminant can be identified with the unique square class $d(\mathcal{O}_K^\times)^2$ for some $d \in \mathcal{O}_K$ such that $\mathcal{Z}(L) = \mathcal{O}_K[X]/(X^2 - d)$. In particular, if $\mathcal{O}_K = \Z$, then the quadratic discriminant can be regarded as an integer.

Just as in the field case, the behavior of the center and the centroid heavily depends on the parity of the rank $n$ of the lattice:

If the rank $n$ is even, the centroid is entirely contained within the even Clifford order, i.e. $\mathcal{Z}(L) \subseteq C_0(L)$. Moreover, the center is trivial, $Z(C) = \mathcal{O}_K$.
If the rank $n$ is odd, the centroid is strictly orthogonal, meaning $\mathcal{Z}(L) = \mathcal{Z}(L)^o$. In this case, the generator of the centroid can be chosen from $C_1(L)$ such that it has a trace of zero. Furthermore, the centroid coincides with the center of the Clifford order, $Z(C) = \mathcal{Z}(L)$.

For Clifford orders over $\mathcal{O}_K \neq \Z$ we provide the following methods:

pseudo_basis_of_center — Method

pseudo_basis_of_center(C::CliffordOrder) -> Vector{Tuple{CliffordOrderElem, NumFieldOrderFractionalIdeal}}

Return a pseudo-basis of the center of C. It equals pseudo_basis_of_centroid(C), if and only if rank(lattice(C)) is odd. Otherwise it is trivial.

Examples

In case that the underlying lattice has even rank, the center of the Clifford Order equals its base ring.

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> pseudo_basis_of_center(C)
1-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([1, 0, 0, 0], <1>//1)

If the underlying lattice has odd rank, then the center and the centroid of the Clifford algebra coincide.

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> D = clifford_order(quadratic_lattice(K, pseudo_matrix(identity_matrix(K, 3), [ideal(OK, OK(2)), ideal(OK, OK(3)), ideal(OK, OK(5))]); gram = K[0 0 1; 0 2 0; 1 0 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   0   1]
  [0   2   0]
  [1   0   0]
and coefficient ideals of the lattice
  3-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1
   <5>//1

julia> pseudo_basis_of_center(D)
2-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([1, 0, 0, 0, 0, 0, 0, 0], <1>//1)
 ([0, 0, -1, 0, 0, 0, 0, -2], <15, 15*sqrt(-5)>//1)

julia> pseudo_basis_of_center(D) == pseudo_basis_of_centroid(D)
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

pseudo_basis_of_centroid — Method

pseudo_basis_of_centroid(C::CliffordOrder) -> Vector{Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}}

Return a pseudo-basis of the centroid of C. Unless rank(lattice(C)) = 0, it contains two pseudo-elements, so it is returned as a vector containing these.

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> pseudo_basis_of_centroid(C)
2-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([1, 0, 0, 0], <1>//1)
 ([1, 0, 0, -1], <6, 6>//1)

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

pseudo_basis_of_max_orth_suborder_of_centroid — Method

pseudo_basis_of_max_orth_suborder_of_centroid(C::CliffordOrder) -> Vector{Tuple{CliffordAlgebraElem, NumFieldOrderFractionalIdeal}}

Return a pseudo-basis of the maximal orthogonal suborder of the centroid of C. Unless rank(lattice(C)) = 0, it consists of two pseudo-elements, so it is returned as a vector containing these. The first one is the multiplicative identity of C paired with the ring of integers as fractional ideal. The square of the first coordinate of the second pseudo-element, if present, equals the second coordinate of quadratic_discriminant(C) if rank(lattice(C)) is odd, and a quarter of it if the rank is even.

Examples

julia> K, a = quadratic_field(-5); OK = maximal_order(K);

julia> C = clifford_order(quadratic_lattice(K, pseudo_matrix(K[1 0; 0 1], [ideal(OK, OK(2)), ideal(OK, OK(3))]); gram = K[0 1; 1 0]))
Clifford order of even lattice over maximal order of imaginary quadratic field defined by x^2 + 5 with Gram matrix
  [0   1]
  [1   0]
and coefficient ideals of the lattice
  2-element Vector{AbsSimpleNumFieldOrderFractionalIdeal}:
   <2>//1
   <3>//1

julia> pseudo_basis_of_max_orth_suborder_of_centroid(C)
2-element Vector{Tuple{CliffordAlgebraElem{AbsSimpleNumFieldElem, AbstractAlgebra.Generic.MatSpaceElem{AbsSimpleNumFieldElem}}, AbsSimpleNumFieldOrderFractionalIdeal}}:
 ([1, 0, 0, 0], <1>//1)
 ([1//2, 0, 0, -1], <6, 6*sqrt(-5)>//1)

julia> x = pseudo_basis_of_max_orth_suborder_of_centroid(C)[2][1]; (4 * x^2)[1] == disq(C)[2]
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

quadratic_discriminant — Method

quadratic_discriminant(C::CliffordOrder) -> Tuple{NumFieldOrderFractionalIdeal, NumFieldElem}

Return the quadratic discriminant of C as a tuple (disq_ideal, alg_disq) where:

disq_ideal is the discriminant ideal of the maximal orthogonal suborder of the centroid of C. Specifically, if this suborder is written as $R \cdot 1 \oplus \mathfrak{a} \cdot x$ (where $R$ is the base ring of C and $x$ is an orthogonal generator), then disq_ideal equals the fractional ideal $\mathfrak{a}^2 x^2$.
alg_disq is the quadratic discriminant of the ambient Clifford algebra. It lies in the same $K$-square class as $x^2$ (rather the scalar coordinate $x^2[1]$), where $K$ is the base field.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

disq — Method

disq(C::CliffordOrder) -> Tuple{NumFieldOrderFractionalIdeal, NumFieldElem}

Alias for quadratic_discriminant.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

For Clifford orders over the integers we provide the following methods:

basis_of_center — Method

basis_of_center(C::ZZCliffordOrder) -> Vector{ZZCliffordOrderElem}

Return a basis of the center of C. It equals basis_of_centroid(C), if and only if rank(lattice(C)) is odd. Otherwise it contains only the multiplicative identity of C.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

basis_of_centroid — Method

basis_of_centroid(C::ZZCliffordOrder) -> Vector{ZZCliffordOrderElem}

Return a basis of the centroid of C. Unless rank(lattice(C)) = 0, it is always free of rank two, so it is returned as a vector containing the basis elements. The first one is the multiplicative identity of C.

Examples

julia> C = clifford_order(root_lattice(:A, 2))
Clifford order of even integer lattice with Gram matrix
  [ 2   -1]
  [-1    2]

julia> basis_of_centroid(C)
2-element Vector{ZZCliffordOrderElem}:
 [1, 0, 0, 0]
 [1, 0, 0, 1]

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

basis_of_max_orth_suborder_of_centroid — Method

basis_of_max_orth_suborder_of_centroid(C::ZZCliffordOrder) -> Vector{ZZCliffordOrderElem}

Return a basis of the maximal orthogonal suborder of the centroid of C. Unless rank(lattice(C)) = 0, it is always free of rank two, so it is returned as a vector containing the basis elements. The first one is the multiplicative identity of C. The square of the second basis element, if present, equals quadratic_discriminant(C).

Examples

julia> C = clifford_order(root_lattice(:A, 2))
Clifford order of even integer lattice with Gram matrix
  [ 2   -1]
  [-1    2]

julia> basis_of_max_orth_suborder_of_centroid(C)
2-element Vector{ZZCliffordOrderElem}:
 [1, 0, 0, 0]
 [1, 0, 0, 2]

julia> (C([1, 0, 0, 2])^2)[1] == disq(C)
true

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

quadratic_discriminant — Method

quadratic_discriminant(C::ZZCliffordOrder) -> ZZRingElem

Return the quadratic discriminant of C as an integer.

Examples

julia> C = clifford_order(root_lattice(:A, 2))
Clifford order of even integer lattice with Gram matrix
  [ 2   -1]
  [-1    2]

julia> quadratic_discriminant(C)
-3

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

disq — Method

disq(C::ZZCliffordOrder) -> ZZRingElem

Alias for quadratic_discriminant.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.