:0
[52] Diagonal
@ ~/.julia/juliaup/julia-1.10.10+0.aarch64.apple.darwin14/share/julia/stdlib/v1.10/LinearAlgebra/src/diagonal.jl:10 [inlined]
[53] Diagonal
@ ~/.julia/juliaup/julia-1.10.10+0.aarch64.apple.darwin14/share/julia/stdlib/v1.10/LinearAlgebra/src/diagonal.jl:14 [inlined]
[54] f
@ ~/Code/optimal_phase_transformation/post.jl:4 [inlined]
[55] call_with_reactant(::typeof(f), ::Reactant.TracedRArray{Float64, 2}, ::Reactant.TracedRArray{Float64, 1})
@ Reactant ~/.julia/packages/Reactant/TF3tW/src/utils.jl:0
[56] make_mlir_fn(f::typeof(f), args::Tuple{…}, kwargs::@NamedTuple{}, name::String, concretein::Bool; toscalar::Bool, return_dialect::Symbol, args_in_result::Symbol, construct_function_without_args::Bool, do_transpose::Bool, within_autodiff::Bool, input_shardings::Nothing, output_shardings::Nothing, runtime::Val{…}, verify_arg_names::Nothing, argprefix::Symbol, resprefix::Symbol, resargprefix::Symbol, num_replicas::Int64, optimize_then_pad::Bool)
@ Reactant.TracedUtils ~/.julia/packages/Reactant/TF3tW/src/TracedUtils.jl:348
[57] make_mlir_fn
@ ~/.julia/packages/Reactant/TF3tW/src/TracedUtils.jl:277 [inlined]
[58] compile_mlir!(mod::Reactant.MLIR.IR.Module, f::typeof(f), args::Tuple{…}, compile_options::CompileOptions, callcache::Dict{…}, sdycache::Dict{…}, sdygroupidcache::Tuple{…}; fn_kwargs::@NamedTuple{}, backend::String, runtime::Val{…}, legalize_stablehlo_to_mhlo::Bool, client::Reactant.XLA.PJRT.Client, kwargs::@Kwargs{})
@ Reactant.Compiler ~/.julia/packages/Reactant/TF3tW/src/Compiler.jl:1734
[59] compile_mlir!
@ ~/.julia/packages/Reactant/TF3tW/src/Compiler.jl:1696 [inlined]
[60] compile_xla(f::Function, args::Tuple{…}; before_xla_optimizations::Bool, client::Nothing, serializable::Bool, kwargs::@Kwargs{…})
@ Reactant.Compiler ~/.julia/packages/Reactant/TF3tW/src/Compiler.jl:3691
[61] compile_xla
@ ~/.julia/packages/Reactant/TF3tW/src/Compiler.jl:3663 [inlined]
[62] compile(f::Function, args::Tuple{…}; kwargs::@Kwargs{…})
@ Reactant.Compiler ~/.julia/packages/Reactant/TF3tW/src/Compiler.jl:3767
Some type information was truncated. Use `show(err)` to see complete types.
```
Thanks for taking your time to look into it!
---
### Author:  [@mofeing](https://discourse.julialang.org/u/mofeing)
#### Post date: [January 15, 2026, 5:32pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/4 "2026-01-15T17:32:54Z")
It’s not what I thought. Mind opening another issue for this?
---
### Author:  [@wsmoses](https://discourse.julialang.org/u/wsmoses)
#### Post date: [January 15, 2026, 5:46pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/5 "2026-01-15T17:46:50Z")
cc @avikpal presumably this can just call our symm/etc mul ops directly [and we should add an overload?]
---
### Author:  [@avikpal](https://discourse.julialang.org/u/avikpal)
#### Post date: [January 15, 2026, 5:50pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/6 "2026-01-15T17:50:27Z")
> You should use `LinearAlgebra.Symmetric` on `F` then.
`F` is captured in the IR itself, so we shouldn’t need a manual Symmetric annotation. That said we should add a pattern that optimizes `eigvals(x)` where x is proven symmetric
---
### Author:  [@mofeing](https://discourse.julialang.org/u/mofeing)
#### Post date: [January 15, 2026, 5:57pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/7 "2026-01-15T17:57:31Z")
> That said we should add a pattern that optimizes `eigvals(x)` where x is proven symmetric
mmm now that I remember, eigendecomposition already assumes that the matrix is Hermitian or symmetric. if not, you will end up with left- and right-eigenvectors but same eigenvalues. `eigvals` doesn’t need an optimization.
a possible optimization, but that it can be too niche, is that if we prove that `x` matrix is Hermitian/Symmetric and we call `inv` on the eigenvectors, then the `inv` can be replaced for `transpose` (or `det = 1`, because eigenvectors then form a unitary matrix).
---
### Author:  [@marcsgil](https://discourse.julialang.org/u/marcsgil)
#### Post date: [January 15, 2026, 8:09pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/8 "2026-01-15T20:09:25Z")
[Here it is](https://github.com/EnzymeAD/Reactant.jl/issues/2130). Weirdly, I only get the error when multiplying three matrices at the same line. If I store the intermediate result, it runs fine.
---
### Author:  [@stevengj](https://discourse.julialang.org/u/stevengj)
#### Post date: [January 15, 2026, 8:27pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/9 "2026-01-15T20:27:57Z")
> [@marcsgil](#):
>
> ```julia-auto
> function f(A, diag_entries)
> D = diagm(diag_entries)
> F = A' * D * A
> sum(inv, eigvals(F))
> end
>
> ```
Note that this function is mathematically the same as the trace of the inverse.
```julia-auto
trinv(A, d) = tr(inv(Hermitian(A' * Diagonal(d) * A)))
```
which is more efficient than using eigenvalues — it is about 10x faster for a 1000x1000 matrix on my machine. It should also be easier to differentiate.
```julia-auto
julia> A = rand(5,5); d = rand(5);
julia> f(A, d)
557.778533254039
julia> trinv(A, d)
557.7785332540502
```
If the `diag_entries` are nonnegative, so that you know `F` is positive-definite (assuming it is invertible), I would instead use the Cholesky factorization to be a bit faster still:
```julia-auto
trinv_posdef(A, d) = tr(inv(cholesky(Hermitian(A' * Diagonal(d) * A))))
```
---
### Author:  [@mofeing](https://discourse.julialang.org/u/mofeing)
#### Post date: [January 15, 2026, 9:52pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/10 "2026-01-15T21:52:31Z")
right. actually, there are several optimizations we can make and use this as a test of such optimizations.
---
### Author:  [@stevengj](https://discourse.julialang.org/u/stevengj)
#### Post date: [January 25, 2026, 8:15pm UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/11 "2026-01-25T20:15:32Z")
> [@stevengj](#):
>
> Note that this function is mathematically the same as the trace of the inverse […] It should also be easier to differentiate.
I assigned the “manual” differentiation of this function, with respect to either the matrix A or the diagonal entries, as a homework problem in our [matrix calculus](https://github.com/mitmath/matrixcalc/) course — see the [solutions for problems 5.3 and 5.5](https://github.com/mitmath/matrixcalc/blob/13ab4edb657f9ad2b504b9a59831f77b58ca6f04/psets/pset1sol.pdf). Not surprisingly, you can compute the gradient quite efficiently along with the function.
For example, to compute the function and its gradient with respect to d, assuming that d has positive entries, you could do:
```julia-auto
function trinv_grad(A, d)
B = inv(cholesky(Hermitian(A' * Diagonal(d) * A)))
trinv = tr(B)
C = B * A'
∇trinv = map(c -> -(c'c), eachcol(C)) # equivalent to -diag(C'C), but faster
return trinv, ∇trinv
end
```
It would be interesting to know how AD applied to `tr(inv(cholesky(Hermitian(A' * Diagonal(d) * A))))` compares (i.e. how much of this structure it exploits). (Right now, both Zygote.jl and Enzyme.jl fail on this function. For `tr(inv(A' * Diagonal(d) * A))`, Enzyme fails while Zygote succeeds but is ≈ 2.5× slower than my hand-rolled version for 1000×1000, single-threaded.)
(Julia discourse is my favorite source of homework problems.)
---
### Author:  [@wsmoses](https://discourse.julialang.org/u/wsmoses)
#### Post date: [January 26, 2026, 2:49am UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/12 "2026-01-26T02:49:27Z")
@stevengj to pre-empt a potential misunderstanding (and also out of personal curiosity), was there a particualrly interesting reason for differentiating the function as given?
I don’t believe the original post had any differentiation in mind.
---
### Author:  [@stevengj](https://discourse.julialang.org/u/stevengj)
#### Post date: [January 26, 2026, 2:59am UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/13 "2026-01-26T02:59:07Z")
My mistake, maybe; I saw “Enzyme” and I jumped to the conclusion that differentiation was ultimately desired.
That being said, nowadays people want derivatives for pretty much any function where the derivative exists, and sometimes even when the derivative doesn’t exist 😉 .
---
### Author:  [@wsmoses](https://discourse.julialang.org/u/wsmoses)
#### Post date: [January 26, 2026, 3:22am UTC](https://discourse.julialang.org/t/are-there-alternatives-to-diagonal-and-eigvals-compatible-with-reactant/135081/14 "2026-01-26T03:22:02Z")
Ah, not quite. We have another cool tool called Reactant that does lots of cool things, including fancy linear algebra optimizations — so this was nevertheless quite relevant!