Fix Julia 1.10 tests: replace Lux-internal NN tracer test with broadcast MLP (#49)

The test suite errored on Julia 1.10 with `UndefVarError: apply_activation
not defined`: `test/runtests.jl` called `Lux.apply_activation`, an internal
that no longer exists in modern Lux. Renaming it does not fix the suite —
modern Lux layer dispatch routes through device-detection / type-introspection
helpers (`fieldcount`, `can_setindex`, `__is_immutable_array_or_dual_val`,
`_reshape_uncolon`, ...) that contain genuine, but value-independent,
compile-time `GotoIfNot` branches. FunctionProperties' syntactic IR scan
cannot distinguish those from value-dependent branches, so tracing a real Lux
layer now reports `hasbranching == true`, which would make the
`@test !hasbranching(ann, ...)` and `@test !hasbranching(dxdt_, ...)`
assertions fail rather than pass. There is no Lux version on 1.10 where the
suite passes as written (#46).

Rework the neural-network portion of the test to exercise the same value flow
the tool actually inspects (SciML/SciMLSensitivity.jl#997: a neural-network-
shaped ODE right-hand side must trace branch-free so a tracing AD can compile
a tape) using explicit affine transforms plus broadcast activations instead of
a Lux layer. This drops the Lux test dependency entirely and removes the
silent resolution to incompatible Lux versions noted in the issue.

Also add `[compat]` bounds for the test dependencies (ComponentArrays, Random,
SafeTestsets, Test) and bump the patch version.

Co-authored-by: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

Project.toml

@@ -1,23 +1,26 @@
 name = "FunctionProperties"
 uuid = "f62d2435-5019-4c03-9749-2d4c77af0cbc"
 authors = ["SciML"]
-version = "0.1.2"
+version = "0.1.3"
 
 [deps]
 Cassette = "7057c7e9-c182-5462-911a-8362d720325c"
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
 
 [compat]
 Cassette = "0.3.12"
+ComponentArrays = "0.15"
 DiffRules = "1.15"
+Random = "1.10"
+SafeTestsets = "0.1"
+Test = "1.10"
 julia = "1.10"
 
 [extras]
 ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
-Lux = "b2108857-7c20-44ae-9111-449ecde12c47"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "SafeTestsets", "ComponentArrays", "Lux", "Random"]
+test = ["Test", "SafeTestsets", "ComponentArrays", "Random"]

test/runtests.jl

@@ -35,41 +35,55 @@ x = [1.0]
 @test !FunctionProperties.hasbranching(f, x)
 
 # Neural networks
-using Lux, ComponentArrays, Random
+#
+# The relevant scenario is a neural-network-shaped ODE right-hand side (SciML/SciMLSensitivity.jl#997):
+# `hasbranching` must report it as branch-free so a tracing AD like ReverseDiff can compile a tape.
+# The forward pass is expressed here as explicit affine transforms plus broadcast activations, which
+# is the value flow `hasbranching` actually inspects. We deliberately do not trace a real Lux layer:
+# modern Lux layer dispatch routes through device-detection / type-introspection helpers that contain
+# genuine (but value-independent, compile-time) `GotoIfNot` branches, which this syntactic IR scan
+# cannot distinguish from value-dependent branches (SciML/FunctionProperties.jl#46).
+using ComponentArrays, Random
 rng = Random.default_rng()
-ann = Dense(1, 1, identity)
-ps, st = Lux.setup(rng, ann)
-p = ComponentArray(ps)
-x0 = [-4.0f0, 0.0f0]
+W = randn(rng, Float32, 1, 1)
+b = randn(rng, Float32, 1)
+p = ComponentArray(; weight = W, bias = b)
 t = [0.0]
 
-function f(x, ps, st)
+function f(x, ps)
     return ps.weight * x
 end
-@test !FunctionProperties.hasbranching(f, t, p, st)
+@test !FunctionProperties.hasbranching(f, t, p)
 
-function f(x, ps, st)
+function f(x, ps)
     return x .+ x
 end
-@test !FunctionProperties.hasbranching(f, t, p, st)
+@test !FunctionProperties.hasbranching(f, t, p)
 
-function f2(x, ps, st)
-    return Lux.apply_activation(identity, ps.weight * x .+ vec(ps.bias)), st
+# Affine transform followed by a broadcast activation (the original `apply_activation` intent).
+function f2(x, ps)
+    return identity.(ps.weight * x .+ vec(ps.bias))
 end
-@test !FunctionProperties.hasbranching(f2, t, p, st)
-@test !FunctionProperties.hasbranching(ann, t, p, st)
+@test !FunctionProperties.hasbranching(f2, t, p)
 
+# A multi-layer perceptron forward pass built from broadcast `tanh` activations.
 rng = Random.default_rng()
 tspan = (0.0f0, 8.0f0)
-ann = Chain(Dense(2, 32, tanh), Dense(32, 32, tanh), Dense(32, 1))
-ps, st = Lux.setup(rng, ann)
-p = ComponentArray(ps)
+W1 = randn(rng, Float32, 32, 2)
+b1 = randn(rng, Float32, 32)
+W2 = randn(rng, Float32, 32, 32)
+b2 = randn(rng, Float32, 32)
+W3 = randn(rng, Float32, 1, 32)
+b3 = randn(rng, Float32, 1)
+p = ComponentArray(; W1, b1, W2, b2, W3, b3)
 θ, ax = getdata(p), getaxes(p)
 
+ann(x, p) = p.W3 * tanh.(p.W2 * tanh.(p.W1 * x .+ p.b1) .+ p.b2) .+ p.b3
+
 function dxdt_(dx, x, p, t)
     x1, x2 = x
-    dx[1] = x[2] + first(ann(x, p, st))[1]
-    return dx[2] = first(ann([t, t], p, st))[1]
+    dx[1] = x[2] + first(ann(x, p))
+    return dx[2] = first(ann([t, t], p))
 end
 x0 = [-4.0f0, 0.0f0]
 ts = Float32.(collect(0.0:0.01:tspan[2]))