gh-35789: more arguments for simplify
    
<!-- Please provide a concise, informative and self-explanatory title.
-->
<!-- Don't put issue numbers in the title. Put it in the Description
below. -->
<!-- For example, instead of "Fixes #12345", use "Add a new method to
multiply two integers" -->

### 📚 Description

We allow a few more arguments to the simplify method.

fixes #32472

<!-- Describe your changes here in detail. -->
<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35789
Reported by: Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/calculus/functional.py

@@ -25,24 +25,40 @@
     sage: expand((x - a)^3)
     -a^3 + 3*a^2*x - 3*a*x^2 + x^3
 """
-
 from sage.structure.element import Expression
 
 
-def simplify(f):
+def simplify(f, algorithm="maxima", **kwds):
     r"""
     Simplify the expression `f`.
 
-    EXAMPLES: We simplify the expression `i + x - x`.
+    See the documentation of the
+    :meth:`~sage.symbolic.expression.Expression.simplify` method of symbolic
+    expressions for details on options.
 
-    ::
+    EXAMPLES:
+
+    We simplify the expression `i + x - x`::
 
         sage: f = I + x - x; simplify(f)
         I
 
     In fact, printing `f` yields the same thing - i.e., the
     simplified form.
+
+    Some simplifications are algorithm-specific::
+
+        sage: x, t = var("x, t")
+        sage: ex = 1/2*I*x + 1/2*I*sqrt(x^2 - 1) + 1/2/(I*x + I*sqrt(x^2 - 1))
+        sage: simplify(ex)
+        1/2*I*x + 1/2*I*sqrt(x^2 - 1) + 1/(2*I*x + 2*I*sqrt(x^2 - 1))
+        sage: simplify(ex, algorithm="giac")
+        I*sqrt(x^2 - 1)
     """
+    try:
+        return f.simplify(algorithm=algorithm, **kwds)
+    except (TypeError, AttributeError):
+        pass
     try:
         return f.simplify()
     except AttributeError:

src/sage/symbolic/expression.pyx

@@ -10617,22 +10617,26 @@ cdef class Expression(Expression_abc):
         else:
             return self
 
-    def simplify(self, algorithm='maxima'):
+    def simplify(self, algorithm='maxima', **kwds):
         """
         Return a simplified version of this symbolic expression.
 
-        .. NOTE::
+        INPUT:
 
-           When using ``algorithm='maxima'``, this just sends the expression to Maxima
-           and converts it back to Sage. When ``algorithm='sympy'``,
-           sympy's simplify method is used.
+        - ``algorithm`` -- one of :
 
-        INPUT:
+            - ``maxima`` : (default) sends the expression to
+              ``maxima`` and converts it back to Sage
 
-        - ``self`` -- an expression with held operations
-        - ``algorithm`` - (default: ``'maxima'``)  one of
-            - ``'maxima'`` - use Maxima (the default)
-            - ``'sympy'`` - use SymPy
+            - ``sympy`` : converts the expression to ``sympy``,
+              simplifies it (passing any optional keyword(s)), and
+              converts the result to Sage
+
+            - ``giac`` : converts the expression to ``giac``,
+              simplifies it, and converts the result to Sage
+
+            - ``fricas`` : converts the expression to ``fricas``,
+              simplifies it, and converts the result to Sage
 
         .. SEEALSO::
 
@@ -10649,11 +10653,21 @@ cdef class Expression(Expression_abc):
             sage: f.simplify()
             x^(-a + 1)*sin(2)
 
-        ::
-
-            sage: expr = (-1/5*(2*sqrt(6)*(sqrt(5) - 5) + 11*sqrt(5) - 11)/(2*sqrt(6)*sqrt(5) - 11))
-            sage: expr.simplify(algorithm='sympy')
-            1/5*sqrt(5) - 1/5
+        Some simplifications are quite algorithm-specific::
+
+            sage: x, t = var("x, t")
+            sage: ex = cos(t).exponentialize()
+            sage: ex = ex.subs((sin(t).exponentialize()==x).solve(t)[0])
+            sage: ex
+            1/2*I*x + 1/2*I*sqrt(x^2 - 1) + 1/2/(I*x + I*sqrt(x^2 - 1))
+            sage: ex.simplify()
+            1/2*I*x + 1/2*I*sqrt(x^2 - 1) + 1/(2*I*x + 2*I*sqrt(x^2 - 1))
+            sage: ex.simplify(algorithm="sympy")
+            I*(x^2 + sqrt(x^2 - 1)*x - 1)/(x + sqrt(x^2 - 1))
+            sage: ex.simplify(algorithm="giac")
+            I*sqrt(x^2 - 1)
+            sage: ex.simplify(algorithm="fricas")  # optional - fricas
+            (I*x^2 + I*sqrt(x^2 - 1)*x - I)/(x + sqrt(x^2 - 1))
 
         TESTS:
 
@@ -10669,16 +10683,16 @@ cdef class Expression(Expression_abc):
             sage: expr = (-1/5*(2*sqrt(6)*(sqrt(5) - 5) + 11*sqrt(5) - 11)/(2*sqrt(6)*sqrt(5) - 11))
             sage: expr.simplify(algorithm='sympy')
             1/5*sqrt(5) - 1/5
-
-
         """
-        if algorithm == 'maxima':
+        if algorithm == "maxima":
             return self._parent(self._maxima_())
-        elif algorithm == 'sympy':
-            return self._sympy_().simplify()._sage_()
-        else:
-            raise NotImplementedError(
-                    "unknown algorithm: '{}'".format(algorithm))
+        if algorithm == "sympy":
+            return self._sympy_().simplify(**kwds)._sage_()
+        if algorithm == "giac":
+            return self._giac_().simplify()._sage_()
+        if algorithm == "fricas":
+            return self._fricas_().simplify()._sage_()
+        raise ValueError(f"algorithm {algorithm} unknown to simplify")
 
     def simplify_full(self):
         """