passagemath-groups 10.5.6__cp311-cp311-macosx_13_0_x86_64.whl → 10.6.31rc3__cp311-cp311-macosx_13_0_x86_64.whl

passagemath_groups-10.6.31rc3.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: passagemath-groups
+Version: 10.6.31rc3
+Summary: passagemath: Groups and Invariant Theory
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-categories==10.6.31rc3
+Requires-Dist: passagemath-gap==10.6.31rc3
+Requires-Dist: passagemath-modules==10.6.31rc3
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+Provides-Extra: coxeter3
+Requires-Dist: passagemath-coxeter3; extra == "coxeter3"
+Provides-Extra: gap
+Provides-Extra: additive
+Provides-Extra: affine
+Provides-Extra: lie
+Provides-Extra: matrix
+Provides-Extra: permutation
+Provides-Extra: presentation
+Provides-Extra: representations
+Requires-Dist: passagemath-combinat; extra == "representations"
+Provides-Extra: semigroups
+Requires-Dist: passagemath-combinat; extra == "semigroups"
+Provides-Extra: standard
+Requires-Dist: passagemath-groups[additive,matrix,representations,semigroups]; extra == "standard"
+
+=====================================================================
+ passagemath: Groups and Invariant Theory
+=====================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable package ``passagemath-groups`` a distribution of a part of the Sage Library.  It provides a small subset of the modules of the Sage library ("sagelib", ``passagemath-standard``) for computations with groups.
+
+
+What is included
+----------------
+
+* `Groups <https://passagemath.org/docs/latest/html/en/reference/groups/index.html>`_
+
+* see https://github.com/passagemath/passagemath/blob/main/pkgs/sagemath-groups/MANIFEST.in

passagemath_groups-10.6.31rc3.dist-info/RECORD

@@ -0,0 +1,39 @@
+passagemath_groups.dylibs/libreadline.8.2.dylib,sha256=72suzcaXCcybK0QXegE7UE0RQBlgvEX4IdQPNglBzrQ,300032
+passagemath_groups.dylibs/libz.1.3.1.dylib,sha256=9Hhgm_e9pvI1VtfNcMqL7YjAakyzlSuGRZcR-jAkNUA,128928
+passagemath_groups.dylibs/libgap.10.dylib,sha256=MQSc4m9xKmpsJsFc0NHtvKdAudRuzEep1R2LNM6k4kM,2524976
+passagemath_groups.dylibs/libgmp.10.dylib,sha256=fu542UCvo3ZacIgrGLQN4qezlyObM_Gyi6lasM72Ysk,510784
+passagemath_groups-10.6.31rc3.dist-info/RECORD,,
+passagemath_groups-10.6.31rc3.dist-info/WHEEL,sha256=RyxoEM-DdYra2rgZTpxdiJkmjbwgUQ_Obk5UCeDLiEQ,137
+passagemath_groups-10.6.31rc3.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_groups-10.6.31rc3.dist-info/METADATA,sha256=wUlLpHzoPm_PIKLPS0jXnNzOWhh-_2HjvD92VXMscxQ,5183
+sage/all__sagemath_groups.py,sha256=JOSY5oJmS67eaWpSs14SBcD7be6NMKH05esJQj8sNOI,525
+sage/groups/finitely_presented.py,sha256=hLccjNjrj880fFeiLu9W7Z7Xz1HewuyJTVKNWrUsVMI,70042
+sage/groups/fqf_orthogonal.py,sha256=8cx71JJorwsFoSPzVLBg1rI_dA9dfGeWDqA6GAuqRh8,20181
+sage/groups/free_group.py,sha256=iMxfq5y8gA91i7XdpCmlL2N-5s2h_oYYohITmhMpVXo,29468
+sage/groups/all__sagemath_groups.py,sha256=g4HxEDA-YDJcTYHqA5pGLBIy7gpzg-BEVb2Jn7mTJD8,1147
+sage/groups/artin.py,sha256=CQHII1jKlBJZ_3GEyH-D22lS06prmIYcagTE7eg_RKc,41353
+sage/groups/finitely_presented_named.py,sha256=dKB2M78fw5W7RTHCGy-VB_X9co9UbFcQQYSdBr945Rc,20597
+sage/groups/all.py,sha256=ia6P1nJW_QxBEPMNKdT6ZE8v7J0z8qlMbX2uD3lBJU8,229
+sage/groups/raag.py,sha256=WbkPRhwCopLc2PtJ_Zcy_QASzsHcsp84_fM1x_dUcWw,28842
+sage/groups/cubic_braid.py,sha256=LEStrE9YiJAb5acsybhoQhth5fh-wbtn7uLjYyLoO1o,86974
+sage/groups/group_semidirect_product.py,sha256=7XqgwRR8i-KAWQdRXE8uoNbYDG-mDTqFw2uyqhDGCwY,17910
+sage/groups/cactus_group.py,sha256=O0FTBvGw8y3nRSR1aGPn5FdEv3jILG7QK_g_lZYdLPc,32895
+sage/groups/braid.py,sha256=6LyEbj9KCOyR7v1HhHWYyd62XqGSHcIOQVQF_TuWCXk,140495
+sage/groups/finitely_presented_catalog.py,sha256=Ylc_cx0Sv6eKH9J-n4xotqWK0Hc4pNrwZ3iRPe-gh1s,1251
+sage/groups/group_exp.py,sha256=KjhnaTnqnNKvBmYZJEbUge2-RydGSkued1JFXSLzeoo,11190
+sage/groups/kernel_subgroup.py,sha256=hZVsh5UYfq6MPxekXwlRuQyPuHq0Fk6SlNnN-5Yja6A,7706
+sage/groups/lie_gps/catalog.py,sha256=O5ub0bmV3z8tvJEFjxhgjIz4Zff8rJksOe5VQp0py0o,363
+sage/groups/lie_gps/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/lie_gps/nilpotent_lie_group.py,sha256=6VEgyU0U4ERif179dC1JWBdxO1PM6ZJ4d7Rc7dLkZmY,32506
+sage/groups/misc_gps/misc_groups.py,sha256=W2eH0XFqltL2-g7suj4vS8-klTYW4bTFmoWJ6ciR0-s,346
+sage/groups/misc_gps/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/misc_gps/misc_groups_catalog.py,sha256=TbpMPXGhwFpeOMlXdwdIGItBLV0XSvfN4oQRbKbMK9o,1627
+sage/groups/abelian_gps/all.py,sha256=yQQEiBWy_vtucLyFb_q1OIqgiC_DIE9KUzNWpdGTa4A,906
+sage/groups/semimonomial_transformations/semimonomial_transformation.cpython-311-darwin.so,sha256=FgGIWI8YCRssC-dQ_Uv_WPFRkHenjOeL1O3ls518hEQ,131976
+sage/groups/semimonomial_transformations/semimonomial_transformation.pyx,sha256=9j9eS_uZYdCUQrTJDs4VhpO_7SeSzXdnzh0cACFNtkk,11298
+sage/groups/semimonomial_transformations/all.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/groups/semimonomial_transformations/semimonomial_transformation_group.py,sha256=QflEYRK_oDUf8axx4kwcUR4aMOQNmE_faY1lzOdrAvQ,18312
+sage/groups/semimonomial_transformations/semimonomial_transformation.pxd,sha256=wivg7LyXn_ZMrADRUmabPEYNitTRZCvs2htLN3E0v9g,297
+sage/geometry/all__sagemath_groups.py,sha256=-vXQHOTG46Zum7Q6k0kcJO43yJo09AIX-El8fzXA7eI,45
+sage/geometry/palp_normal_form.pyx,sha256=HfDpZHxffoxG2pxTrXO0ucRlEDZcrtzHBoZ0CoHm5lI,17498
+sage/geometry/palp_normal_form.cpython-311-darwin.so,sha256=6GR7I1FSlnhEauQM7r6UOpJl8fr9WWKQRDNg1ZEyxK0,227760

{passagemath_groups-10.5.6.dist-info → passagemath_groups-10.6.31rc3.dist-info}/WHEEL

@@ -1,5 +1,6 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_13_0_x86_64
+Generator: delocate 0.13.0
 

sage/all__sagemath_groups.py

@@ -1,4 +1,5 @@
 # sage_setup: distribution = sagemath-groups
+# delvewheel: patch
 r"""
 Top level of the distribution package sagemath-groups
 
@@ -9,8 +10,8 @@ This distribution makes the following feature available::
     FeatureTestResult('sage.groups', True)
 """
 
-from .all__sagemath_modules import *
 from .all__sagemath_gap import *
+from .all__sagemath_modules import *
 
 try:  # extra
     from sage.all__sagemath_combinat import *

sage/geometry/palp_normal_form.pyx

@@ -198,7 +198,7 @@ def _palp_PM_max(Matrix_integer_dense PM, check=False):
         else:
             S[i] = i + 1
 
-    cdef int l, np, cf, ccf, n_s_bar, d1, v0, vc, vj
+    cdef int l, cf, ccf, n_s_bar, d1, v0, vc, vj
     cdef list l_r
 
     # We determine the other rows of PM_max in turn by use of perms and

sage/groups/all__sagemath_groups.py

@@ -10,10 +10,6 @@ from sage.groups.all__sagemath_gap import *
 
 from sage.misc.lazy_import import lazy_import
 
-lazy_import('sage.groups.class_function', 'ClassFunction')
-
-lazy_import('sage.groups.conjugacy_classes', ['ConjugacyClass', 'ConjugacyClassGAP'])
-
 lazy_import('sage.groups.free_group', 'FreeGroup')
 lazy_import('sage.groups.braid', 'BraidGroup')
 lazy_import('sage.groups.cubic_braid', 'CubicBraidGroup')

sage/groups/artin.py

@@ -10,10 +10,17 @@ of the corresponding Coxeter group.
 AUTHORS:
 
 - Travis Scrimshaw (2018-02-05): Initial version
+- Travis Scrimshaw (2025-01-30): Allowed general construction; implemented
+  general Burau representation
+
+.. TODO::
+
+    Implement affine type Artin groups with their well-known embeddings into
+    the classical braid group.
 """
 
 # ****************************************************************************
-#       Copyright (C) 2018 Travis Scrimshaw <tcscrims at gmail.com>
+#       Copyright (C) 2018-2025 Travis Scrimshaw <tcscrims at gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -27,6 +34,7 @@ from sage.combinat.root_system.coxeter_group import CoxeterGroup
 from sage.groups.free_group import FreeGroup
 from sage.groups.finitely_presented import FinitelyPresentedGroup, FinitelyPresentedGroupElement
 from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
 from sage.rings.infinity import Infinity
 from sage.structure.richcmp import richcmp, rich_to_bool
 from sage.structure.unique_representation import UniqueRepresentation
@@ -62,7 +70,7 @@ class ArtinGroupElement(FinitelyPresentedGroupElement):
             sage: b._latex_()                                                           # needs sage.rings.number_field
             '\\sigma_{1}\\sigma_{2}\\sigma_{3}\\sigma_{1}^{-1}\\sigma_{2}\\sigma_{3}^{-1}'
 
-            sage: # needs sage.graphs
+            sage: # needs sage.combinat sage.graphs
             sage: B = BraidGroup(4)
             sage: b = B([1, 2, 3, -1, 2, -3])
             sage: b._latex_()
@@ -93,7 +101,7 @@ class ArtinGroupElement(FinitelyPresentedGroupElement):
             sage: b.exponent_sum()
             0
 
-            sage: # needs sage.graphs
+            sage: # needs sage.combinat sage.graphs
             sage: B = BraidGroup(5)
             sage: b = B([1, 4, -3, 2])
             sage: b.exponent_sum()
@@ -127,6 +135,8 @@ class ArtinGroupElement(FinitelyPresentedGroupElement):
             [ a -a  1]
             sage: b.coxeter_group_element().reduced_word()
             [1, 2, 3, 2]
+
+            sage: # neeeds sage.combinat sage.rings.number_field
             sage: A.<s1,s2,s3> = ArtinGroup(['A',3])
             sage: c = s1 * s2 *s3
             sage: c1 = c.coxeter_group_element(); c1
@@ -161,7 +171,157 @@ class ArtinGroupElement(FinitelyPresentedGroupElement):
             W = self.parent().coxeter_group()
         s = W.simple_reflections()
         In = W.index_set()
-        return W.prod(s[In[abs(i)-1]] for i in self.Tietze())
+        return W.prod(s[In[abs(i) - 1]] for i in self.Tietze())
+
+    def burau_matrix(self, var='t'):
+        r"""
+        Return the Burau matrix of the Artin group element.
+
+        Following [BQ2024]_, the (generalized) Burau representation
+        of an Artin group is defined by deforming the reflection
+        representation of the corresponding Coxeter group. However,
+        we substitute `q \mapsto -t` from [BQ2024]_ to match one of
+        the unitary (reduced) Burau representations of the braid group
+        (see :meth:`sage.groups.braid.Braid.burau_matrix()` for details.)
+
+        More precisely, let `(m_{ij})_{i,j \in I}` be the
+        :meth:`Coxeter matrix<coxeter_matrix>`. Then the action is
+        given on the basis `(\alpha_1, \ldots \alpha_n)` (corresponding
+        to the reflection representation of the corresponding
+        :meth:`Coxeter group<coxeter_group>`) by
+
+        .. MATH::
+
+            \sigma_i(\alpha_j) = \alpha_j
+              - \langle \alpha_i, \alpha_j \rangle_q \alpha_i,
+            \qquad \text{ where }
+            \langle \alpha_i, \alpha_j \rangle_q := \begin{cases}
+             1 + t^2 & \text{if } i = j, \\
+             -2 t \cos(\pi/m_{ij}) & \text{if } i \neq j.
+            \end{cases}.
+
+        By convention `\cos(\pi/\infty) = 1`. Note that the inverse of the
+        generators act by `\sigma_i^{-1}(\alpha_j) = \alpha_j - q^{-2}
+        \langle \alpha_j, \alpha_i \rangle_q \alpha_i`.
+
+        INPUT:
+
+        - ``var`` -- string (default: ``'t'``); the name of the
+          variable in the entries of the matrix
+
+        OUTPUT:
+
+        The Burau matrix of the Artin group element over the Laurent
+        polynomial ring in the variable ``var``.
+
+        EXAMPLES::
+
+            sage: A.<s1,s2,s3> = ArtinGroup(['B',3])
+            sage: B1 = s1.burau_matrix()
+            sage: B2 = s2.burau_matrix()
+            sage: B3 = s3.burau_matrix()
+            sage: [B1, B2, B3]
+            [
+            [-t^2    t    0]  [   1    0    0]  [   1    0    0]
+            [   0    1    0]  [   t -t^2  a*t]  [   0    1    0]
+            [   0    0    1], [   0    0    1], [   0  a*t -t^2]
+            ]
+            sage: B1 * B2 * B1 == B2 * B1 * B2
+            True
+            sage: B2 * B3 * B2 * B3 == B3 * B2 * B3 * B2
+            True
+            sage: B1 * B3 == B3 * B1
+            True
+            sage: (~s1).burau_matrix() * B1 == 1
+            True
+
+        We verify the example in Theorem 4.1 of [BQ2024]_::
+
+            sage: A.<s1,s2,s3,s4> = ArtinGroup(['A', 3, 1])
+            sage: [g.burau_matrix() for g in A.gens()]
+            [
+            [-t^2    t    0    t]  [   1    0    0    0]  [   1    0    0    0]
+            [   0    1    0    0]  [   t -t^2    t    0]  [   0    1    0    0]
+            [   0    0    1    0]  [   0    0    1    0]  [   0    t -t^2    t]
+            [   0    0    0    1], [   0    0    0    1], [   0    0    0    1],
+            <BLANKLINE>
+            [   1    0    0    0]
+            [   0    1    0    0]
+            [   0    0    1    0]
+            [   t    0    t -t^2]
+            ]
+            sage: a = s3^2 * s4 * s3 * s2 *s1 * ~s3 * s4 * s3 * s2 * s1^-2 * s4
+            sage: b = s1^2 * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4^-2 * s3
+            sage: alpha = a * s3 * ~a
+            sage: beta = b * s2 * ~b
+            sage: elm = alpha * beta * ~alpha * ~beta
+            sage: print(elm.Tietze())
+            (3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4, 3, -4, 1, 1, -2, -3,
+             -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2, 4, 1, -3, 2, -4, 3, 1,
+             4, 1, -2, -4, -4, 3, 2, -3, 4, 4, 2, -1, -4, -1, -3, 4, -2, 3,
+             -1, -4, 2, -1, -1, 3, 3, 4, 3, 2, 1, -3, 4, 3, 2, -1, -1, 4,
+             -3, -4, 1, 1, -2, -3, -4, 3, -1, -2, -3, -4, -3, -3, 1, 1, -2,
+             4, 1, -3, 2, -4, 3, 1, 4, 1, -2, -4, -4, 3, -2, -3, 4, 4, 2,
+             -1, -4, -1, -3, 4, -2, 3, -1, -4, 2, -1, -1)
+            sage: elm.burau_matrix()
+            [1 0 0 0]
+            [0 1 0 0]
+            [0 0 1 0]
+            [0 0 0 1]
+
+        Next, we show ``elm`` is not the identity by using the embedding of
+        the affine braid group `\widetilde{B}_n \to B_{n+1}`::
+
+            sage: # needs sage.libs.braiding
+            sage: B.<t1,t2,t3,t4> = BraidGroup(5)
+            sage: D = t1 * t2 * t3 * t4^2
+            sage: t0 = D * t3 * ~D
+            sage: t0*t1*t0 == t1*t0*t1
+            True
+            sage: t0*t2 == t2*t0
+            True
+            sage: t0*t3*t0 == t3*t0*t3
+            True
+            sage: T = [t0, t1, t2, t3]
+            sage: emb = B.prod(T[i-1] if i > 0 else ~T[-i-1] for i in elm.Tietze())
+            sage: emb.is_one()
+            False
+
+        Since the Burau representation does not respect the group embedding,
+        the corresponding `B_5` element's Burau matrix is not the identity
+        (Bigelow gave an example of the representation not being faithful for
+        `B_5`, but it is still open for `B_4`)::
+
+            sage: emb.burau_matrix() != 1                                               # needs sage.libs.braiding
+            True
+
+        We also verify the result using the elements in [BQ2024]_ Remark 4.2::
+
+            sage: ap = s3 * s1 * s2 * s1 * ~s3 * s4 * s2 * s3 * s2 * ~s3 * s1^-2 * s4
+            sage: bp = s1 * ~s4 * s1^2 * s3^-2 * ~s2 * s4 * s1 * ~s3 * s2 * ~s4 * s3 * s1 * s4 * s1 * ~s2 * s4^-2 * s3
+            sage: alpha = ap * s3 * ~ap
+            sage: beta = bp * s2 * ~bp
+            sage: elm = alpha * beta * ~alpha * ~beta                                   # needs sage.libs.braiding
+            sage: elm.burau_matrix()                                                    # needs sage.libs.braiding
+            [1 0 0 0]
+            [0 1 0 0]
+            [0 0 1 0]
+            [0 0 0 1]
+
+        REFERENCES:
+
+        - [BQ2024]_
+        """
+        gens, invs = self.parent()._burau_generators
+        MS = gens[0].parent()
+        ret = MS.prod(gens[i-1] if i > 0 else invs[-i-1] for i in self.Tietze())
+
+        if var == 't':
+            return ret
+
+        from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
+        poly_ring = LaurentPolynomialRing(ret.base_ring().base_ring(), var)
+        return ret.change_ring(poly_ring)
 
 
 class FiniteTypeArtinGroupElement(ArtinGroupElement):
@@ -248,6 +408,7 @@ class FiniteTypeArtinGroupElement(ArtinGroupElement):
             sage: A([1,2,1,3,2,1,3,2,3,3,2,3,1,2,3,1,2,3,1,2]).left_normal_form()
             ((s3*(s2*s3*s1)^2*s2*s1)^2, s3*s2)
 
+            sage: # needs sage.combinat
             sage: B = BraidGroup(4)
             sage: b = B([1, 2, 3, -1, 2, -3])
             sage: b.left_normal_form()                                                  # needs sage.libs.braiding
@@ -434,7 +595,7 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
             sage: A1 is A2 and A2 is A3
             True
 
-            sage: ArtinGroup(['A',3]) is BraidGroup(4, 's1,s2,s3')                      # needs sage.rings.number_field
+            sage: ArtinGroup(['A',3]) is BraidGroup(4, 's1,s2,s3')                      # needs sage.combinat sage.rings.number_field
             True
 
             sage: # needs sage.graphs sage.rings.number_field
@@ -461,13 +622,13 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
             from sage.groups.raag import RightAngledArtinGroup
             return RightAngledArtinGroup(coxeter_data.coxeter_graph(), names)
         if not coxeter_data.is_finite():
-            raise NotImplementedError
+            return super().__classcall__(cls, coxeter_data, names)
         if coxeter_data.coxeter_type().cartan_type().type() == 'A':
             from sage.groups.braid import BraidGroup
-            return BraidGroup(coxeter_data.rank()+1, names)
+            return BraidGroup(coxeter_data.rank() + 1, names)
         return FiniteTypeArtinGroup(coxeter_data, names)
 
-    def __init__(self, coxeter_matrix, names):
+    def __init__(self, coxeter_matrix, names) -> None:
         """
         Initialize ``self``.
 
@@ -484,18 +645,20 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
         rels = []
         # Generate the relations based on the Coxeter graph
         I = coxeter_matrix.index_set()
+        gens = free_group.gens()
         for ii, i in enumerate(I):
-            for j in I[ii + 1:]:
+            for jj, j in enumerate(I[ii + 1:], start=ii + 1):
                 m = coxeter_matrix[i, j]
                 if m == Infinity:  # no relation
                     continue
-                elt = [i, j] * m
-                for ind in range(m, 2*m):
-                    elt[ind] = -elt[ind]
-                rels.append(free_group(elt))
+                elt = (gens[ii] * gens[jj]) ** (m // 2)
+                if m % 2 == 1:
+                    elt = elt * gens[ii] * ~gens[jj]
+                elt = elt * (~gens[ii] * ~gens[jj]) ** (m // 2)
+                rels.append(elt)
         FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -630,7 +793,7 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
         return self.element_class(self, x)
 
     @cached_method
-    def an_element(self):
+    def _an_element_(self):
         """
         Return an element of ``self``.
 
@@ -642,7 +805,7 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
         """
         return self.gen(0)
 
-    def some_elements(self):
+    def some_elements(self) -> list:
         """
         Return a list of some elements of ``self``.
 
@@ -687,8 +850,8 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
 
         EXAMPLES::
 
-            sage: A = ArtinGroup(['B',3])                                               # needs sage.rings.number_field
-            sage: A._standard_lift(A.coxeter_group().long_element())                    # needs sage.rings.number_field
+            sage: A = ArtinGroup(['B',3])                                               # needs sage.combinat sage.rings.number_field
+            sage: A._standard_lift(A.coxeter_group().long_element())                    # needs sage.combinat sage.rings.number_field
             s3*(s2*s3*s1)^2*s2*s1
 
             sage: B = BraidGroup(5)
@@ -698,6 +861,154 @@ class ArtinGroup(UniqueRepresentation, FinitelyPresentedGroup):
         """
         return self(self._standard_lift_Tietze(w))
 
+    @lazy_attribute
+    def _burau_generators(self):
+        """
+        The Burau matrices for the generators of ``self`` and their inverses.
+
+        EXAMPLES::
+
+            sage: A = ArtinGroup(['G',2])
+            sage: A._burau_generators
+            [[
+            [-t^2  a*t]  [   1    0]
+            [   0    1], [ a*t -t^2]
+            ],
+             [
+            [ -t^-2 a*t^-1]  [     1      0]
+            [     0      1], [a*t^-1  -t^-2]
+            ]]
+
+            sage: A = ArtinGroup(['H',3])
+            sage: A._burau_generators
+            [[
+            [-t^2    t    0]  [              1               0               0]
+            [   0    1    0]  [              t            -t^2 (1/2*a + 1/2)*t]
+            [   0    0    1], [              0               0               1],
+            <BLANKLINE>
+            [              1               0               0]
+            [              0               1               0]
+            [              0 (1/2*a + 1/2)*t            -t^2]
+            ],
+             [
+            [-t^-2  t^-1     0]
+            [    0     1     0]
+            [    0     0     1],
+            <BLANKLINE>
+            [                 1                  0                  0]
+            [              t^-1              -t^-2 (1/2*a + 1/2)*t^-1]
+            [                 0                  0                  1],
+            <BLANKLINE>
+            [                 1                  0                  0]
+            [                 0                  1                  0]
+            [                 0 (1/2*a + 1/2)*t^-1              -t^-2]
+            ]]
+
+            sage: CM = matrix([[1,4,7], [4,1,10], [7,10,1]])
+            sage: A = ArtinGroup(CM)
+            sage: gens = A._burau_generators[0]; gens
+            [
+            [                -t^2    (E(8) - E(8)^3)*t (-E(7)^3 - E(7)^4)*t]
+            [                   0                    1                    0]
+            [                   0                    0                    1],
+            <BLANKLINE>
+            [                  1                   0                   0]
+            [  (E(8) - E(8)^3)*t                -t^2 (E(20) - E(20)^9)*t]
+            [                  0                   0                   1],
+            <BLANKLINE>
+            [                   1                    0                    0]
+            [                   0                    1                    0]
+            [(-E(7)^3 - E(7)^4)*t  (E(20) - E(20)^9)*t                 -t^2]
+            ]
+            sage: all(gens[i] * A._burau_generators[1][i] == 1 for i in range(3))
+            True
+            sage: B1, B2, B3 = gens
+            sage: (B1 * B2)^2 == (B2 * B1)^2
+            True
+            sage: (B2 * B3)^5 == (B3 * B2)^5
+            True
+            sage: B1 * B3 * B1 * B3 * B1 * B3 * B1 == B3 * B1 * B3 * B1 * B3 * B1 * B3
+            True
+        """
+        data = self.coxeter_type()
+        coxeter_matrix = self.coxeter_matrix()
+        n = coxeter_matrix.rank()
+
+        # Determine the base field
+        if data.is_simply_laced():
+            from sage.rings.integer_ring import ZZ
+            base_ring = ZZ
+        elif data.is_finite():
+            from sage.rings.number_field.number_field import QuadraticField
+            letter = data.cartan_type().type()
+            if letter in ['B', 'C', 'F']:
+                base_ring = QuadraticField(2)
+            elif letter == 'G':
+                base_ring = QuadraticField(3)
+            elif letter == 'H':
+                base_ring = QuadraticField(5)
+            else:
+                from sage.rings.universal_cyclotomic_field import UniversalCyclotomicField
+                base_ring = UniversalCyclotomicField()
+        else:
+            from sage.rings.universal_cyclotomic_field import UniversalCyclotomicField
+            base_ring = UniversalCyclotomicField()
+
+        # Construct the matrices
+        from sage.matrix.args import SparseEntry
+        from sage.matrix.matrix_space import MatrixSpace
+        from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
+        import sage.rings.abc
+        poly_ring = LaurentPolynomialRing(base_ring, 't')
+        q = -poly_ring.gen()
+        MS = MatrixSpace(poly_ring, n, sparse=True)
+        one = MS.one()
+        # FIXME: Hack because there is no ZZ \cup \{ \infty \}: -1 represents \infty
+        if isinstance(base_ring, sage.rings.abc.UniversalCyclotomicField):
+            E = base_ring.gen
+
+            def val(x):
+                if x == -1:
+                    return 2 * q
+                elif x == 1:
+                    return 1 + q**2
+                else:
+                    E2x = E(2 * x)
+                    return q * (E2x + ~E2x)
+        elif isinstance(base_ring, sage.rings.abc.NumberField_quadratic):
+            from sage.rings.universal_cyclotomic_field import UniversalCyclotomicField
+            E = UniversalCyclotomicField().gen
+
+            def val(x):
+                if x == -1:
+                    return 2 * q
+                elif x == 1:
+                    return 1 + q**2
+                else:
+                    return q * base_ring((E(2 * x) + ~E(2 * x)).to_cyclotomic_field())
+        else:
+            def val(x):
+                if x == -1:
+                    return 2 * q
+                elif x == 1:
+                    return 1 + q**2
+                elif x == 2:
+                    return 0
+                elif x == 3:
+                    return q
+                else:
+                    from sage.functions.trig import cos
+                    from sage.symbolic.constants import pi
+                    return q * base_ring(2 * cos(pi / x))
+        index_set = data.index_set()
+        gens = [one - MS([SparseEntry(i, j, val(coxeter_matrix[index_set[i], index_set[j]]))
+                          for j in range(n)])
+                for i in range(n)]
+        invs = [one - q**-2 * MS([SparseEntry(i, j, val(coxeter_matrix[index_set[i], index_set[j]]))
+                                  for j in range(n)])
+                for i in range(n)]
+        return [gens, invs]
+
     Element = ArtinGroupElement
 
 
@@ -754,8 +1065,8 @@ class FiniteTypeArtinGroup(ArtinGroup):
             sage: A.delta()                                                             # needs sage.rings.number_field
             (s2*s1)^3
 
-            sage: B = BraidGroup(5)
-            sage: B.delta()
+            sage: B = BraidGroup(5)                                                     # needs sage.combinat
+            sage: B.delta()                                                             # needs sage.combinat
             s0*s1*s2*s3*s0*s1*s2*s0*s1*s0
         """
         return self._standard_lift(self._coxeter_group.long_element())