Normal Order for bosonic operators and related simplification tools

[Krastanov]

QuantumSymbolics.jl can represent bosonic creation and annihilation operators, their products and tensor products:

julia> using SymbolicUtils, QuantumSymbolics

julia> (Create*Create*Destroy)⊗(Destroy*Create)
a†a†a⊗aa†

julia> (Create*Create*Destroy)⊗(Destroy*Create) |> typeof
STensorOperator (alias for QuantumSymbolics.STensor{QuantumInterface.AbstractOperator})

julia> (Create*Create*Destroy)⊗(Destroy*Create) |> arguments
2-element Vector{Any}:
 a†a†a
 aa†

julia> (Create*Create*Destroy)⊗(Destroy*Create) |> arguments .|> typeof
2-element Vector{DataType}:
 SMulOperator
 SMulOperator

julia> (Create*Create*Destroy)⊗(Destroy*Create) |> arguments .|> arguments
2-element Vector{Vector{Any}}:
 [a†, a†, a]
 [a, a†]

It can also run simplification/canonicalization rules:

julia> qsimplify_fock(Destroy*CoherentState(0.5))
0.5|0.5⟩

This bounty is about implementing a "Normal Form" canonicalization for products of bosonic creation and annihilation operators

The Normal Form is an important canonical way to write products of creation and annihilation operators. To implement it in QuantumSymbolics, one would need to have:

• an internal function that with high performance gives the normalized representation, potentially using more efficient internal representation; that internal function can assume it is always given a product of creation and annihilation operators
• a public function that does the chores related to detecting products of creation and annihilation operators in arbitrary expressions and then calling the internal function only on the appropriate subexpression

In the end, the following should work:

normal_form( 3.5*(some_operator*a*a'*a*a')⊗(a*a') + a_constant*other_operator⊗another_operator ) giving a new expression in which all subexpressions which were products of creation and annihilation operators are now in normal form.

The most useful references would be:

• the overall documentation of QuantumSymbolics
• normal form on wikipedia
• a julia library specifically on normal forms of operator products -- QuantumAlgebra.jl
• existing simplification rules in QuantumSymbolics.jl
• the documentation for the underlying SymbolicUtils.jl

For this bounty to be completed, one would need:

• implementation of the aforementioned functions
• documentation
• tests, potentially against other existing libraries (e.g. QuantumAlgebra.jl)

If you are new to julia, make sure to:

• install julia using juliaup for version management
• look through the julia manual and modern workflows
• try out VSCode with the Julia plugin for good IDE support