Recognize Mapreducer/Mapper operations for sum/map over symbolic arrays

On Symbolics v7 / SymbolicUtils v4, sum(x) and map(f, x) over symbolic
arrays trace to terms whose operation is a SymbolicUtils.Mapreducer /
SymbolicUtils.Mapper callable rather than sum/map itself, so the rule
table never matched them and every such reduction analyzed as
UnknownCurvature. Plain sums (mapreduce(identity, add_sum, x) for any
dims/init) now delegate to the registered sum rule, and map(f, xs...)
delegates to f's rule the same way broadcast does.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ChrisRackauckas

src/atoms.jl

@@ -583,3 +583,20 @@ hasdcprule(::typeof(broadcast)) = true
 
 add_dcprule(LinearAlgebra.adjoint, array_domain(RealLine(), 1), AnySign, Affine, Increasing)
 add_dcprule(Base.getindex, array_domain(RealLine(), 1), AnySign, Affine, AnyMono)
+
+# On Symbolics v7 / SymbolicUtils v4, reductions and maps over symbolic arrays
+# trace to `SymbolicUtils.Mapreducer`/`SymbolicUtils.Mapper` operations rather
+# than to `sum`/`map` themselves, so the static rule table never sees them.
+# A plain sum — `mapreduce(identity, add_sum, x)`
+# for any `dims`/`init` — delegates to the registered `sum` rule (an `init`
+# only shifts by a constant, which preserves the affine composition), and
+# `map(f, xs...)` delegates to `f`'s rule exactly like `broadcast`.
+hasdcprule(::SymbolicUtils.Mapreducer{typeof(identity), typeof(Base.add_sum)}) = true
+function dcprule(
+        ::SymbolicUtils.Mapreducer{typeof(identity), typeof(Base.add_sum)}, args...
+    )
+    return dcprules_dict[sum], args
+end
+
+hasdcprule(op::SymbolicUtils.Mapper) = hasdcprule(op.f)
+dcprule(op::SymbolicUtils.Mapper, args...) = dcprule(op.f, args...)

test/test.jl

@@ -142,3 +142,22 @@ ex = propagate_curvature(ex)
 ex = norm(z, -1) |> unwrap
 ex = propagate_curvature(propagate_sign(ex))
 @test getcurvature(ex) == SymbolicAnalysis.UnknownCurvature
+
+# sum/map over symbolic arrays trace to SymbolicUtils.Mapreducer/Mapper
+# operations, not to `sum`/`map` themselves; previously they always analyzed
+# as UnknownCurvature.
+ex = sum(exp.(z)) |> unwrap
+ex = propagate_curvature(propagate_sign(ex))
+@test getcurvature(ex) == SymbolicAnalysis.Convex
+
+ex = sum(log.(z)) |> unwrap
+ex = propagate_curvature(propagate_sign(ex))
+@test getcurvature(ex) == SymbolicAnalysis.Concave
+
+ex = sum(z) |> unwrap
+ex = propagate_curvature(propagate_sign(ex))
+@test getcurvature(ex) == SymbolicAnalysis.Affine
+
+ex = map(exp, z) |> unwrap
+ex = propagate_curvature(propagate_sign(ex))
+@test getcurvature(ex) == SymbolicAnalysis.Convex