gh-38102: Implement the intrinsic arrangement of a Specht module
    
<!-- ^ Please provide a concise and informative title. -->
<!-- ^ Don't put issue numbers in the title, do this in the PR
description below. -->
<!-- ^ For example, instead of "Fixes #12345" use "Introduce new method
to calculate 1 + 2". -->
<!-- v Describe your changes below in detail. -->
<!-- v Why is this change required? What problem does it solve? -->
<!-- v If this PR resolves an open issue, please link to it here. For
example, "Fixes #12345". -->

We provide an implementation of the hyperplane arrangement of a Specht
module from https://arxiv.org/abs/1910.08302.

### 📝 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

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - #12345: short description why this is a dependency -->
<!-- - #34567: ... -->
    
URL: #38102
Reported by: Travis Scrimshaw
Reviewer(s): Matthias Köppe

Author: Release Manager

src/doc/en/reference/references/index.rst

@@ -6393,6 +6393,11 @@ REFERENCES:
              Journal of Combinatorial Theory, Series A 16.3 (1974), pp 313–333.
              :doi:`10.1016/0097-3165(74)90056-9`
 
+.. [TVY2020] \N. V. Tsilevich, A. M. Vershik, and S. Yuzvinsky.
+             *The intrinsic hyperplane arrangement in an arbitrary irreducible
+             representation of the symmetric group*, Arnold Math. J. **6**
+             no. 2 (2020) pp. 173-187.
+
 .. [TW1980] \A.D. Thomas and G.V. Wood, Group Tables (Exeter: Shiva
             Publishing, 1980)
 

src/sage/combinat/specht_module.py

@@ -850,6 +850,102 @@ def simple_module(self):
             return self
         return SimpleModule(self)
 
+    def intrinsic_arrangement(self, base_ring=None):
+        r"""
+        Return the intrinsic arrangement of ``self``.
+
+        Consider the Specht module `S^{\lambda}` with `\lambda` a
+        (integer) partition of `n` (i.e., `S^{\lambda}` is an `S_n`-module).
+        The *intrinsic arrangement* of `S^{\lambda}` is the central hyperplane
+        arrangement in `S^{\lambda}` given by the hyperplanes `H_{\alpha}`,
+        indexed by a set partition `\alpha` of `\{1, \ldots, n\}` of size
+        `\lambda`, defined by
+
+        .. MATH::
+
+            H_{\alpha} := \bigoplus_{\tau \in T_{\alpha}} (S^{\lambda})^{\tau},
+
+        where `T_{\alpha}` is some set of generating transpositions
+        of the Young subgroup `S_{\alpha}` and `V^{\tau}` denotes the
+        `\tau`-invariant subspace of `V`. (These hyperplanes do not
+        depend on the choice of `T_{\alpha}`.)
+
+        This was introduced in [TVY2020]_ as a generalization of the
+        braid arrangement, which is the case when `\lambda = (n-1, 1)`
+        (equivalently, for the irreducible representation of `S_n`
+        given by the type `A_{n-1}` root system).
+
+        EXAMPLES::
+
+            sage: SGA = SymmetricGroupAlgebra(QQ, 4)
+            sage: SM = SGA.specht_module([2, 1, 1])
+            sage: A = SM.intrinsic_arrangement()
+            sage: A.hyperplanes()
+            (Hyperplane T0 - T1 - 3*T2 + 0,
+             Hyperplane T0 - T1 + T2 + 0,
+             Hyperplane T0 + 3*T1 + T2 + 0,
+             Hyperplane 3*T0 + T1 - T2 + 0)
+            sage: A.is_free()
+            False
+
+        We reproduce Example 3 of [TVY2020]_::
+
+            sage: SGA = SymmetricGroupAlgebra(QQ, 5)
+            sage: for la in Partitions(5):
+            ....:     SM = SGA.specht_module(la)
+            ....:     A = SM.intrinsic_arrangement()
+            ....:     print(la, A.characteristic_polynomial())
+            [5] 1
+            [4, 1] x^4 - 10*x^3 + 35*x^2 - 50*x + 24
+            [3, 2] x^5 - 15*x^4 + 90*x^3 - 260*x^2 + 350*x - 166
+            [3, 1, 1] x^6 - 10*x^5 + 45*x^4 - 115*x^3 + 175*x^2 - 147*x + 51
+            [2, 2, 1] x^5 - 10*x^4 + 45*x^3 - 105*x^2 + 120*x - 51
+            [2, 1, 1, 1] x^4 - 5*x^3 + 10*x^2 - 10*x + 4
+            [1, 1, 1, 1, 1] 1
+
+            sage: A = SGA.specht_module([4, 1]).intrinsic_arrangement()
+            sage: A.characteristic_polynomial().factor()
+            (x - 4) * (x - 3) * (x - 2) * (x - 1)
+        """
+        from sage.geometry.hyperplane_arrangement.arrangement import HyperplaneArrangements
+        from sage.combinat.set_partition import SetPartitions
+        if base_ring is None:
+            base_ring = self.base_ring()
+
+        if self.dimension() == 1:  # corner case
+            HA = HyperplaneArrangements(base_ring, 'T')
+            return HA()
+
+        SGA = self._semigroup_algebra
+        G = self._semigroup
+
+        def t(i, j):
+            ret = [i for i in range(1, SGA.n+1)]
+            ret[i-1] = j
+            ret[j-1] = i
+            return SGA(G(ret))
+
+        # Construct the hyperplanes
+        fixed_spaces = {}
+        norms = []
+        for alpha in SetPartitions(SGA.n, self._diagram.conjugate()):
+            span = []
+            for a in alpha:
+                a = list(a)
+                for i in range(len(a)-1):
+                    elt = t(a[i], a[i+1])
+                    if elt not in fixed_spaces:
+                        fixed_spaces[elt] = self.annihilator_basis([elt - SGA.one()], side='left')
+                    span.extend(fixed_spaces[elt])
+            H = self.echelon_form(span)
+            N = matrix([v.to_vector() for v in H]).right_kernel_matrix()
+            assert N.nrows() == 1
+            norms.append(N[0])
+
+        # Convert the data to an arrangement
+        HA = HyperplaneArrangements(base_ring, tuple([f'T{i}' for i in range(self.dimension())]))
+        return HA([[0] + list(N) for N in norms])
+
 
 class MaximalSpechtSubmodule(SymmetricGroupRepresentation, SubmoduleWithBasis):
     r"""

src/sage/geometry/hyperplane_arrangement/arrangement.py

@@ -952,11 +952,19 @@ def characteristic_polynomial(self):
             ....:     m_perm = matrix(m_perm).transpose()
             ....:     charpoly = H(m_perm.rows()).characteristic_polynomial()
             ....:     assert charpoly == expected_charpoly
+
+        Check the corner case of the empty arrangement::
+
+            sage: E = H()
+            sage: E.characteristic_polynomial()
+            1
         """
         from sage.rings.polynomial.polynomial_ring import polygen
         x = polygen(QQ, 'x')
         if self.rank() == 1:
             return x**(self.dimension() - 1) * (x - len(self))
+        if self.rank() == 0:
+            return x ** 0
 
         H = self[0]
         R = self.restriction(H)