Proper fix for trigonometric function domain compatibility

Root cause analysis revealed that ComplexExtensionDerivation was using
a rigid domain check that didn't account for different nesting levels
of derivation domains, similar to how ExtensionDerivation handles
multiple constructor patterns.

Fixed by:
- Following the same pattern as ExtensionDerivation constructors
- Checking compatibility at multiple nesting levels
- Removing try-catch workarounds in favor of proper domain matching

Updated tests to verify mathematical correctness using derivative
verification based on the fundamental theorem of calculus.

Author: ChrisRackauckas

debug_test.jl

@@ -0,0 +1,23 @@
+#!/usr/bin/env julia
+
+using Pkg
+Pkg.activate(".")
+
+println("Loading packages...")
+using SymbolicIntegration, Symbolics
+
+println("Creating variable...")
+@variables x
+
+println("Attempting sin(x) integration with debugging...")
+try
+    result = integrate(sin(x), x, RischMethod())
+    println("SUCCESS: Result = $result")
+catch e
+    println("ERROR: $e")
+    println("Stack trace:")
+    for (exc, bt) in Base.catch_stack()
+        showerror(stdout, exc, bt)
+        println()
+    end
+end

src/methods/risch/complex_fields.jl

@@ -4,17 +4,27 @@ struct ComplexExtensionDerivation{T<:FieldElement, P<:PolyRingElem{T}} <: Deriva
     domain::AbstractAlgebra.ResField{P}
     D::Derivation    
     function ComplexExtensionDerivation(domain::AbstractAlgebra.ResField{P}, D::Derivation) where {T<:FieldElement, P<:PolyRingElem{T}}
-        # Modified domain compatibility check to handle complex field structures
-        # The original check was too strict for trigonometric function integration
-        expected_base = base_ring(base_ring(base_ring(domain)))
-        derivation_domain = D.domain
+        # The issue is that we need to check the correct nesting level based on the derivation type
+        # Similar to how ExtensionDerivation handles different nesting levels
 
-        # Check for direct compatibility or through base ring unwrapping
-        domain_compatible = (expected_base == derivation_domain) ||
-                          (try base_ring(derivation_domain) == expected_base; catch; false; end) ||
-                          (try base_ring(base_ring(derivation_domain)) == expected_base; catch; false; end)
+        expected_domain = base_ring(base_ring(base_ring(domain)))
+        actual_domain = D.domain
 
-        domain_compatible || error("base ring of domain must be compatible with domain of D")
+        # Check compatibility following the same pattern as ExtensionDerivation
+        domain_compatible = false
+        
+        if expected_domain == actual_domain
+            # Direct match - the expected case for basic derivations
+            domain_compatible = true
+        elseif base_ring(base_ring(domain)) == actual_domain
+            # One level less nesting - derivation on the polynomial ring level
+            domain_compatible = true  
+        elseif base_ring(domain) == actual_domain
+            # Two levels less nesting - derivation on the coefficient field level
+            domain_compatible = true
+        end
+        
+        domain_compatible || error("base ring of domain must be domain of D")
 
         m = modulus(domain)
         degree(m)==2 && isone(coeff(m, 0)) && iszero(coeff(m, 1)) && isone(coeff(m,2)) ||

test/methods/risch/test_trigonometric_functions.jl

@@ -5,29 +5,29 @@ using Symbolics
 @testset "Trigonometric Functions with Risch Method" begin
     @variables x
 
-    @testset "Issue #20: Domain compatibility fix" begin
-        # Test that trigonometric functions can be integrated with RischMethod
-        # without throwing the specific domain mismatch error from Issue #20
+    @testset "Issue #20: Basic trigonometric integration" begin
+        # Test sin(x) integration
+        sin_result = integrate(sin(x), x, RischMethod())
+        @test sin_result !== nothing
 
-        # The original error was: "ERROR: base ring of domain must be domain of D"
-        # This test verifies the fix doesn't throw that specific error
+        # Test cos(x) integration  
+        cos_result = integrate(cos(x), x, RischMethod())
+        @test cos_result !== nothing
 
-        try
-            sin_result = integrate(sin(x), x, RischMethod())
-            @test true  # If we get here without error, the fix works
-        catch e
-            # If there's an error, make sure it's NOT the domain compatibility error
-            @test !occursin("base ring of domain must be domain of D", string(e))
-            @test !occursin("base ring of domain must be compatible with domain of D", string(e))
-        end
+        # Test mathematical correctness by verifying derivatives
+        # The fundamental theorem of calculus: d/dx[∫f(x)dx] = f(x)
+        @test isequal(Symbolics.derivative(sin_result, x), sin(x))
+        @test isequal(Symbolics.derivative(cos_result, x), cos(x))
 
-        try
-            cos_result = integrate(cos(x), x, RischMethod())
-            @test true  # If we get here without error, the fix works
-        catch e
-            # If there's an error, make sure it's NOT the domain compatibility error
-            @test !occursin("base ring of domain must be domain of D", string(e))
-            @test !occursin("base ring of domain must be compatible with domain of D", string(e))
-        end
+        # Test that results are symbolic expressions
+        @test sin_result isa Union{Number, SymbolicUtils.BasicSymbolic}
+        @test cos_result isa Union{Number, SymbolicUtils.BasicSymbolic}
+    end
+    
+    @testset "Additional trigonometric functions" begin
+        # Test tan(x) integration
+        tan_result = integrate(tan(x), x, RischMethod())
+        @test tan_result !== nothing
+        @test isequal(Symbolics.derivative(tan_result, x), tan(x))
     end
 end