gh-35554: Laurent polynomial/series modularization fixes
    
<!-- 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

<!-- Describe your changes here in detail. -->
We remove several obstacles to modularization:
- `sage.data_structures.stream` importing from `sage.combinat.sf`
- eager module-level imports in `sage.rings.bigoh`, importing
`LaurentSeries`, `PuiseuxSeries`, padics.
- `LaurentSeriesRing._element_constructor_` unconditionally importing
`sage.libs.pari.all` just for an `isinstance` test
- import of `factorial` from `sage.functions` (only the version from
`sage.arith` is needed)
- multivariate implementation of Laurent polynomials (with compile-time
dependency on `sage.matrix`) mixed with the univariate implementation

Also adding `# optional` tags for the doctests that depend on
`sage.rings.finite_rings`, `sage.symbolic`.

<!-- Why is this change required? What problem does it solve? -->
Part of:
- #29705
<!-- 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.
- [ ] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] 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: #35554
Reported by: Matthias Köppe
Reviewer(s): Kwankyu Lee, Matthias Köppe

Author: Release Manager

src/sage/combinat/root_system/root_lattice_realization_algebras.py

@@ -1166,13 +1166,13 @@ def expand(self, alphabet):
             TESTS::
 
                 sage: type(p.expand(F.gens()))
-                <class 'sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair'>
+                <class 'sage.rings.polynomial.laurent_polynomial_mpair.LaurentPolynomial_mpair'>
 
                 sage: p = KL.zero()
                 sage: p.expand(F.gens())
                 0
                 sage: type(p.expand(F.gens()))
-                <class 'sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair'>
+                <class 'sage.rings.polynomial.laurent_polynomial_mpair.LaurentPolynomial_mpair'>
             """
             codomain = alphabet[0].parent()
             return codomain.sum(c * prod(X**int(n)

src/sage/data_structures/stream.py

@@ -99,10 +99,12 @@
 from sage.arith.misc import divisors
 from sage.misc.misc_c import prod
 from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.lazy_import import lazy_import
 from sage.combinat.integer_vector_weighted import iterator_fast as wt_int_vec_iter
-from sage.combinat.sf.sfa import _variables_recursive, _raise_variables
 from sage.categories.hopf_algebras_with_basis import HopfAlgebrasWithBasis
 
+lazy_import('sage.combinat.sf.sfa', ['_variables_recursive', '_raise_variables'])
+
 
 class Stream():
     """

src/sage/rings/big_oh.py

@@ -9,15 +9,25 @@
     - `polynomials <../../../polynomial_rings/index.html>`_
 """
 
-import sage.arith.all as arith
-from . import laurent_series_ring_element
-from sage.rings.puiseux_series_ring_element import PuiseuxSeries
-import sage.rings.padics.factory as padics_factory
-import sage.rings.padics.padic_generic_element as padic_generic_element
+from sage.arith.misc import factor
+from sage.misc.lazy_import import lazy_import
+lazy_import('sage.rings.padics.factory', ['Qp', 'Zp'])
+lazy_import('sage.rings.padics.padic_generic_element', 'pAdicGenericElement')
+from sage.rings.polynomial.polynomial_element import Polynomial
+
+try:
+    from .laurent_series_ring_element import LaurentSeries
+except ImportError:
+    LaurentSeries = ()
+
+try:
+    from .puiseux_series_ring_element import PuiseuxSeries
+except ImportError:
+    PuiseuxSeries = ()
+
 from . import power_series_ring_element
 from . import integer
 from . import rational
-from sage.rings.polynomial.polynomial_element import Polynomial
 from . import multi_power_series_ring_element
 
 
@@ -47,41 +57,42 @@ def O(*x, **kwds):
 
     This is also useful to create `p`-adic numbers::
 
-        sage: O(7^6)
+        sage: O(7^6)                                                                    # optional - sage.rings.padics
         O(7^6)
-        sage: 1/3 + O(7^6)
+        sage: 1/3 + O(7^6)                                                              # optional - sage.rings.padics
         5 + 4*7 + 4*7^2 + 4*7^3 + 4*7^4 + 4*7^5 + O(7^6)
 
     It behaves well with respect to adding negative powers of `p`::
 
-        sage: a = O(11^-32); a
+        sage: a = O(11^-32); a                                                          # optional - sage.rings.padics
         O(11^-32)
-        sage: a.parent()
+        sage: a.parent()                                                                # optional - sage.rings.padics
         11-adic Field with capped relative precision 20
 
     There are problems if you add a rational with very negative
     valuation to an `O`-Term::
 
-        sage: 11^-12 + O(11^15)
+        sage: 11^-12 + O(11^15)                                                         # optional - sage.rings.padics
         11^-12 + O(11^8)
 
     The reason that this fails is that the constructor doesn't know
     the right precision cap to use. If you cast explicitly or use
     other means of element creation, you can get around this issue::
 
-        sage: K = Qp(11, 30)
-        sage: K(11^-12) + O(11^15)
+        sage: K = Qp(11, 30)                                                            # optional - sage.rings.padics
+        sage: K(11^-12) + O(11^15)                                                      # optional - sage.rings.padics
         11^-12 + O(11^15)
-        sage: 11^-12 + K(O(11^15))
+        sage: 11^-12 + K(O(11^15))                                                      # optional - sage.rings.padics
         11^-12 + O(11^15)
-        sage: K(11^-12, absprec = 15)
+        sage: K(11^-12, absprec=15)                                                     # optional - sage.rings.padics
         11^-12 + O(11^15)
-        sage: K(11^-12, 15)
+        sage: K(11^-12, 15)                                                             # optional - sage.rings.padics
         11^-12 + O(11^15)
 
     We can also work with `asymptotic expansions`_::
 
-        sage: A.<n> = AsymptoticRing(growth_group='QQ^n * n^QQ * log(n)^QQ', coefficient_ring=QQ); A
+        sage: A.<n> = AsymptoticRing(growth_group='QQ^n * n^QQ * log(n)^QQ',            # optional - sage.symbolic
+        ....:                        coefficient_ring=QQ); A
         Asymptotic Ring <QQ^n * n^QQ * log(n)^QQ * Signs^n> over Rational Field
         sage: O(n)
         O(n)
@@ -137,9 +148,8 @@ def O(*x, **kwds):
                                       "for the maximal ideal (x)")
         return x.parent().completion(x.parent().gen())(0, x.degree(), **kwds)
 
-    elif isinstance(x, laurent_series_ring_element.LaurentSeries):
-        return laurent_series_ring_element.LaurentSeries(x.parent(), 0).\
-            add_bigoh(x.valuation(), **kwds)
+    elif isinstance(x, LaurentSeries):
+        return LaurentSeries(x.parent(), 0).add_bigoh(x.valuation(), **kwds)
 
     elif isinstance(x, PuiseuxSeries):
         return x.add_bigoh(x.valuation(), **kwds)
@@ -148,18 +158,18 @@ def O(*x, **kwds):
         # p-adic number
         if x <= 0:
             raise ArithmeticError("x must be a prime power >= 2")
-        F = arith.factor(x)
+        F = factor(x)
         if len(F) != 1:
             raise ArithmeticError("x must be prime power")
         p, r = F[0]
         if r >= 0:
-            return padics_factory.Zp(p, prec=max(r, 20),
-                                     type='capped-rel')(0, absprec=r, **kwds)
+            return Zp(p, prec=max(r, 20),
+                      type='capped-rel')(0, absprec=r, **kwds)
         else:
-            return padics_factory.Qp(p, prec=max(r, 20),
-                                     type='capped-rel')(0, absprec=r, **kwds)
+            return Qp(p, prec=max(r, 20),
+                      type='capped-rel')(0, absprec=r, **kwds)
 
-    elif isinstance(x, padic_generic_element.pAdicGenericElement):
+    elif isinstance(x, pAdicGenericElement):
         return x.parent()(0, absprec=x.valuation(), **kwds)
     elif hasattr(x, 'O'):
         return x.O(**kwds)

src/sage/rings/laurent_series_ring.py

@@ -47,6 +47,11 @@
 
 from sage.rings.integer_ring import ZZ
 
+try:
+    from sage.libs.pari.all import pari_gen
+except ImportError:
+    pari_gen = ()
+
 
 def is_LaurentSeriesRing(x):
     """
@@ -483,7 +488,6 @@ def _element_constructor_(self, x, n=0, prec=infinity):
         from sage.rings.polynomial.polynomial_element import Polynomial
         from sage.rings.polynomial.multi_polynomial import MPolynomial
         from sage.structure.element import parent
-        from sage.libs.pari.all import pari_gen
 
         P = parent(x)
         if isinstance(x, self.element_class) and n == 0 and P is self:

src/sage/rings/laurent_series_ring_element.pyx

@@ -1594,8 +1594,8 @@ cdef class LaurentSeries(AlgebraElement):
 
         TESTS::
 
-            sage: y = var('y')
-            sage: f.derivative(y)
+            sage: y = var('y')                                                          # optional - sage.symbolic
+            sage: f.derivative(y)                                                       # optional - sage.symbolic
             Traceback (most recent call last):
             ...
             ValueError: cannot differentiate with respect to y