gh-38986: Allow CRT_list() to be called with one argument
    
As in the title.

Opinion: should we allow `crt()` / `CRT()` to be called with one list
also? Note that currently it is callable with two lists and does the
exact same thing as `CRT_list()`.

Opinion: is returning `Mod(0, 1)` for empty list a sane idea? Problem is
later we may want to implement (pseudocode)

```python
CRT_list([mod(x-1, x^2+1), mod(x+1, x^2-1)])
```

and in that case the correct thing to return is not clear when the list
is empty.

More generally, if it's given elements `x₁ ∈ R/I₁, …, xₙ ∈ R/Iₙ` where
`Iᵢ = xᵢ.parent().defining_ideal()` and all `R = xᵢ.parent()` are the
same for all `i`, it should returns `x ∈
R/(I₁.intersection(I₂).intersection(I₃).….intersection(Iₙ))`. But this
is not well-defined when `values` is empty.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion. (not aware of one)
- [x] I have created tests covering the changes.
- [x] I have updated the documentation and checked the documentation
preview.
    
URL: #38986
Reported by: user202729
Reviewer(s): Travis Scrimshaw, user202729

Author: Release Manager

src/sage/arith/misc.py

@@ -1841,7 +1841,6 @@ def gcd(a, b=None, **kwargs):
         except TypeError:
             return m(py_scalar_to_element(b), **kwargs)
 
-    from sage.structure.sequence import Sequence
     seq = Sequence(py_scalar_to_element(el) for el in a)
     if seq.universe() is ZZ:
         return GCD_list(seq)
@@ -3498,11 +3497,16 @@ def crt(a, b, m=None, n=None):
 CRT = crt
 
 
-def CRT_list(values, moduli):
-    r""" Given a list ``values`` of elements and a list of corresponding
+def CRT_list(values, moduli=None):
+    r"""
+    Given a list ``values`` of elements and a list of corresponding
     ``moduli``, find a single element that reduces to each element of
     ``values`` modulo the corresponding moduli.
 
+    This function can also be called with one argument, each element
+    of the list is a :mod:`modular integer <sage.rings.finite_rings.integer_mod>`.
+    In this case, it returns another modular integer.
+
     .. SEEALSO::
 
         - :func:`crt`
@@ -3529,6 +3533,13 @@ def CRT_list(values, moduli):
         ...
         ValueError: no solution to crt problem since gcd(180,150) does not divide 92-1
 
+    Call with one argument::
+
+        sage: x = CRT_list([mod(2,3),mod(3,5),mod(2,7)]); x
+        23
+        sage: x.parent()
+        Ring of integers modulo 105
+
     The arguments must be lists::
 
         sage: CRT_list([1,2,3],"not a list")
@@ -3564,6 +3575,21 @@ def CRT_list(values, moduli):
         sage: CRT_list([mpz(2),mpz(3),mpz(2)], [mpz(3),mpz(5),mpz(7)])
         23
 
+    Tests for call with one argument::
+
+        sage: x = CRT_list([mod(2,3)]); x
+        2
+        sage: x.parent()
+        Ring of integers modulo 3
+        sage: x = CRT_list([]); x
+        0
+        sage: x.parent()
+        Ring of integers modulo 1
+        sage: x = CRT_list([2]); x
+        Traceback (most recent call last):
+        ...
+        TypeError: if one argument is given, it should be a list of IntegerMod
+
     Make sure we are not mutating the input lists::
 
         sage: xs = [1,2,3]
@@ -3575,14 +3601,26 @@ def CRT_list(values, moduli):
         sage: ms
         [5, 7, 9]
     """
-    if not isinstance(values, list) or not isinstance(moduli, list):
+    if not isinstance(values, list) or (moduli is not None and not isinstance(moduli, list)):
         raise ValueError("arguments to CRT_list should be lists")
-    if len(values) != len(moduli):
-        raise ValueError("arguments to CRT_list should be lists of the same length")
-    if not values:
-        return ZZ.zero()
-    if len(values) == 1:
-        return moduli[0].parent()(values[0])
+    return_mod = moduli is None
+    if return_mod:
+        from sage.rings.finite_rings.integer_mod import IntegerMod_abstract, Mod
+        if not values:
+            return Mod(0, 1)
+        if not all(isinstance(v, IntegerMod_abstract) for v in values):
+            raise TypeError("if one argument is given, it should be a list of IntegerMod")
+        if len(values) == 1:
+            return values[0]
+        moduli = [v.modulus() for v in values]
+        values = [v.lift() for v in values]
+    else:
+        if len(values) != len(moduli):
+            raise ValueError("arguments to CRT_list should be lists of the same length")
+        if not values:
+            return ZZ.zero()
+        if len(values) == 1:
+            return moduli[0].parent()(values[0])
 
     # The result is computed using a binary tree. In typical cases,
     # this scales much better than folding the list from one side.
@@ -3593,7 +3631,10 @@ def CRT_list(values, moduli):
             vs[i] = CRT(vs[i], v, ms[i], m)
             ms[i] = lcm(ms[i], m)
         values, moduli = vs, ms
-    return values[0] % moduli[0]
+    if return_mod:
+        return Mod(values[0], moduli[0])
+    else:
+        return values[0] % moduli[0]
 
 
 def CRT_basis(moduli):