fix(risch): use SU4 Sym constructor; stop catch-all from hiding API breakage

`analyze_expr` introduces a fresh symbol for each new exp/log/atan/tan
factor via `SymbolicUtils.Sym{Real}(name)`. Under SymbolicUtils v4 the
type parameter must be `<:SymVariant`, not `Real`, so this constructor
throws `TypeError`. Update to `Sym{SymbolicUtils.SymReal}(name; type=Real)`,
which is the SU4 spelling that produces the same `BasicSymbolic{SymReal}`
the function dispatch already expects.

The bug was invisible because of a `try`/`catch` immediately around the
dispatch body that re-wrapped any unrecognised exception as
`NotImplementedError("integrand contains unsupported expression $f")`.
The outer `integrate_risch` catch then converted that into an unevaluated
`∫(f, x)` and the user saw an apparent coverage gap. Drop the catch-all
— domain limits are already raised explicitly with `NotImplementedError`
at the right spots; everything else (`MethodError`/`TypeError`/etc.) is
a real bug and should surface as itself so future SU/Symbolics API
breakage is debuggable instead of silent.

Effect on the difficult-test corpus: 15 previously-unevaluated Risch
integrals (`x*log(x)`, `x*exp(x)`, `1/(x*log(x))`, `x*atan(x)`,
`log(x)^2`, …) now solve cleanly with correct antiderivatives.

Bisected from a comparison of Apostol-corpus per-integral results
between e4fff44 (last green pre-PR-#53) and current main: RuleBased was
net-positive across the SU4 upgrade (+8 newly solved, 1 regression),
but Risch lost exactly this class.

Adds `test/methods/risch/test_textbook_transcendentals.jl` covering the
15 regressed integrands, with verification by differentiation rather
than antiderivative-equality (different but equivalent forms are
common). All 30 new assertions pass locally.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

src/methods/risch/frontend.jl

@@ -300,135 +300,132 @@ function analyze_expr(f::SymbolicUtils.BasicSymbolic{SymbolicUtils.SymReal} , fu
         return f
     end
 
-    # For non-symbols, dispatch based on operation
-    try
-        op = operation(f)
-        if op in (+, *, /)
-            # Handle Add, Mul, Div operations
-            as = [SymbolicUtils.unwrap_const(x) for x in arguments(f)]
-            ps = [analyze_expr(a, funs, vars, args, tanArgs, expArgs) for a in as]
-            return op(ps...)
-        elseif op == (^)
-            # Handle Pow operations  
-            as = [SymbolicUtils.unwrap_const(x) for x in arguments(f)]
-            p1 = analyze_expr(as[1], funs, vars, args, tanArgs, expArgs)
-            p2 = analyze_expr(as[2], funs, vars, args, tanArgs, expArgs)
-            if isa(p2, Integer)
-                return p1^p2
-            elseif isa(p2, Number)        
-                throw(NotImplementedError("integrand contains power with unsupported exponent $p2"))
-            end
+    # For non-symbols, dispatch based on operation. No catch-all here on
+    # purpose: domain limits are raised explicitly as `NotImplementedError`
+    # at the right point; everything else (MethodError/TypeError/...) is a
+    # bug and should surface as itself rather than be re-wrapped as
+    # "unsupported expression", which makes upstream API breakage look like
+    # a coverage gap.
+    op = operation(f)
+    if op in (+, *, /)
+        # Handle Add, Mul, Div operations
+        as = [SymbolicUtils.unwrap_const(x) for x in arguments(f)]
+        ps = [analyze_expr(a, funs, vars, args, tanArgs, expArgs) for a in as]
+        return op(ps...)
+    elseif op == (^)
+        # Handle Pow operations
+        as = [SymbolicUtils.unwrap_const(x) for x in arguments(f)]
+        p1 = analyze_expr(as[1], funs, vars, args, tanArgs, expArgs)
+        p2 = analyze_expr(as[2], funs, vars, args, tanArgs, expArgs)
+        if isa(p2, Integer)
+            return p1^p2
+        elseif isa(p2, Number)
             throw(NotImplementedError("integrand contains power with unsupported exponent $p2"))
-        elseif op == exp
-            # Handle exp function
-            a = arguments(f)[1]
-            i = findfirst(x -> is_rational_multiple(a, x), expArgs)
-            n = 1
-            if i === nothing
-                push!(expArgs, a)
-            else
-                n = rational_multiple(a, expArgs[i])
-                if !isone(denominator(n)) # n not an integer
-                    expArgs[i] = 1//denominator(n)*expArgs[i]
-                    throw(UpdatedArgList())            
-                end
-                n = numerator(n)
-            end
-            if n != 1
-                f_new = exp(expArgs[i])^n
-                return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-            end
-            # Continue to general function handling below
-        elseif op == tan        
-            # Handle tan function
-            a = arguments(f)[1]
-            i = findfirst(x -> is_rational_multiple(a, x), tanArgs)
-            n = 1
-            if i === nothing
-                push!(tanArgs, a)
-            else
-                n = rational_multiple(a, tanArgs[i])
-                if !isone(denominator(n)) # n not an integer
-                    tanArgs[i] = 1//denominator(n)*tanArgs[i]
-                    throw(UpdatedArgList())            
-                end
-                n = numerator(n) 
-            end
-            if n != 1
-                f_new = tan_nx(n, tanArgs[i])
-                return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+        end
+        throw(NotImplementedError("integrand contains power with unsupported exponent $p2"))
+    elseif op == exp
+        # Handle exp function
+        a = arguments(f)[1]
+        i = findfirst(x -> is_rational_multiple(a, x), expArgs)
+        n = 1
+        if i === nothing
+            push!(expArgs, a)
+        else
+            n = rational_multiple(a, expArgs[i])
+            if !isone(denominator(n)) # n not an integer
+                expArgs[i] = 1//denominator(n)*expArgs[i]
+                throw(UpdatedArgList())
             end
-            # Continue to general function handling below
-        elseif op == sinh
-            # Transform sinh to exponentials
-            a = arguments(f)[1]
-            f_new = 1//2*(exp(a) - 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == cosh
-            # Transform cosh to exponentials  
-            a = arguments(f)[1]
-            f_new = 1//2*(exp(a) + 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == csch # 1/sinh
-            a = arguments(f)[1]
-            f_new = 2/(exp(a) - 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == sech
-            a = arguments(f)[1]
-            f_new = 2/(exp(a) + 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == tanh
-            a = arguments(f)[1]
-            f_new = (exp(a) - 1/exp(a))/(exp(a) + 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == coth
-            a = arguments(f)[1]
-            f_new = (exp(a) + 1/exp(a))/(exp(a) - 1/exp(a))
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)        
-        elseif op == sin # transform to half angle format
-            a = arguments(f)[1]
-            f_new = 2*tan(1//2*a)/(1 + tan(1//2*a)^2)
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == cos
-            a = arguments(f)[1]
-            f_new = (1 - tan(1//2*a)^2)/(1 + tan(1//2*a)^2)
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == csc # 1/sin
-            a = arguments(f)[1]
-            f_new = 1//2*(1 + tan(1//2*a)^2)/tan(1//2*a)
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == sec # 1/cos
-            a = arguments(f)[1]
-            f_new = (1 + tan(1//2*a)^2)/(1 - tan(1//2*a)^2)
-            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
-        elseif op == cot
-            a = arguments(f)[1]
-            f_new = 1/tan(a)
+            n = numerator(n)
+        end
+        if n != 1
+            f_new = exp(expArgs[i])^n
             return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
         end
-        
-        # General function handling (for exp, log, atan, tan that didn't get transformed above)
-        i = findfirst(x -> hash(x)==hash(f), funs) 
-        if i !== nothing
-            return vars[i]
-        end    
-        op in [exp, log, atan, tan] ||        
-            throw(NotImplementedError("integrand contains unsupported function $op"))
+        # Continue to general function handling below
+    elseif op == tan
+        # Handle tan function
         a = arguments(f)[1]
-        p = analyze_expr(a, funs, vars, args, tanArgs, expArgs)
-        tname = Symbol(:t, length(vars)) 
-        t = SymbolicUtils.Sym{Real}(tname)
-        push!(funs, f)
-        push!(vars, t)
-        push!(args, p)
-        return t
-    catch e
-        if isa(e, UpdatedArgList)
-            rethrow(e)
+        i = findfirst(x -> is_rational_multiple(a, x), tanArgs)
+        n = 1
+        if i === nothing
+            push!(tanArgs, a)
         else
-            throw(NotImplementedError("integrand contains unsupported expression $f"))
+            n = rational_multiple(a, tanArgs[i])
+            if !isone(denominator(n)) # n not an integer
+                tanArgs[i] = 1//denominator(n)*tanArgs[i]
+                throw(UpdatedArgList())
+            end
+            n = numerator(n)
         end
+        if n != 1
+            f_new = tan_nx(n, tanArgs[i])
+            return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+        end
+        # Continue to general function handling below
+    elseif op == sinh
+        # Transform sinh to exponentials
+        a = arguments(f)[1]
+        f_new = 1//2*(exp(a) - 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == cosh
+        # Transform cosh to exponentials
+        a = arguments(f)[1]
+        f_new = 1//2*(exp(a) + 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == csch # 1/sinh
+        a = arguments(f)[1]
+        f_new = 2/(exp(a) - 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == sech
+        a = arguments(f)[1]
+        f_new = 2/(exp(a) + 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == tanh
+        a = arguments(f)[1]
+        f_new = (exp(a) - 1/exp(a))/(exp(a) + 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == coth
+        a = arguments(f)[1]
+        f_new = (exp(a) + 1/exp(a))/(exp(a) - 1/exp(a))
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == sin # transform to half angle format
+        a = arguments(f)[1]
+        f_new = 2*tan(1//2*a)/(1 + tan(1//2*a)^2)
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == cos
+        a = arguments(f)[1]
+        f_new = (1 - tan(1//2*a)^2)/(1 + tan(1//2*a)^2)
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == csc # 1/sin
+        a = arguments(f)[1]
+        f_new = 1//2*(1 + tan(1//2*a)^2)/tan(1//2*a)
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == sec # 1/cos
+        a = arguments(f)[1]
+        f_new = (1 + tan(1//2*a)^2)/(1 - tan(1//2*a)^2)
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
+    elseif op == cot
+        a = arguments(f)[1]
+        f_new = 1/tan(a)
+        return analyze_expr(f_new, funs, vars, args, tanArgs, expArgs)
     end
+
+    # General function handling (for exp, log, atan, tan that didn't get transformed above)
+    i = findfirst(x -> hash(x)==hash(f), funs)
+    if i !== nothing
+        return vars[i]
+    end
+    op in [exp, log, atan, tan] ||
+        throw(NotImplementedError("integrand contains unsupported function $op"))
+    a = arguments(f)[1]
+    p = analyze_expr(a, funs, vars, args, tanArgs, expArgs)
+    tname = Symbol(:t, length(vars))
+    t = SymbolicUtils.Sym{SymbolicUtils.SymReal}(tname; type=Real)
+    push!(funs, f)
+    push!(vars, t)
+    push!(args, p)
+    return t
 end
 
 function analyze_expr(f::Number , funs::Vector, vars::Vector{SymbolicUtils.BasicSymbolic{SymbolicUtils.SymReal}}, args::Vector, tanArgs::Vector, expArgs::Vector)

test/methods/risch/test_textbook_transcendentals.jl

@@ -0,0 +1,42 @@
+using Test
+using SymbolicIntegration
+using Symbolics
+
+# Textbook transcendental integrals that all reduce to introducing fresh symbols
+# in `analyze_expr` (the `Sym{SymReal}(name; type=Real)` path). These regressed
+# silently when the SymbolicUtils v3→v4 upgrade left a stale `Sym{Real}` in
+# place: the resulting `TypeError` was caught and re-thrown as a generic
+# `NotImplementedError("integrand contains unsupported expression …")`, so
+# `integrate_risch` returned the input integrand unevaluated and CI looked
+# like a coverage gap rather than a bug.
+@testset "[Risch] Textbook transcendental integrals" begin
+    @variables x
+
+    cases = Any[
+        x*log(x),
+        x^2*log(x)^2,
+        x^3*log(x)^3,
+        x*log(x)^2,
+        log(x)^2,
+        log(1 - x)/(1 - x),
+        1/(x*log(x)),
+        x*exp(x),
+        x^2*exp(x),
+        x^2*exp(x^3),
+        1/(1 + exp(x)),
+        x^2/exp(x),
+        x^3/exp(x),
+        x*atan(x),
+        x*atan(x)^2,
+    ]
+
+    for integrand in cases
+        @testset "$(integrand)" begin
+            r = integrate(integrand, x, RischMethod())
+            @test !occursin('∫', string(r))
+            # Verify by differentiation, not equality of antiderivatives —
+            # different but equivalent forms are common.
+            @test isequal(simplify(Symbolics.derivative(r, x) - integrand; expand=true), 0)
+        end
+    end
+end

test/runtests.jl

@@ -25,9 +25,10 @@ const TEST_GROUP = get(ENV, "TEST_GROUP", "all")
 
             # Include Risch method test suites
             include("methods/risch/test_rational_integration.jl")
-            include("methods/risch/test_complex_fields.jl") 
+            include("methods/risch/test_complex_fields.jl")
             include("methods/risch/test_bronstein_examples.jl")
             include("methods/risch/test_algorithm_internals.jl")
+            include("methods/risch/test_textbook_transcendentals.jl")
 
             # test internals of rulebased methods
             include("methods/rule_based/test_rule2.jl")