From 35f35835c4d3f4df4a05aa8251530f062505a066 Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
Date: Fri, 20 Feb 2026 15:33:55 -0500
Subject: [PATCH] mjo/clan/clan.py: Vinberg cone automorphisms (WIP)

This proof-of-concept is mostly working, but the tests are crashing
for some reason.
---
 mjo/clan/clan.py | 99 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/mjo/clan/clan.py b/mjo/clan/clan.py
index 9435f73..bec08fa 100644
--- a/mjo/clan/clan.py
+++ b/mjo/clan/clan.py
@@ -789,6 +789,105 @@ class VinbergClan(NormalDecomposition):
         """
         return f"Vinberg clan over {self.base_ring()}"
 
+    def random_triangular_cone_automorphism(self):
+        r"""
+        Generate a random triangular automorphism of the Vinberg cone.
+
+        Elliot Herrington in his thesis "Highly symmetric homogeneous
+        Kobayashi-hyperbolic manifolds" gives a formula for the
+        connected component of the identity in the group of triangular
+        automorphisms. This won't generate the whole group, but it's
+        a good start.
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        R = self.base_ring()
+        MS = MatrixSpace(R, 5)
+
+        # Herrington's notation for triangular automorphisms
+        a = R._random_nonzero_element().abs()
+        b = R.random_element()
+        c = R.random_element()
+        e = R._random_nonzero_element()
+        i = R._random_nonzero_element()
+
+        T = MS([ [a**2, b**2, c**2, 2*a*b, 2*a*c],
+                 [   0, e**2,    0,     0,     0],
+                 [   0,    0, i**2,     0,     0],
+                 [   0,  b*e,    0,   a*e,     0],
+                 [   0,    0,  c*i,     0,   a*i] ])
+
+        from mjo.clan.clan_operator import ClanOperator
+        return ClanOperator(self, self, T)
+
+
+    def random_isotropy_cone_automorphism(self):
+        r"""
+        Generate a random automorphism of the Vinberg cone that
+        fixes the unit element.
+
+        This is effectively a guess, based on the work done by Ishi
+        and Koufany for the **dual** Vinberg cone.
+
+        TESTS:
+
+        Evidence for the conjecture that these preserve the two trace
+        inner products::
+
+            sage: C = VinbergClan()
+            sage: isinstance(C, Clan)
+            True
+            sage: A = C.random_isotropy_cone_automorphism()
+            sage: A(C.one()) == C.one()
+            True
+            sage: x = C.random_element()
+            sage: y = C.random_element()
+            sage: x.inner_product(y) == A(x).inner_product(A(y))
+            True
+            sage: expected = x.inner_product_vinberg(y)
+            sage: actual = A(x).inner_product_vinberg(A(y))
+            sage: actual == expected
+            True
+
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        MS = MatrixSpace(self.base_ring(), 5)
+        # Now the generators of the isotropy subgroup (inspired by
+        # Ishi/Kounfany, but basically just guessing and checking).
+        #
+        # x21 -> -x21
+        g1 = MS([ [1, 0,0,0,0],
+                  [0,-1,0,0,0],
+                  [0, 0,1,0,0],
+                  [0, 0,0,1,0],
+                  [0, 0,0,0,1] ])
+        # x31 -> -x31
+        g2 = MS([ [1,0,0, 0,0],
+                  [0,1,0, 0,0],
+                  [0,0,1, 0,0],
+                  [0,0,0,-1,0],
+                  [0,0,0, 0,1] ])
+        # x32 <-> x33, x21 <-> x31
+        g3 = MS([ [1,0,0,0,0],
+                  [0,0,0,1,0],
+                  [0,0,0,0,1],
+                  [0,1,0,0,0],
+                  [0,0,1,0,0] ])
+
+        # Group is order eight?
+        gs = [MS.one(), g1, g2, g3, g1*g2, g1*g3, g3*g1, g3*g2]
+
+        from random import choice
+        from mjo.clan.clan_operator import ClanOperator
+        return ClanOperator(self, self, choice(gs))
+
+    def random_cone_automorphism(self):
+        r"""
+        Generate a random automorphism of the Vinberg cone.
+        """
+        T = self.random_triangular_cone_automorphism()
+        K = self.random_isotropy_cone_automorphism()
+        return T*K
+
     def from_matrices(self, A, B):
         r"""
         Construct an element of this clan from a pair of
-- 
2.51.0