refactor: make import and export explicit (#251)

* move all import into QuantumCumulants.jl file

* check_all_explicit_imports_via_owners

* fix SQA import list

* fix tests

* idmergeable method in docs example to use SQA

* enable tests again

Author: oameye

Project.toml

@@ -9,8 +9,8 @@ Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
+OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 QuantumOpticsBase = "4f57444f-1401-5e15-980d-4471b28d5678"
-Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SecondQuantizedAlgebra = "f7aa4685-e143-4cb6-a7f3-073579757907"
 SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b"
@@ -29,10 +29,10 @@ LinearAlgebra = "1.10"
 MacroTools = "0.5"
 ModelingToolkit = "~9.70"
 OrdinaryDiffEq = "6"
+OrderedCollections = "1.8"
 QuantumOptics = "1"
 QuantumOpticsBase = "0.4, 0.5"
 Random = "1.10"
-Reexport = "1"
 SciMLBase = "1, 2"
 SecondQuantizedAlgebra = "0.3.1"
 SteadyStateDiffEq = "2"

docs/src/implementation.md

@@ -404,7 +404,8 @@ Symbolics.jl. More fields could be added, but the four shown here are always req
 Now, for methods we simply need:
 
 ```@example custom-operators
-QuantumCumulants.ismergeable(::Position,::Momentum) = true
+using SecondQuantizedAlgebra
+SecondQuantizedAlgebra.ismergeable(::Position,::Momentum) = true
 Base.:*(x::Position, p::Momentum) = im + p*x
 Base.isequal(a::Position, b::Position) = isequal(a.hilbert, b.hilbert) && isequal(a.name, b.name) && isequal(a.aon, b.aon)
 Base.isequal(a::Momentum, b::Momentum) = isequal(a.hilbert, b.hilbert) && isequal(a.name, b.name) && isequal(a.aon, b.aon)

src/QuantumCumulants.jl

@@ -1,65 +1,106 @@
 module QuantumCumulants
 
-import SymbolicUtils
-import SymbolicUtils: substitute, BasicSymbolic, operation, arguments, iscall
+using Latexify: Latexify, @latexrecipe, latexify
+using MacroTools: MacroTools
+using LaTeXStrings: LaTeXStrings, latexstring, @L_str
 
-import Symbolics
-import TermInterface
+using Combinatorics: partitions
+using LinearAlgebra: LinearAlgebra
+using OrderedCollections: OrderedCollections
 
-import SciMLBase
+using SciMLBase: SciMLBase
+using QuantumOpticsBase: QuantumOpticsBase
 
-import ModelingToolkit
-import ModelingToolkit: complete, complete!
-const MTK = ModelingToolkit
-
-using Combinatorics: partitions, combinations, levicivita
-using LinearAlgebra
+using SymbolicUtils: SymbolicUtils, substitute, BasicSymbolic, operation, arguments, iscall
 
-using QuantumOpticsBase
-import QuantumOpticsBase: ⊗, tensor
+using Symbolics: Symbolics
+using TermInterface: TermInterface
 
+using ModelingToolkit: ModelingToolkit, complete, complete!
+const MTK = ModelingToolkit
 
-using Reexport
-@reexport using SecondQuantizedAlgebra
 using SecondQuantizedAlgebra:
+    SecondQuantizedAlgebra,
+    QTerm,
+    QSym,
+    CNumber,
+    Average,
     QNumber,
-    SNuN,
     QMul,
     QAdd,
+    SpecialIndexedTerm,
+    IndexedOperator,
     ClusterAon,
     CallableTransition,
-    IndexInt,
+    NumberedOperator,
+    Parameter,
+    ProductSpace,
+    FockSpace,
+    Destroy,
+    Create,
+    Index,
+    SingleSum,
+    DoubleSum,
+    Transition,
+    NLevelSpace,
     get_indices,
     commutator,
-    numeric_average,
     _conj,
     _adjoint,
     get_i,
     hilbert,
     inorder!,
     levels,
     has_cluster,
-    ismergeable,
-    inadjoint,
     undo_average,
     _average,
     sym_average,
     IndexedVariable,
     DoubleIndexedVariable,
     SpecialIndexedAverage,
-    IndexedAverageSum,
     _inconj,
     DoubleNumberedVariable,
     SingleNumberedVariable,
     create_index_arrays,
-    IndexedAverageDoubleSum,
-    getIndName,
     _to_expression,
     AvgSums,
-    get_numbers
-const SQA = SecondQuantizedAlgebra
+    get_numbers,
+    @cnumbers,
+    @qnumbers,
+    @rnumbers,
+    ClusterSpace,
+    HilbertSpace,
+    Pauli,
+    PauliSpace,
+    SpinSpace,
+    RNumber,
+    RealParameter,
+    Spin,
+    cnumber,
+    cnumbers,
+    find_operators,
+    fundamental_operators,
+    insert_index,
+    order_by_index,
+    reorder,
+    rnumber,
+    rnumbers,
+    to_numeric,
+    transition_superscript,
+    unique_ops,
+    unique_ops!,
+    Σ,
+    ∑,
+    ⊗,
+    tensor,
+    acts_on,
+    average,
+    change_index,
+    numeric_average,
+    IndexedAverageSum,
+    IndexedAverageDoubleSum
 
-import Base: *, +, -
+const SQA = SecondQuantizedAlgebra
 
 export HilbertSpace,
     ProductSpace,
@@ -91,6 +132,8 @@ export HilbertSpace,
     @rnumbers,
     rnumbers,
     rnumber,
+    Average,
+    average,
     cumulant_expansion,
     get_order,
     cumulant,
@@ -145,11 +188,7 @@ export HilbertSpace,
     insert_index,
     eval_term,
     MeanfieldNoiseEquations,
-    IndexedMeanfieldNoiseEquations#, indexed_arithmetic, indexed_noise, simplified_indexed_complete!
-
-
-source_metadata(source, name) =
-    Base.ImmutableDict{DataType,Any}(Symbolics.VariableSource, (source, name))
+    IndexedMeanfieldNoiseEquations
 
 
 include("equations.jl")

src/correlation.jl

@@ -40,7 +40,7 @@ function CorrelationFunction(
 )
     if iv === nothing
         iv_ = SymbolicUtils.Sym{Real}(:τ)
-        iv_ = SymbolicUtils.setmetadata(iv_, MTK.VariableSource, (:parameters, :τ))
+        iv_ = SymbolicUtils.setmetadata(iv_, Symbolics.VariableSource, (:parameters, :τ))
         iv_ = SymbolicUtils.setmetadata(iv_, MTK.MTKVariableTypeCtx, MTK.PARAMETER)
     else
         iv_ = iv
@@ -383,7 +383,7 @@ function MTK.ODESystem(c::CorrelationFunction; complete_sys = true, kwargs...)
     return complete_sys ? complete(sys) : sys
 end
 
-substitute(c::CorrelationFunction, args...; kwargs...) = CorrelationFunction(
+SymbolicUtils.substitute(c::CorrelationFunction, args...; kwargs...) = CorrelationFunction(
     c.op1,
     c.op2,
     substitute(c.de0, args...; kwargs...),
@@ -619,7 +619,7 @@ function _substitute_vars(t::T) where {T<:SymbolicUtils.Symbolic}
             )
         else
             args = [_substitute_vars(arg) for arg ∈ SymbolicUtils.arguments(t)]
-            return SymbolicUtils.maketerm(T, f, args, TermInterface.metadata(t))
+            return TermInterface.maketerm(T, f, args, TermInterface.metadata(t))
         end
     else
         return t

src/cumulant_expansion.jl

@@ -205,19 +205,19 @@ function _cumulant_expansion(x::IndexedAverageDoubleSum, order; kwargs...)
 end
 function _cumulant_expansion(a::BasicSymbolic{IndexedAverageSum}, order; kwargs...)
     if SymbolicUtils.hasmetadata(a, IndexedAverageSum)
-        meta = SymbolicUtils.metadata(a)[IndexedAverageSum]
+        meta = TermInterface.metadata(a)[IndexedAverageSum]
         return _cumulant_expansion(meta, order; kwargs...)
     end
 end
 function _cumulant_expansion(a::BasicSymbolic{IndexedAverageDoubleSum}, order; kwargs...)
     if SymbolicUtils.hasmetadata(a, IndexedAverageDoubleSum)
-        meta = SymbolicUtils.metadata(a)[IndexedAverageDoubleSum]
+        meta = TermInterface.metadata(a)[IndexedAverageDoubleSum]
         return _cumulant_expansion(meta, order; kwargs...)
     end
 end
 function _cumulant_expansion(a::BasicSymbolic{SpecialIndexedAverage}, order; kwargs...)
     if SymbolicUtils.hasmetadata(a, SpecialIndexedAverage)
-        meta = SymbolicUtils.metadata(a)[SpecialIndexedAverage]
+        meta = TermInterface.metadata(a)[SpecialIndexedAverage]
         return SpecialIndexedAverage(
             cumulant_expansion(meta.term, order; kwargs...),
             meta.indexMapping,
@@ -328,19 +328,19 @@ get_order(a::IndexedAverageDoubleSum) = get_order(a.innerSum)
 get_order(a::SpecialIndexedAverage) = get_order(a.term)
 function get_order(a::BasicSymbolic{IndexedAverageSum})
     if SymbolicUtils.hasmetadata(a, IndexedAverageSum)
-        meta = SymbolicUtils.metadata(a)[IndexedAverageSum]
+        meta = TermInterface.metadata(a)[IndexedAverageSum]
         return get_order(meta)
     end
 end
 function get_order(a::BasicSymbolic{IndexedAverageDoubleSum})
     if SymbolicUtils.hasmetadata(a, IndexedAverageDoubleSum)
-        meta = SymbolicUtils.metadata(a)[IndexedAverageDoubleSum]
+        meta = TermInterface.metadata(a)[IndexedAverageDoubleSum]
         return get_order(meta)
     end
 end
 function get_order(a::BasicSymbolic{SpecialIndexedAverage})
     if SymbolicUtils.hasmetadata(a, SpecialIndexedAverage)
-        meta = SymbolicUtils.metadata(a)[SpecialIndexedAverage]
+        meta = TermInterface.metadata(a)[SpecialIndexedAverage]
         return get_order(meta)
     end
 end

src/diffeq.jl

@@ -46,7 +46,7 @@ function substitute_conj(t::T, vs′, vs′hash) where {T}
         else
             _f = x->substitute_conj(x, vs′, vs′hash)
             args = map(_f, SymbolicUtils.arguments(t))
-            return SymbolicUtils.maketerm(
+            return TermInterface.maketerm(
                 T,
                 SymbolicUtils.operation(t),
                 args,
@@ -128,7 +128,7 @@ function substitute_conj_ind(t::T, vs′, vs′hash) where {T}
             _f = x->substitute_conj_ind(x, vs′, vs′hash)
             args = map(_f, SymbolicUtils.arguments(t))
             f = SymbolicUtils.operation(t)
-            return SymbolicUtils.maketerm(T, f, args, TermInterface.metadata(t))
+            return TermInterface.maketerm(T, f, args, TermInterface.metadata(t))
         end
     else
         return t

src/equations.jl

@@ -131,14 +131,14 @@ function _append!(de::T, me::T) where {T<:AbstractMeanfieldEquations}
 end
 
 # Substitution
-function substitute(de::T, dict) where {T<:AbstractMeanfieldEquations}
+function SymbolicUtils.substitute(de::T, dict) where {T<:AbstractMeanfieldEquations}
     eqs = [substitute(eq, dict) for eq ∈ de.equations]
     states = getfield.(eqs, :lhs)
     fields = [getfield(de, s) for s ∈ fieldnames(T)[4:end]]
     return T(eqs, de.operator_equations, states, fields...)
 end
 
-function substitute(de::IndexedMeanfieldEquations, dict)
+function SymbolicUtils.substitute(de::IndexedMeanfieldEquations, dict)
     eqs = [
         Symbolics.Equation(
             inorder!(substitute(eq.lhs, dict)),
@@ -190,6 +190,9 @@ function make_var(v, t)
     return SymbolicUtils.Term{Complex}(var_f, [t]; metadata = d)
 end
 
+source_metadata(source, name) =
+    Base.ImmutableDict{DataType,Any}(Symbolics.VariableSource, (source, name))
+
 function make_varmap(vs, t)
     varmap = Pair{Any,Any}[]
     add_vars!(varmap, vs, t)

src/index_average.jl

@@ -212,7 +212,7 @@ function eval_term(
     h = nothing,
     kwargs...,
 )
-    meta = SymbolicUtils.metadata(sum_)[IndexedAverageSum]
+    meta = TermInterface.metadata(sum_)[IndexedAverageSum]
     if !=(h, nothing)
         if !(h isa Vector)
             h = [h]
@@ -261,7 +261,7 @@ function eval_term(
     return sum(adds)
 end
 function eval_term(sum::BasicSymbolic{IndexedAverageDoubleSum}; kwargs...)
-    meta = SymbolicUtils.metadata(sum)[IndexedAverageDoubleSum]
+    meta = TermInterface.metadata(sum)[IndexedAverageDoubleSum]
     return eval_term(
         IndexedAverageDoubleSum(
             eval_term(meta.innerSum; kwargs...),
@@ -342,7 +342,7 @@ function create_value_map(
     limits = Dict{BasicSymbolic,Int64}(),
     kwargs...,
 )
-    iVar = SymbolicUtils.metadata(sym)[IndexedVariable]
+    iVar = TermInterface.metadata(sym)[IndexedVariable]
     if iVar.ind.range isa SymbolicUtils.BasicSymbolic
         if iVar.ind.range in keys(limits)
             range1 = limits[iVar.ind.range]
@@ -367,7 +367,7 @@ function create_value_map(
     limits = Dict{BasicSymbolic,Int64}(),
     kwargs...,
 )
-    iVar = SymbolicUtils.metadata(sym)[IndexedVariable]
+    iVar = TermInterface.metadata(sym)[IndexedVariable]
     dict = Dict{BasicSymbolic,ComplexF64}()
     if iVar.ind.range isa SymbolicUtils.BasicSymbolic
         if iVar.ind.range in keys(limits)
@@ -390,7 +390,7 @@ function create_value_map(
     kwargs...,
 )
     dict = Dict{BasicSymbolic,ComplexF64}()
-    var = SymbolicUtils.metadata(sym)[DoubleIndexedVariable]
+    var = TermInterface.metadata(sym)[DoubleIndexedVariable]
     if var.ind1.range isa SymbolicUtils.BasicSymbolic
         if var.ind1.range in keys(limits)
             range1 = limits[var.ind1.range]
@@ -436,11 +436,11 @@ containsIndex(term::Average, ind::Index) = ind ∈ get_indices(term)
 # TODO: only used in tests, remove?
 
 getAvrgs(sum::BasicSymbolic{SpecialIndexedAverage}) =
-    getAvrgs(SymbolicUtils.metadata(sum)[SpecialIndexedAverage].term)
+    getAvrgs(TermInterface.metadata(sum)[SpecialIndexedAverage].term)
 getAvrgs(sum::BasicSymbolic{IndexedAverageSum}) =
-    getAvrgs(SymbolicUtils.metadata(sum)[IndexedAverageSum].term)
+    getAvrgs(TermInterface.metadata(sum)[IndexedAverageSum].term)
 getAvrgs(Dsum::BasicSymbolic{IndexedAverageDoubleSum}) =
-    getAvrgs(SymbolicUtils.metadata(Dsum)[IndexedAverageDoubleSum].innerSum)
+    getAvrgs(TermInterface.metadata(Dsum)[IndexedAverageDoubleSum].innerSum)
 function getAvrgs(term::BasicSymbolic{<:CNumber})
     if iscall(term)
         return vcat(