Fix QA (Aqua/JET) findings and align downgrade compat floor

Builds on the Symbolics-v6 cap to make the QA and Downgrade groups green:

Downgrade: raise the package Manifolds compat floor from 0.9 to 0.10 so it
matches the test env's Manifolds cap (needed for OptimizationManopt 1.3.2).
julia-downgrade-compat was pinning the root floor to Manifolds 0.9.10, which
had an empty intersection with the test env's 0.10 -> Downgrade now resolves
the minimal set (Manifolds 0.10.0, ...).

Aqua:
- Drop the unused IfElse and Dictionaries deps (genuine stale deps).
- Disambiguate Base.in(::Num/::Symbolic, ::CustomDomain) against Symbolics'
  in(::Num/::Symbolic, ::Domain) (CustomDomain <: Domain made the two overlap).
- Configure run_qa's Aqua via aqua_kwargs: treat the deliberately-extended
  non-owned functions (log/tr/inv/sqrt/logdet/distance/xlogx and the Symbolics
  arguments/hasmetadata/promote_symtype hooks) as own for the piracy check, and
  exclude the 10 atom functions whose scalar+array @register_symbolic
  registrations generate benign internal ambiguities. All remaining ambiguities
  are internal to SymbolicAnalysis (no cross-package ambiguity remains).

JET (real code bugs surfaced by report_package, run in :typo mode):
- lorentz_log_barrier referenced an undefined ; a = (0,...,0,1) makes the
  Lorentzian inner product reduce to -p[end], so the barrier is -log(-1+p[end]).
- lognormcdf called logcdf(Normal, x) (the type) which is a MethodError; use the
  standard-normal instance logcdf(Normal(), x).
- find_curvature/find_gcurvature could fall through with /
  undefined (the  branch did not return its value); return it and
  default f_curvature/f_monotonicity to the existing 'unknown' semantics.

Switch test/qa/qa.jl to SciMLTesting.run_qa (the shared harness, matching
ModelingToolkit) with jet=true and mode=:typo.

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

Author: ChrisRackauckas

Project.toml

@@ -6,10 +6,8 @@ version = "0.3.6"
 [deps]
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
-Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf"
-IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
 Manifolds = "1cead3c2-87b3-11e9-0ccd-23c62b72b94e"
@@ -23,13 +21,11 @@ Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 [compat]
 DSP = "0.7, 0.8"
 DataStructures = "0.18, 0.19"
-Dictionaries = "0.4"
 Distributions = "0.25"
 DomainSets = "0.7, 0.8"
-IfElse = "0.1"
 LinearAlgebra = "1.10"
 LogExpFunctions = "0.3, 1.0"
-Manifolds = "0.9, 0.10, 0.11"
+Manifolds = "0.10, 0.11"
 PDMats = "0.11"
 PrecompileTools = "1"
 RecursiveArrayTools = "3, 4"

src/atoms.jl

@@ -420,7 +420,7 @@ Returns the log of the normal cumulative distribution function of `x`.
     - `x::Real`: A Real.
 """
 function lognormcdf(x::Real)
-    return logcdf(Normal, x)
+    return logcdf(Normal(), x)
 end
 Symbolics.@register_symbolic lognormcdf(x::Real)
 add_dcprule(lognormcdf, RealLine(), Negative, Concave, Increasing)

src/gdcp/gdcp_rules.jl

@@ -101,6 +101,8 @@ function find_gcurvature(ex)
     if iscall(ex)
         f, args = operation(ex), arguments(ex)
         knowngcurv = false
+        f_curvature = GUnknownCurvature
+        f_monotonicity = (GAnyMono,)
 
         if hasgdcprule(f) && !any(iscall.(args))
             rule, args = gdcprule(f, args...)
@@ -170,7 +172,7 @@ function find_gcurvature(ex)
                 elseif argscurv == GConcave
                     return GConvex
                 else
-                    argscurv
+                    return argscurv
                 end
             else
                 @warn "Disciplined Programming does not support multiple non-constant arguments in multiplication"

src/gdcp/lorentz.jl

@@ -16,19 +16,20 @@ using Symbolics: Symbolic, @register_symbolic, unwrap, variables
 add_gdcprule(Manifolds.distance, Manifolds.Lorentz, Positive, GConvex, GAnyMono)
 
 """
-    lorentz_log_barrier(a, p)
+    lorentz_log_barrier(p)
 
-Computes the log-barrier function for the Lorentz model: `-log(-1 - <a, p>_L)`.
+Computes the log-barrier function for the Lorentz model: `-log(-1 - <a, p>_L)`,
+with the fixed vector `a = (0, ..., 0, 1)` in R^(d+1).
 
 # Arguments
 
-    - `a`: The vector (0, ..., 0, 1) in R^(d+1).
     - `p`: A point on the Lorentz manifold.
 """
 function lorentz_log_barrier(p::AbstractVector)
-    # Lorentzian inner product: a⋅p_L = a1*p1 + ... + a_d*p_d - a_{d+1}*p_{d+1}
-    inner_prod = a[end] * p[end]
-    return -log(-1 + inner_prod)
+    # a = (0, ..., 0, 1), so the Lorentzian inner product
+    # <a, p>_L = a1*p1 + ... + a_d*p_d - a_{d+1}*p_{d+1} reduces to -p[end].
+    # The barrier is -log(-1 - <a, p>_L) = -log(-1 + p[end]).
+    return -log(-1 + p[end])
 end
 
 @register_symbolic lorentz_log_barrier(p::Union{Symbolics.Arr, AbstractVector})

src/rules.jl

@@ -7,6 +7,10 @@ struct CustomDomain{T} <: Domain{T}
 end
 
 Base.in(x, c::CustomDomain) = c.in(x)
+# Disambiguate against Symbolics' `in(::Num/::Symbolic, ::Domain)`, since
+# `CustomDomain <: Domain` makes the symbolic-variable calls match both methods.
+Base.in(x::Union{Symbolics.Num, Symbolic{<:Number}}, c::CustomDomain) = c.in(x)
+Base.in(x::NTuple{N, Union{Symbolics.Num, Symbolic{<:Number}}}, c::CustomDomain) where {N} = c.in(x)
 
 function array_domain(element_domain)
     return CustomDomain{AbstractArray}() do xs
@@ -332,7 +336,7 @@ function find_curvature(ex)
                 elseif argscurv == Concave
                     return Convex
                 else
-                    argscurv
+                    return argscurv
                 end
             else
                 @warn "DCP does not support multiple non-constant arguments in multiplication"

test/qa/qa.jl

@@ -1,9 +1,37 @@
-using SymbolicAnalysis, Aqua, JET, Test
+using SymbolicAnalysis, Aqua, JET, SciMLTesting
 
-@testset "Aqua" begin
-    Aqua.test_all(SymbolicAnalysis)
-end
+const SA = SymbolicAnalysis
 
-@testset "JET" begin
-    JET.test_package(SymbolicAnalysis; target_defined_modules = true)
-end
+# Functions this package deliberately extends with symbolic-analysis methods.
+# Registering DCP/GDCP methods on these non-owned functions (and the Symbolics
+# traversal/symtype hooks) is the core purpose of the package, so they are
+# intentional and declared to Aqua's piracy check via `treat_as_own`.
+const SYMBOLIC_OWN = Any[
+    Base.log, SA.LinearAlgebra.tr, SA.LinearAlgebra.inv, SA.LinearAlgebra.sqrt,
+    SA.LinearAlgebra.logdet, SA.Manifolds.distance, SA.LogExpFunctions.xlogx,
+    SA.Symbolics.arguments, SA.Symbolics.hasmetadata, SA.Symbolics.promote_symtype,
+]
+
+# The scalar/array `@register_symbolic`/`@register_array_symbolic` registrations
+# for the package's own atoms generate overlapping signatures (e.g. a scalar and
+# an array method of the same atom), which Aqua reports as internal ambiguities.
+# These are all between SymbolicAnalysis's own methods (no cross-package
+# ambiguity remains) and are benign; concrete calls dispatch unambiguously.
+# Excluding only these atoms keeps the check live for everything else.
+const ATOM_AMBIGUITIES = Any[
+    SA.affine_map, SA.sdivergence, SA.lorentz_least_squares, SA.conjugation,
+    SA.log_quad_form, SA.lorentz_homogeneous_quadratic, SA.hadamard_product,
+    SA.lorentz_homogeneous_diagonal, SA.lorentz_transform, SA.quad_over_lin,
+]
+
+run_qa(
+    SymbolicAnalysis;
+    Aqua = Aqua,
+    JET = JET,
+    jet = true,
+    aqua_kwargs = (;
+        ambiguities = (; exclude = ATOM_AMBIGUITIES),
+        piracies = (; treat_as_own = SYMBOLIC_OWN),
+    ),
+    jet_kwargs = (; target_modules = (SymbolicAnalysis,), mode = :typo),
+)