Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Make is_exterior_power (and friends) internal #3346

Merged
merged 4 commits into from
Feb 20, 2024
Merged

Make is_exterior_power (and friends) internal #3346

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
b19369b
Rename `is_exterior_power` to `is_exterior_power_with_data` (and frie…
lgoettgens Feb 9, 2024
aba773d
Revert "Rename `is_exterior_power` to `is_exterior_power_with_data` (…
lgoettgens Feb 16, 2024
75d299d
Make `is_exterior_power` internal
lgoettgens Feb 16, 2024
5b69bca
the same for similar functions
lgoettgens Feb 16, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 0 additions & 12 deletions experimental/LieAlgebras/docs/src/modules.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,15 +63,3 @@ tensor_power(::LieAlgebraModule{C}, ::Int) where {C<:FieldElem}
abstract_module(::LieAlgebra{C}, ::Int, ::Vector{<:MatElem{C}}, ::Vector{<:VarName}; ::Bool) where {C<:FieldElem}
abstract_module(::LieAlgebra{C}, ::Int, ::Matrix{SRow{C}}, ::Vector{<:VarName}; ::Bool) where {C<:FieldElem}
```

# Type-dependent getters

```@docs
is_standard_module(::LieAlgebraModule)
is_dual(::LieAlgebraModule)
is_direct_sum(::LieAlgebraModule)
is_tensor_product(::LieAlgebraModule)
is_exterior_power(::LieAlgebraModule)
is_symmetric_power(::LieAlgebraModule)
is_tensor_power(::LieAlgebraModule)
```
102 changes: 51 additions & 51 deletions experimental/LieAlgebras/src/LieAlgebraModule.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -155,12 +155,12 @@ function Base.show(io::IO, ::MIME"text/plain", V::LieAlgebraModule)
io = pretty(io)
println(io, _module_type_to_string(V))
println(io, Indent(), "of dimension $(dim(V))")
if is_dual(V)[1] ||
is_direct_sum(V)[1] ||
is_tensor_product(V)[1] ||
is_exterior_power(V)[1] ||
is_symmetric_power(V)[1] ||
is_tensor_power(V)[1]
if _is_dual(V)[1] ||
_is_direct_sum(V)[1] ||
_is_tensor_product(V)[1] ||
_is_exterior_power(V)[1] ||
_is_symmetric_power(V)[1] ||
_is_tensor_power(V)[1]
_show_inner(io, V)
end
print(io, Dedent())
Expand All @@ -169,38 +169,38 @@ function Base.show(io::IO, ::MIME"text/plain", V::LieAlgebraModule)
end

function _show_inner(io::IO, V::LieAlgebraModule)
if is_standard_module(V)
if _is_standard_module(V)
println(io, "standard module")
elseif ((fl, W) = is_dual(V); fl)
elseif ((fl, W) = _is_dual(V); fl)
println(io, "dual of ", Lowercase())
print(io, Indent())
_show_inner(io, W)
print(io, Dedent())
elseif ((fl, Ws) = is_direct_sum(V); fl)
elseif ((fl, Ws) = _is_direct_sum(V); fl)
println(io, "direct sum with direct summands")
print(io, Indent())
for W in Ws
_show_inner(io, W)
end
print(io, Dedent())
elseif ((fl, Ws) = is_tensor_product(V); fl)
elseif ((fl, Ws) = _is_tensor_product(V); fl)
println(io, "tensor product with tensor factors")
print(io, Indent())
for W in Ws
_show_inner(io, W)
end
print(io, Dedent())
elseif ((fl, W, k) = is_exterior_power(V); fl)
elseif ((fl, W, k) = _is_exterior_power(V); fl)
println(io, "$(ordinal_number_string(k)) exterior power of")
print(io, Indent())
_show_inner(io, W)
print(io, Dedent())
elseif ((fl, W, k) = is_symmetric_power(V); fl)
elseif ((fl, W, k) = _is_symmetric_power(V); fl)
println(io, "$(ordinal_number_string(k)) symmetric power of")
print(io, Indent())
_show_inner(io, W)
print(io, Dedent())
elseif ((fl, W, k) = is_tensor_power(V); fl)
elseif ((fl, W, k) = _is_tensor_power(V); fl)
println(io, "$(ordinal_number_string(k)) tensor power of")
print(io, Indent())
_show_inner(io, W)
Expand All @@ -221,19 +221,19 @@ function Base.show(io::IO, V::LieAlgebraModule)
end

function _module_type_to_string(V::LieAlgebraModule)
if is_standard_module(V)
if _is_standard_module(V)
return "Standard module"
elseif is_dual(V)[1]
elseif _is_dual(V)[1]
return "Dual module"
elseif is_direct_sum(V)[1]
elseif _is_direct_sum(V)[1]
return "Direct sum module"
elseif is_tensor_product(V)[1]
elseif _is_tensor_product(V)[1]
return "Tensor product module"
elseif is_exterior_power(V)[1]
elseif _is_exterior_power(V)[1]
return "Exterior power module"
elseif is_symmetric_power(V)[1]
elseif _is_symmetric_power(V)[1]
return "Symmetric power module"
elseif is_tensor_power(V)[1]
elseif _is_tensor_power(V)[1]
return "Tensor power module"
else
return "Abstract Lie algebra module"
Expand Down Expand Up @@ -354,24 +354,24 @@ function (V::LieAlgebraModule{C})(
) where {C<:FieldElem}
if length(a) == 1 && V === parent(a[1])
return a[1]
elseif ((fl, W) = is_dual(V); fl)
elseif ((fl, W) = _is_dual(V); fl)
@req length(a) == 1 "Invalid input length."
@req W === parent(v) "Incompatible modules."
return V(coefficients(v))
elseif ((fl, Vs) = is_direct_sum(V); fl)
elseif ((fl, Vs) = _is_direct_sum(V); fl)
@req length(a) == length(Vs) "Invalid input length."
@req all(i -> parent(a[i]) === Vs[i], 1:length(a)) "Incompatible modules."
return sum(inji(ai) for (ai, inji) in zip(a, canonical_injections(V)); init=zero(V))
elseif is_tensor_product(V)[1]
elseif _is_tensor_product(V)[1]
pure = get_attribute(V, :tensor_pure_function)
return pure(a)::elem_type(V)
elseif is_exterior_power(V)[1]
elseif _is_exterior_power(V)[1]
pure = get_attribute(V, :wedge_pure_function)
return pure(a)::elem_type(V)
elseif is_symmetric_power(V)[1]
elseif _is_symmetric_power(V)[1]
pure = get_attribute(V, :mult_pure_function)
return pure(a)::elem_type(V)
elseif is_tensor_power(V)[1]
elseif _is_tensor_power(V)[1]
pure = get_attribute(V, :tensor_pure_function)
return pure(a)::elem_type(V)
else
Expand All @@ -384,15 +384,15 @@ function (V::LieAlgebraModule{C})(a::LieAlgebraModuleElem{C}...) where {C<:Field
end

function _is_allowed_input_length(V::LieAlgebraModule, a::Int)
if ((fl, Vs) = is_direct_sum(V); fl)
if ((fl, Vs) = _is_direct_sum(V); fl)
return a == length(Vs)
elseif ((fl, Vs) = is_tensor_product(V); fl)
elseif ((fl, Vs) = _is_tensor_product(V); fl)
return a == length(Vs)
elseif ((fl, W, k) = is_exterior_power(V); fl)
elseif ((fl, W, k) = _is_exterior_power(V); fl)
return a == k
elseif ((fl, W, k) = is_symmetric_power(V); fl)
elseif ((fl, W, k) = _is_symmetric_power(V); fl)
return a == k
elseif ((fl, W, k) = is_tensor_power(V); fl)
elseif ((fl, W, k) = _is_tensor_power(V); fl)
return a == k
else
throw(ArgumentError("Invalid input."))
Expand Down Expand Up @@ -518,11 +518,11 @@ end
###############################################################################

@doc raw"""
is_standard_module(V::LieAlgebraModule{C}) -> Bool
_is_standard_module(V::LieAlgebraModule{C}) -> Bool

Check whether `V` has been constructed as a standard module.
"""
function is_standard_module(V::LieAlgebraModule)
function _is_standard_module(V::LieAlgebraModule)
if has_attribute(V, :is_standard_module)
@assert get_attribute(V, :is_standard_module)::Bool === true
return true
Expand All @@ -531,13 +531,13 @@ function is_standard_module(V::LieAlgebraModule)
end

@doc raw"""
is_dual(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}
_is_dual(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}

Check whether `V` has been constructed as a dual module.
If it has, return `true` and the base module.
If not, return `false` as the first return value, and an arbitrary value for the second.
"""
function is_dual(V::LieAlgebraModule)
function _is_dual(V::LieAlgebraModule)
if has_attribute(V, :is_dual)
W = get_attribute(V, :is_dual)::typeof(V)
return (true, W)
Expand All @@ -546,13 +546,13 @@ function is_dual(V::LieAlgebraModule)
end

@doc raw"""
is_direct_sum(V::LieAlgebraModule{C}) -> Bool, Vector{LieAlgebraModule{C}}
_is_direct_sum(V::LieAlgebraModule{C}) -> Bool, Vector{LieAlgebraModule{C}}

Check whether `V` has been constructed as a direct sum of modules.
If it has, return `true` and the summands.
If not, return `false` as the first return value, and an empty vector for the second.
"""
function is_direct_sum(V::LieAlgebraModule)
function _is_direct_sum(V::LieAlgebraModule)
if has_attribute(V, :is_direct_sum)
summands = get_attribute(V, :is_direct_sum)::Vector{typeof(V)}
return (true, summands)
Expand All @@ -561,13 +561,13 @@ function is_direct_sum(V::LieAlgebraModule)
end

@doc raw"""
is_tensor_product(V::LieAlgebraModule{C}) -> Bool, Vector{LieAlgebraModule{C}}
_is_tensor_product(V::LieAlgebraModule{C}) -> Bool, Vector{LieAlgebraModule{C}}

Check whether `V` has been constructed as a tensor product of modules.
If it has, return `true` and the tensor factors.
If not, return `false` as the first return value, and an empty vector for the second.
"""
function is_tensor_product(V::LieAlgebraModule)
function _is_tensor_product(V::LieAlgebraModule)
if has_attribute(V, :is_tensor_product)
factors = get_attribute(V, :is_tensor_product)::Vector{typeof(V)}
return (true, factors)
Expand All @@ -576,13 +576,13 @@ function is_tensor_product(V::LieAlgebraModule)
end

@doc raw"""
is_exterior_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int
_is_exterior_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int

Check whether `V` has been constructed as an exterior power of a module.
If it has, return `true`, the base module, and the power.
If not, return `false` as the first return value, and arbitrary values for the other two.
"""
function is_exterior_power(V::LieAlgebraModule)
function _is_exterior_power(V::LieAlgebraModule)
if has_attribute(V, :is_exterior_power)
W, k = get_attribute(V, :is_exterior_power)::Tuple{typeof(V),Int}
return (true, W, k)
Expand All @@ -591,13 +591,13 @@ function is_exterior_power(V::LieAlgebraModule)
end

@doc raw"""
is_symmetric_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int
_is_symmetric_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int

Check whether `V` has been constructed as an symmetric power of a module.
If it has, return `true`, the base module, and the power.
If not, return `false` as the first return value, and arbitrary values for the other two.
"""
function is_symmetric_power(V::LieAlgebraModule)
function _is_symmetric_power(V::LieAlgebraModule)
if has_attribute(V, :is_symmetric_power)
W, k = get_attribute(V, :is_symmetric_power)::Tuple{typeof(V),Int}
return (true, W, k)
Expand All @@ -606,13 +606,13 @@ function is_symmetric_power(V::LieAlgebraModule)
end

@doc raw"""
is_tensor_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int
_is_tensor_power(V::LieAlgebraModule{C}) -> Bool, LieAlgebraModule{C}, Int

Check whether `V` has been constructed as a tensor power of a module.
If it has, return `true`, the base module, and the power.
If not, return `false` as the first return value, and arbitrary values for the other two.
"""
function is_tensor_power(V::LieAlgebraModule)
function _is_tensor_power(V::LieAlgebraModule)
if has_attribute(V, :is_tensor_power)
W, k = get_attribute(V, :is_tensor_power)::Tuple{typeof(V),Int}
return (true, W, k)
Expand Down Expand Up @@ -797,7 +797,7 @@ function dual(V::LieAlgebraModule{C}; cached::Bool=true) where {C<:FieldElem}
-transpose(transformation_matrix(V, i))
end

s = if is_standard_module(V)
s = if _is_standard_module(V)
[Symbol("$(s)*") for s in symbols(V)]
else
[Symbol("($(s))*") for s in symbols(V)]
Expand Down Expand Up @@ -855,7 +855,7 @@ function direct_sum(V::LieAlgebraModule{C}, Vs::LieAlgebraModule{C}...) where {C
else
[
Symbol("$s^($j)") for (j, Vj) in enumerate(Vs) for
s in (is_standard_module(Vj) ? symbols(Vj) : (x -> "($x)").(symbols(Vj)))
s in (_is_standard_module(Vj) ? symbols(Vj) : (x -> "($x)").(symbols(Vj)))
]
end

Expand Down Expand Up @@ -926,7 +926,7 @@ function tensor_product(
Symbol(join(s, (is_unicode_allowed() ? "⊗" : "(x)"))) for s in
reverse.(
ProductIterator([
is_standard_module(Vi) ? symbols(Vi) : (x -> "($x)").(symbols(Vi)) for
_is_standard_module(Vi) ? symbols(Vi) : (x -> "($x)").(symbols(Vi)) for
Vi in reverse(Vs)
])
)
Expand Down Expand Up @@ -1049,7 +1049,7 @@ function exterior_power(
[Symbol("1")]
elseif k == 1
symbols(V)
elseif is_standard_module(V)
elseif _is_standard_module(V)
[Symbol(join(s, (is_unicode_allowed() ? "∧" : "^"))) for s in combinations(symbols(V), k)]
else
[
Expand Down Expand Up @@ -1185,7 +1185,7 @@ function symmetric_power(
[Symbol("1")]
elseif k == 1
symbols(V)
elseif is_standard_module(V)
elseif _is_standard_module(V)
[
Symbol(
join(
Expand Down Expand Up @@ -1336,7 +1336,7 @@ function tensor_power(
[Symbol("1")]
elseif k == 1
symbols(V)
elseif is_standard_module(V)
elseif _is_standard_module(V)
[
Symbol(join(s, (is_unicode_allowed() ? "⊗" : "(x)"))) for
s in reverse.(ProductIterator(symbols(V), k))
Expand Down
Loading
Loading