feat(properties): add property implications

Author: mfasi

src/matrices/companion.jl

@@ -36,7 +36,7 @@ Companion{T}(n::Integer) where {T<:Number} = Companion(T[1:n;])
 Companion{T}(polynomial::Polynomial) where {T<:Number} = Companion(T.(-polynomial.coeffs[end-1:-1:begin] ./ polynomial.coeffs[end]))
 
 # metadata
-@properties Companion Symbol[]
+@properties Companion Property[]
 
 # properties
 size(A::Companion) = (A.n, A.n)

src/metadata.jl

@@ -17,6 +17,7 @@ const PROPERTIES = Dict{Type{<:PropertyTypes.AbstractProperty},Property}(
         PropertyTypes.FixedSize => :fixedsize,
         PropertyTypes.Graph => :graph,
         PropertyTypes.Hankel => :hankel,
+        PropertyTypes.Hermitian => :hermitian,
         PropertyTypes.Hessenberg => :hessenberg,
         PropertyTypes.IllConditioned => :illcond,
         PropertyTypes.Indefinite => :indefinite,
@@ -30,6 +31,7 @@ const PROPERTIES = Dict{Type{<:PropertyTypes.AbstractProperty},Property}(
         PropertyTypes.Orthogonal => :orthogonal,
         PropertyTypes.Positive => :positive,
         PropertyTypes.PositiveDefinite => :posdef,
+        PropertyTypes.PositiveSemidefinite => :possemidef,
         PropertyTypes.Random => :random,
         PropertyTypes.RankDeficient => :rankdef,
         PropertyTypes.Rectangular => :rectangular,
@@ -42,10 +44,73 @@ const PROPERTIES = Dict{Type{<:PropertyTypes.AbstractProperty},Property}(
         PropertyTypes.TotallyPositive => :totpos,
         PropertyTypes.Triangular => :triangular,
         PropertyTypes.Tridiagonal => :tridiagonal,
-        PropertyTypes.Unimodular => :unimodular
+        PropertyTypes.Unimodular => :unimodular,
+        PropertyTypes.Unitary => :unitary
     )
 )
 
+# Handle property implications
+struct PropertyImplication
+    ifPresent::Set{Property}
+    ifAbsent::Set{Property}
+    thenAdd::Set{Property}
+end
+
+const IMPLICATIONS = [
+    PropertyImplication(Set(Property(present)), Set(Property(absent)), Set(Property(toAdd)))
+        for (present::Vector{Symbol}, absent::Vector{Symbol}, toAdd::Vector{Symbol}) in [
+            ([:bidiagonal], [], [:hessenberg, :sparse, :triangular, :tridiagonal]),
+            ([:circulant], [], [:toeplitz, :eigen]),
+            ([:complex], [], [:normal]),
+            ([:correlation], [], [:symmetric, :possemidef]),
+            ([:diagdom], [], [:posdef]),
+            ([:hankel], [], [:symmetric]),
+            ([:hermitian], [], [:normal]),
+            ([:infdiv], [], [:possemidef]),
+            ([:involutory], [], [:inverse]),
+            ([:involutory, :symmetric], [], [:orthofonal]),
+            ([:involutory, :normal], [:complex], [:symmetric, :orthogonal]),
+            ([:involutory, :normal, :complex], [], [:hermitian, :unitary]),
+            ([:orthogonal], [:complex], [:unitary]),
+            ([:positive], [], [:nonneg]),
+            ([:posdef], [], [:possemidef]),
+            ([:posdef], [:complex], [:symmetric]),
+            ([:posdef], [:complex], [:hermitian]),
+            ([:symmetric], [], [:normal]),
+            ([:symmetric], [:complex], [:hermitian]),
+            ([:TotallyNonnegative], [], [:nonneg]),
+            ([:TotallyNonnegative, :hermitian], [], [:possemidef]),
+            ([:totallyPositive], [], [:positive]),
+            ([:totallyPositive, :hermitian], [], [:posdef]),
+            ([:tridiagonal], [], [:hessenberg]),
+            ([:unimodular], [], [:integer]),
+            ([:unitary], [:complex], [:symmetric])
+    ]
+]
+
+"""
+    add_implied_properties(properties::Set{Symbol})
+
+Add implied properties to a set of properties.
+
+# Examples
+```julia-repl
+julia> add_implied_properties(Set([:posdef]))
+"""
+function add_implied_properties!(properties::Vector{Property})
+    changed = true
+    while changed
+        changed = false
+        for imp in IMPLICATIONS
+            if imp.ifPresent ⊆ properties && isempty(imp.ifAbsent ∩ properties) && !(imp.thenAdd ⊆ properties)
+                    append!(properties, setdiff(imp.thenAdd, properties))
+                    changed = true
+            end
+        end
+    end
+    return properties
+end
+
 """
     list_properties()
 
@@ -154,6 +219,7 @@ julia> register_properties(Matrix, [PropertyTypes.Symmetric(), PropertyTypes.Inv
 function register_properties(T::Type, props::Vector{Property})
     # check props
     check_properties_exist(props...)
+    add_implied_properties!(props)
 
     # register properties
     @eval properties(::Type{<:$T}) = $props

src/types.jl

@@ -66,6 +66,10 @@ The matrix is a Hankel matrix.
 """
 struct Hankel <: AbstractProperty end
 """
+The matrix is Hermitian.
+"""
+struct Hermitian <: AbstractProperty end
+"""
 The matrix is an upper or lower Hessenberg matrix.
 """
 struct Hessenberg <: AbstractProperty end
@@ -118,6 +122,10 @@ The matrix is positive definite for some parameter values.
 """
 struct PositiveDefinite <: AbstractProperty end
 """
+The matrix is positive semidefinite for some parameter values.
+"""
+struct PositiveSemidefinite <: AbstractProperty end
+"""
 The matrix has random entries.
 """
 struct Random <: AbstractProperty end
@@ -169,6 +177,10 @@ struct TotallyPositive <: AbstractProperty end
 The matrix is unimodular for some parameter values.
 """
 struct Unimodular <: AbstractProperty end
+"""
+The matrix is unitary for some parameter values.
+"""
+struct Unitary <: AbstractProperty end
 end
 
 """
@@ -181,6 +193,12 @@ See also [`list_properties`](@ref), [`@properties`](@ref), [`properties`](@ref).
 struct Property
     name::Symbol
 end
+# The alternative solution
+#   Property(symbols::Symbols...) = [Property(symbol) for symbol in symbols]
+#   Property(symbols::Vector{Symbol}) = Property(symbols...)
+# is not type stable for vectors of length 1.
+Property(symbols::Symbol...) = [Property(symbol) for symbol in symbols]
+Property(symbols::Vector{Symbol}) = [Property(symbol) for symbol in symbols]
 
 """
     Group

test/metadata.jl

@@ -38,9 +38,12 @@ props = list_properties()
     @properties Matrix Property[]
 
     # properties
+    @test Property([:symmetric]) == [Property(:symmetric)]
+    @test Property(:symmetric, :inverse) == [Property(:symmetric), Property(:inverse)]
     @test properties(AbstractMatrix) == []
-    @properties Matrix [:symmetric, :inverse]
-    @test properties(Matrix) == [Property(:symmetric), Property(:inverse)]
-    @test properties(Matrix(ones(1, 1))) == [Property(:symmetric), Property(:inverse)]
+    @properties Matrix [:posdef, :inverse]
+    implied_properties = Set([Property(:posdef), Property(:possemidef), Property(:symmetric), Property(:hermitian), Property(:normal), Property(:inverse)])
+    @test Set(properties(Matrix)) == implied_properties
+    @test Set(properties(Matrix(ones(1, 1)))) == implied_properties
     @properties Matrix Property[]
 end