Enzyme: Cannot differentiate through MTK DAE solve (MutabilityException / RuntimeActivityError)

[ChrisRackauckas-Claude]

Description

Enzyme fails to differentiate through solve for an MTK ODEProblem with DAE initialization (algebraic constraints with guesses). Three different calling conventions were tested, each producing a different error:

1. Enzyme.gradient(Reverse, loss, tunables) → EnzymeMutabilityException — closure captures mutable state (ODEProblem containing arrays)
2. Enzyme.gradient(Reverse, Const(loss), tunables) → EnzymeRuntimeActivityError — constant memory stored/returned to differentiable variable
3. Enzyme.gradient(set_runtime_activity(Reverse), Const(loss), tunables) → MethodError: no method matching MixedDuplicated(::ODESolution...)

MWE

import Pkg
Pkg.activate(; temp = true)
Pkg.add(["ModelingToolkit", "OrdinaryDiffEq", "Enzyme",
    "SciMLSensitivity", "SciMLStructures", "SymbolicIndexingInterface"])

using ModelingToolkit, OrdinaryDiffEq, Enzyme
using ModelingToolkit: t_nounits as t, D_nounits as D
using SciMLSensitivity
import SciMLStructures as SS
using SymbolicIndexingInterface

# Minimal DAE system: ODE + algebraic constraint requiring initialization
@parameters a b
@variables x(t) y(t)

eqs = [
    D(x) ~ a * x + y,
    0 ~ x^2 - b * y,  # algebraic constraint
]

@mtkbuild sys = ODESystem(eqs, t)

prob = ODEProblem(sys, [x => 1.0], (0.0, 1.0), [a => -0.5, b => 2.0],
    guesses = [y => 1.0])
tunables, repack, _ = SS.canonicalize(SS.Tunable(), parameter_values(prob))

# Forward solve works fine
sol = solve(prob, Rodas5P())

loss = let prob = prob, repack = repack
    p -> begin
        new_prob = remake(prob; p = repack(p))
        sol = solve(new_prob, Rodas5P(); abstol = 1e-8, reltol = 1e-6)
        sum(sol)
    end
end

# Attempt 1: plain Reverse
grad = Enzyme.gradient(Enzyme.Reverse, loss, tunables)
# => EnzymeMutabilityException

# Attempt 2: Const(loss)
grad = Enzyme.gradient(Enzyme.Reverse, Enzyme.Const(loss), tunables)
# => EnzymeRuntimeActivityError

# Attempt 3: set_runtime_activity + Const
grad = Enzyme.gradient(set_runtime_activity(Enzyme.Reverse), Enzyme.Const(loss), tunables)
# => MethodError: no method matching MixedDuplicated(::ODESolution...)

Errors

Attempt 1:

EnzymeMutabilityException: Function argument passed to autodiff cannot be proven readonly.

Attempt 2:

EnzymeRuntimeActivityError: Detected potential need for runtime activity.
Constant memory is stored (or returned) to a differentiable variable and correctness cannot be guaranteed with static activity analysis.

Attempt 3:

MethodError: no method matching MixedDuplicated(::ODESolution{Float64, 2, ...}, ...)

Environment

• Julia 1.12
• ModelingToolkit v11
• Enzyme v0.13 / Enzyme_jll v0.0.249
• SciMLSensitivity latest

Related

• Add Mooncake and EnzymeCore extensions for AD compatibility ModelingToolkit.jl#4331 (EnzymeCore extension with inactive_noinl for getproperty)
• Update Core8 MTK tests for mutation-aware AD #1356 (Core8 test updates with @test_broken)

[ChrisRackauckas-Claude]

Full error output

Full output (including precompilation, all 3 attempts with stack traces): https://gist.github.com/ChrisRackauckas-Claude/21e0e0ea60bf32c5d8cc245404e0f1b0

Attempt 1: Enzyme.gradient(Reverse, loss, tunables)

FAILED: Enzyme.Compiler.EnzymeMutabilityException
EnzymeMutabilityException: Function argument passed to autodiff cannot be proven readonly.
If the the function argument cannot contain derivative data, instead call autodiff(Mode, Const(f), ...)

The potentially writing call is:
  store atomic ptr addrspace(10) %.fca.1.0.1.extract, ptr addrspace(11) %4 unordered, align 8
  using %.fca.1.0.1.extract = extractvalue { ptr addrspace(10), [1 x { ptr addrspace(10), ptr addrspace(10) }] } %0, 1, 0, 1
    enzymejl_source_type_Vector{Float64}

Stacktrace:
  [1] remake @ ~/.julia/packages/SciMLBase/YSSnm/src/remake.jl:222 [inlined]
  [2] #2 @ /tmp/mwe_enzyme_full.jl:31 [inlined]
  [3] diffejulia__2_414687_inner_18wrap @ /tmp/mwe_enzyme_full.jl:0
  ...
 [10] gradient(::ReverseMode{...}, ::var"#2#3"{ODEProblem{...}}, ::Vector{Float64})
    @ Enzyme ~/.julia/packages/Enzyme/S3nC6/src/sugar.jl:274

Attempt 2: Enzyme.gradient(Reverse, Const(loss), tunables)

FAILED: Enzyme.Compiler.EnzymeRuntimeActivityError
EnzymeRuntimeActivityError: Detected potential need for runtime activity.

Constant memory is stored (or returned) to a differentiable variable and correctness
cannot be guaranteed with static activity analysis.

Failure within method:
(::var"#2#3"{ODEProblem{...}})(::Vector{Float64})
     @ Main /tmp/mwe_enzyme_full.jl:30

Mismatched activity for:
  store atomic ptr addrspace(10) %.fca.1.0.1.extract, ptr addrspace(11) %4 unordered, align 8
  const val: %.fca.1.0.1.extract = extractvalue {...} %0, 1, 0, 1
    enzymejl_source_type_Vector{Float64}
Julia value causing error: Unknown object of type Vector{Float64}

Stacktrace:
  [1] remake @ ~/.julia/packages/SciMLBase/YSSnm/src/remake.jl:222 [inlined]
  [2] #2 @ /tmp/mwe_enzyme_full.jl:31 [inlined]
  ...

Attempt 3: Enzyme.gradient(set_runtime_activity(Reverse), Const(loss), tunables)

FAILED: MethodError
MethodError: no method matching MixedDuplicated(::ODESolution{Float64, 2, Vector{Vector{Float64}}, ...}, ...)

Stacktrace:
  [1] MixedDuplicated @ ~/.julia/packages/EnzymeCore/WjGjx/src/EnzymeCore.jl:203 [inlined]
  [2] FFIABI
  [3] macro expansion @ ~/.julia/packages/Enzyme/S3nC6/src/compiler.jl:6672 [inlined]
  [4] enzyme_call @ ~/.julia/packages/Enzyme/S3nC6/src/compiler.jl:6151 [inlined]
  ...
 [14] gradient(::ReverseMode{...}, ::Const{var"#2#3"{ODEProblem{...}}}, ::Vector{Float64})
    @ Enzyme ~/.julia/packages/Enzyme/S3nC6/src/sugar.jl:274

All three failures occur at the remake call site (SciMLBase/src/remake.jl:222) where the ODEProblem is reconstructed with new parameters. The LLVM IR shows Enzyme struggling with the Vector{Float64} field within the captured MTKParameters struct being stored through the closure.

[ChrisRackauckas-Claude]

Investigation Results

Investigated the three error modes. Here's what's happening:

Root Cause Analysis

Attempt 3 (set_runtime_activity(Reverse) + Const(loss)) - MixedDuplicated error:

The DiffEqBaseEnzymeExt.jl custom Enzyme rules for solve_up only accept Duplicated{RT} as the return type annotation. When Enzyme determines that ODESolution has mixed activity state (both mutable arrays and immutable scalars), it wants MixedDuplicated{RT}, finds no matching rule, and falls through to JIT rules which fail at MixedDuplicated constructor.

Fix: PR opened at SciML/DiffEqBase.jl#1282 - adds MixedDuplicated{RT} to the Union in both augmented_primal and reverse rule signatures.

Additional Issues Found

1. NonlinearSolveBase's Enzyme extension has the same problem - NonlinearSolveBaseEnzymeExt.jl also only accepts Duplicated{RT}. Since DAE initialization calls solve on a NonlinearProblem, this needs the same fix.

2. Enzyme.make_zero segfaults on complex ODESolution types on Julia 1.12 - After the custom rule fires correctly, Enzyme.make_zero(res[1]) (line 55 of DiffEqBaseEnzymeExt.jl) crashes with a segfault in jl_object_id__cold during GC. This is a Julia 1.12 / Enzyme interaction issue.

3. Attempts 1 and 2 are expected Enzyme behavior:

   • Attempt 1 (plain Reverse): Enzyme correctly detects the closure captures mutable state
   • Attempt 2 (Const(loss) without set_runtime_activity): Enzyme detects constant memory flowing to differentiable variables

Confirmed via Testing

The custom rule IS being dispatched correctly after the fix (confirmed via stacktrace showing augmented_primal at DiffEqBaseEnzymeExt.jl:32 being called from solve → solve_up). The MixedDuplicated union fix allows the rule to match.

The remaining make_zero segfault appears to be an upstream Enzyme/Julia 1.12 GC issue, not a SciMLSensitivity issue.

[ChrisRackauckas]

Currently blocked on an issue EnzymeAD/Enzyme.jl#2977

[ChrisRackauckas-Claude]

Status update — Layer 2 isolated and filed upstream (2026-05-21)

Continuing the investigation summary that was posted earlier. The 4-layer stack from that report is now in motion:

Layer	Status	Tracking
1. MTK supports_initialization → jumps(sys) mutation	PR open — verified one-line fix	SciML/ModelingToolkit.jl#4551 (closes #4550)
2. Enzyme + NonlinearSolve on a wrapped-function NonlinearProblem (RuntimeGeneratedFunction or GeneratedFunctionWrapper{closure})	Filed upstream with no-MTK MWE	EnzymeAD/Enzyme.jl#3117
3. SciMLBase EnzymeRuntimeActivityError "Mismatched activity for Unknown object of type System" via Const(loss)	Becomes unnecessary once 1+2 land	—
4. Enzyme.jl MethodError MixedDuplicated(::NonlinearSolution, ...) in create_activity_wrapper	Becomes unnecessary once 1+2+3 land	adjacent to EnzymeAD/Enzyme.jl#2961

Defensive improvement also filed:

• Declare cache-storage types as Enzyme inactive FunctionWrappersWrappers.jl#51 — declares SingleCacheStorage / DictCacheStorage / NoCacheStorage as inactive_type so Enzyme stops conservatively flagging captured FWW wrappers. Does not unblock Layer 2 on its own (verified empirically); it's just hardening.

What the three @test_broken Enzyme.gradient blocks need

Both #4551 (MTK) and EnzymeAD#3117 need to land before:

• test/mtk.jl "Enzyme through DAE init" 2-broken set flips
• test/parameter_initialization.jl "Adjoint through Prob (Enzyme)" testset flips
• test/desauty_dae_mwe.jl "Enzyme through init" testset flips

#4551 verified locally: with it applied, Enzyme.gradient through bare remake (no solve) succeeds. The block is now decisively on the Enzyme + NonlinearSolve + wrapped-function side.

Minimal Layer 2 MWE (for upstream tracking)

using RuntimeGeneratedFunctions, NonlinearSolve, Enzyme
using SciMLBase: NonlinearProblem, remake
RuntimeGeneratedFunctions.init(@__MODULE__)

f_rgf = @RuntimeGeneratedFunction(:((du, u, p) -> (du[1] = u[1] - p[1] + p[2]; nothing)))
prob = NonlinearProblem(f_rgf, [0.0], [2.0, 1.0])
loss(p) = sum(solve(remake(prob; p)).u)
Enzyme.gradient(Enzyme.Reverse, loss, [2.0, 1.0])
# EnzymeMutabilityException

The same shape with a plain anonymous Julia closure (no RGF, no GeneratedFunctionWrapper) returns [1.0, -1.0] correctly.