# Creating PBW-Algebras

## Types

PBW-algebras are modeled by objects of type `PBWAlgRing{T, S} <: NCRing`

, their elements are objects of type `PBWAlgElem{T, S} <: NCRingElem`

. Here, `T`

is the element type of the field over which the PBW-algebra is defined (the type `S`

is added for internal use).

## Constructors

The basic constructor below allows one to build PBW-algebras:

`pbw_algebra`

— Method`pbw_algebra(R::MPolyRing{T}, rel, ord::MonomialOrdering; check::Bool = true) where T`

Given a multivariate polynomial ring `R`

over a field, say $R=K[x_1, \dots, x_n]$, given a strictly upper triangular matrix `rel`

with entries in `R`

of type $c_{ij} \cdot x_ix_j+d_{ij}$, where the $c_{ij}$ are nonzero scalars and where we think of the $x_jx_i = c_{ij} \cdot x_ix_j+d_{ij}$ as setting up relations in the free associative algebra $K\langle x_1, \dots , x_n\rangle$, and given an ordering `ord`

on $\text{Mon}(x_1, \dots, x_n)$, return the PBW-algebra

\[A = K\langle x_1, \dots , x_n \mid x_jx_i = c_{ij} \cdot x_ix_j+d_{ij}, \ 1\leq i<j \leq n \rangle.\]

The input data gives indeed rise to a PBW-algebra if:

- The ordering
`ord`

is admissible for`A`

. - The standard monomials in $K\langle x_1, \dots , x_n\rangle$ represent a
`K`

-basis for`A`

.

See the definition of PBW-algebras in the OSCAR documentation for details.

The `K`

-basis condition above is checked by default. This check may be skipped by passing `check = false`

.

**Examples**

```
julia> R, (x, y, z) = QQ["x", "y", "z"];
julia> L = [x*y, x*z, y*z + 1];
julia> REL = strictly_upper_triangular_matrix(L);
julia> A, (x, y, z) = pbw_algebra(R, REL, deglex(gens(R)))
(PBW-algebra over Rational field in x, y, z with relations y*x = x*y, z*x = x*z, z*y = y*z + 1, PBWAlgElem{QQFieldElem, Singular.n_Q}[x, y, z])
```

Some PBW-algebras are predefined in OSCAR.

### Weyl Algebras

The *$n$-th Weyl algebra over a field $K$* is the PBW-algebra

\[D_n(K)=K \langle x_1,\ldots, x_n, \partial _1,\dots \partial _n \mid \partial_i x_i=x_i\partial _i +1, \partial _i x_j=x_j \partial _i \ \text { for }\ i\neq j\rangle.\]

Here, we tacitly assume that

\[x_j x_i=x_i x _j \; \text{ and } \; \partial _j \partial_i=\partial_i \partial _j \; \text{ for all } \; i,j.\]

Note that any global monomial ordering on $\text{Mon}_{2n}(x, \partial)$ is admissible for $D_n(K)$.

The constructor below returns the algebras equipped with `degrevlex`

.

`weyl_algebra`

— Method`weyl_algebra(K::Ring, xs::AbstractVector{<:VarName})`

Given a field `K`

and a vector `xs`

of, say, $n$ Strings, Symbols, or Characters, return the $n$-th Weyl algebra over `K`

.

The generators of the returned algebra print according to the entries of `xs`

. See the example below.

**Examples**

```
julia> D, (x, y, dx, dy) = weyl_algebra(QQ, ["x", "y"])
(Weyl-algebra over Rational field in variables (x, y), PBWAlgElem{QQFieldElem, Singular.n_Q}[x, y, dx, dy])
julia> dx*x
x*dx + 1
```

### Universal Enveloping Algebras of Finite Dimensional Lie Algebras

Let $\mathfrak g$ be an $n$-dimensional Lie algebra over a field $K$, and let $x_1, \dots, x_n$ be a $K$-basis of $\mathfrak g$. Consider $n$ indeterminates which are also denoted by $x_1, \dots, x_n$. The *universal enveloping algebra of $\mathfrak g$* is the PBW-algebra

\[U(\mathfrak g)=K \langle x_1,\ldots, x_n \mid x_jx_i = x_ix_j+[x_j, x_i], \ 1\leq i<j \leq n \rangle,\]

where $[x_j, x_i]$ corresponds to evaluating the Lie bracket $[x_j, x_i]_\mathfrak g$. That the standard monomials in $U(\mathfrak g)$ indeed form a $K$-basis for $U(\mathfrak g)$ is the content of the Poincar$\'{\text{e}}$-Birkhoff-Witt theorem (the names PBW-basis and PBW-algebra are derived from this fact).

Note that any degree compatible global monomial ordering on $\N^n$ is admissible for $U(\mathfrak g)$.

The constructors below return the algebras equipped with `degrevlex`

.

### Quantized Enveloping Algebras

### Non-Standard Quantum Deformation of $so_3$

## Data Associated to PBW-Algebras

Given a PBW-algebra `A`

over a field `K`

,

`coefficient_ring(A)`

refers to`K`

,`gens(A)`

to the generators of`A`

,`number_of_generators(A)`

/`ngens(A)`

to the number of these generators, and`gen(A, i)`

as well as`A[i]`

to the`i`

-th such generator.

###### Examples

```
julia> R, (x,y,z) = QQ["x", "y", "z"];
julia> L = [x*y, x*z, y*z + 1];
julia> REL = strictly_upper_triangular_matrix(L);
julia> A, (x,y,z) = pbw_algebra(R, REL, deglex(gens(R)));
julia> coefficient_ring(A)
Rational field
julia> gens(A)
3-element Vector{PBWAlgElem{QQFieldElem, Singular.n_Q}}:
x
y
z
julia> gen(A, 2)
y
julia> A[3]
z
julia> number_of_generators(A)
3
```

## Elements of PBW-Algebras

Elements of PBW-algebras are stored and printed in their standard representation.

### Constructors

One way to create elements of a PBW-algebra `A`

over a field `K`

is to build them up from the generators of `A`

using basic arithmetic as shown below:

###### Examples

```
julia> R, (x,y,z) = QQ["x", "y", "z"];
julia> L = [x*y, x*z, y*z + 1];
julia> REL = strictly_upper_triangular_matrix(L);
julia> A, (x,y,z) = pbw_algebra(R, REL, deglex(gens(R)));
julia> f = 3*x^2+z*y
3*x^2 + y*z + 1
```

Alternatively, there is the following constructor:

`(A::PBWAlgRing)(cs::AbstractVector, es::AbstractVector{Vector{Int}})`

Its return value is the element of `A`

whose standard representation is built from the elements of `cs`

as coefficients, and the elements of `es`

as exponents.

###### Examples

```
julia> R, (x,y,z) = QQ["x", "y", "z"];
julia> L = [x*y, x*z, y*z + 1];
julia> REL = strictly_upper_triangular_matrix(L);
julia> A, (x,y,z) = pbw_algebra(R, REL, deglex(gens(R)));
julia> f = 3*x^2+z*y
3*x^2 + y*z + 1
julia> g = A(QQ.([3, 1, 1]), [[2, 0, 0], [0, 1, 1], [0, 0, 0]])
3*x^2 + y*z + 1
julia> f == g
true
```

An often more effective way to create elements is to use the corresponding build context as indicated below:

```
julia> R, (x,y,z) = QQ["x", "y", "z"];
julia> L = [x*y, x*z, y*z + 1];
julia> REL = strictly_upper_triangular_matrix(L);
julia> A, (x,y,z) = pbw_algebra(R, REL, deglex(gens(R)));
julia> B = build_ctx(A);
julia> for i = 1:5 push_term!(B, QQ(i), [i+1, i, i-1]) end
julia> finish(B)
5*x^6*y^5*z^4 + 4*x^5*y^4*z^3 + 3*x^4*y^3*z^2 + 2*x^3*y^2*z + x^2*y
```

### Special Elements

Given a PBW-algebra `A`

, `zero(A)`

and `one(A)`

refer to the additive and multiplicative identity of `A`

, respectively. Relevant test calls on an element `f`

of `A`

are `iszero(f)`

and `isone(f)`

.

### Data Associated to Elements of PBW-algebras

Given an element `f`

of a PBW-algebra `A`

,

`parent(f)`

refers to`A`

,

## Opposite Algebras

`opposite_algebra`

— Method`opposite_algebra(A::PBWAlgRing)`

Return the opposite algebra of `A`

.

**Examples**

```
julia> D, (x, y, dx, dy) = weyl_algebra(QQ, ["x", "y"])
(Weyl-algebra over Rational field in variables (x, y), PBWAlgElem{QQFieldElem, Singular.n_Q}[x, y, dx, dy])
julia> Dop, opp = opposite_algebra(D);
julia> Dop
PBW-algebra over Rational field in dy, dx, y, x with relations dx*dy = dy*dx, y*dy = dy*y + 1, x*dy = dy*x, y*dx = dx*y, x*dx = dx*x + 1, x*y = y*x
julia> opp
Map to opposite of Weyl-algebra over Rational field in variables (x, y)
julia> opp(dx*x)
dx*x + 1
```

If a map `opp`

from a PBW-algebra to its opposite algebra is given, then `inv(opp)`

refers to the inverse of `opp`

.