gh-39626: Fixed issue the caused random element in for Tuples to stall by adding unrank method.
    
Fixes #39534. There was an issue in Tuples causing random element to
stall. It was stalling because Tuples did not have an efficient method
of getting the i-th element without iterating through the entire set. To
fix this an unrank method was added to Tuples. This method was based on
the unrank method found in
src\sage\categories\finite_enumerated_sets.py. This unrank method
creates each tuple in a similar way to how numbers in some base are
created. Also added documentation, an example, and various tests to make
sure the function is working correctly.

### 📝 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.
- [X] I have created tests covering the changes.
- [X] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies
    
URL: #39626
Reported by: Noel-Roemmele
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/categories/enumerated_sets.py

@@ -432,7 +432,7 @@ def __getitem__(self, i):
                 sage: P[-1]
                 Traceback (most recent call last):
                 ...
-                NotImplementedError: cannot list an infinite set
+                ValueError: infinite list
 
             ::
 
@@ -457,11 +457,28 @@ def __getitem__(self, i):
                 [1]
                 sage: F[1::2]
                 [2]
+
+            TESTS:
+
+            Verify that an infinite index raises an error::
+
+                sage: F = FiniteEnumeratedSet([1,2,3,4,5])
+                sage: F[oo]
+                Traceback (most recent call last):
+                ...
+                TypeError: unable to coerce <class 'sage.rings.infinity.PlusInfinity'>
+                to an integer
             """
+            from sage.rings.infinity import Infinity
             if isinstance(i, slice):
                 return self.unrank_range(i.start, i.stop, i.step)
+            i = Integer(i)
+            if i < 0:
+                i += self.cardinality()
             if i < 0:
-                return self.list()[i]
+                raise IndexError("index out of range")
+            if i is Infinity:
+                raise ValueError("infinite list")
             return self.unrank(i)
 
         def __len__(self):

src/sage/combinat/tuple.py

@@ -90,6 +90,142 @@ def __repr__(self):
         """
         return "Tuples of %s of length %s" % (self.S, self.k)
 
+    def unrank(self, i):
+        """
+        Return the `i`-th element of the set of Tuples.
+
+        INPUT:
+
+        - ``i`` -- integer between `0` and `n-1`, where `n` is the cardinality
+          of this set
+
+        EXAMPLES::
+
+            sage: T = Tuples(range(7), 6)
+            sage: T[73451]
+            (0, 0, 1, 4, 2, 4)
+
+        TESTS:
+
+        Verify that :meth:`unrank` is giving the correct result::
+
+            sage: T = Tuples(range(4), 5)
+            sage: all(T[i] == x for i,x in enumerate(T))
+            True
+
+        Verify that :meth:`unrank` is fast for large inputs::
+
+            sage: Tuples(range(3), 30)[10^12]
+            (1, 0, 0, 1, 1, 1, 2, 0, 1, 2, 0, 1, 1, 0, 2, 1, 1, 0, 1, 2, 1, 2,
+            1, 1, 0, 1, 0, 0, 0, 0)
+
+        Verify that :meth:`unrank` normalizes ``i``::
+
+            sage: T = Tuples(range(3), 2)
+            sage: T[QQ(4/2)]
+            (2, 0)
+            sage: T[QQ(1/2)]
+            Traceback (most recent call last):
+            ...
+            TypeError: no conversion of this rational to integer
+
+        Verify that :meth:`unrank` throws an error when ``i`` is out of bounds::
+
+            sage: T = Tuples(range(3), 3)
+            sage: T[27]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=27) is greater than or equal to the cardinality
+            sage: T[-28]
+            Traceback (most recent call last):
+            ...
+            IndexError: index out of range
+
+        Verify that :meth:`unrank` works correctly for Tuples where `k = 1`::
+
+            sage: T = Tuples(range(6), 1)
+            sage: T[5]
+            (5,)
+
+        Verify that :meth:`unrank` works when called directly::
+
+            sage: T = Tuples(range(4), 3)
+            sage: T.unrank(19)
+            (3, 0, 1)
+            sage: T.unrank(-1)
+            Traceback (most recent call last):
+            ...
+            IndexError: index out of range
+
+        Verify that :meth:`unrank` works with non-integer sets::
+
+            sage: T = Tuples(['a', 'b', 'c'], 3)
+            sage: T[15]
+            ('a', 'c', 'b')
+            sage: T = Tuples([None, 1, ZZ, GF(2)], 5)
+            sage: T[30]
+            (Integer Ring, Finite Field of size 2, 1, None, None)
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| < 1`::
+
+            sage: T = Tuples([],5)
+            sage: T[0]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=0) is greater than or equal to the cardinality
+            sage: list(T)
+            []
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| = 1`::
+
+            sage: T = Tuples([1],5)
+            sage: T[0]
+            (1, 1, 1, 1, 1)
+
+        Verify that :meth:`unrank` gives the correct answer when `k = 0`::
+
+            sage: T = Tuples(range(6), 0)
+            sage: list(T)
+            [()]
+            sage: T[0]
+            ()
+            sage: T[1]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=1) is greater than or equal to the cardinality
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| < 1` and
+        `k = 0`::
+
+            sage: T = Tuples(range(0), 0)
+            sage: T[0]
+            ()
+            sage: T[-1]
+            ()
+            sage: T[1]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=1) is greater than or equal to the cardinality
+
+        Verify that :issue:`39534` has been fixed::
+
+            sage: T = Tuples(range(3), 30).random_element()
+            sage: all(v in range(3) for v in T)
+            True
+            sage: len(T)
+            30
+        """
+        i = ZZ(i)
+        if i < 0:
+            raise IndexError("index out of range")
+        if i >= self.cardinality():
+            raise IndexError("index i (={}) is greater than or equal to the cardinality"
+                             .format(i))
+        ts = len(self.S)
+        if ts <= 1:
+            return tuple(self.S[0] for _ in range(self.k))
+        return tuple(i.digits(ts, self.S, self.k))
+
     def __iter__(self):
         """
         EXAMPLES::

src/sage/sets/finite_enumerated_set.py

@@ -288,7 +288,7 @@ def unrank(self, i):
             sage: S[-4]
             Traceback (most recent call last):
             ...
-            IndexError: list index out of range
+            IndexError: index out of range
         """
         return self._elements[i]