.. _SectGrpLieCST: .. _cst-presentations: Curtis--Steinberg--Tits Presentations ===================================== In Magma a group of Lie type over a field is defined by generators which satisfy Steinberg relations (see section :ref:`SubsectGrpLieSteinberg`). In particular the unipotent elements :math:`x_\alpha(a)` are parametrised by the field and the torus elements are parametrised by the non-zero elements of the field. However, the number of generators and relations can be reduced considerably using a form of the Curtis–Steinberg–Tits (CST) presentation :cite:`babai-etal-1997`. This section describes basic functions to compute with highest weight representations of finite groups of Lie type defined by CST presentations: see the previous section and Chapter :ref:`ChapLieReps` for more functions for highest weight representations. Currently this functionality is available only for algebraically simple finite reductive groups with a simply connected root datum: all untwisted types and the twisted groups of types :math:`{}^2\hbox{A}_n` (:math:`n` odd), :math:`{}^2\hbox{D}_n`, :math:`{}^3\hbox{D}_4` and :math:`{}^2\hbox{E}_6`. Let :math:`G(q)` be a simply connected group defined over the field :math:`{\mathbb{F}}_q`, let :math:`\Delta = \{\alpha_1,\dots,\alpha_d\}` be a base of simple roots and let :math:`B` be a basis for :math:`{\mathbb{F}}_q` regarded as a vector space over its prime field. The CST presentation can be described as follows. For :math:`i < j`, let :math:`\Phi_{ij}` be the subsystem spanned by :math:`\alpha_i` and :math:`\alpha_j`, put :math:`\Psi = \bigcup_{i,j}\Phi_{ij}` and :math:`\Upsilon = \bigcup_{i,j}\{\,(\alpha,\beta) \in \Phi_{ij}\times \Phi_{ij} \mid \alpha\ne \pm \beta\,\}`. Then :math:`G(q)` has a presentation with generators :math:`x_\alpha(a)` for :math:`\alpha \in \Psi` and :math:`a\in B`. It is enough to require relations :math:`x_\alpha(a)x_\alpha(b) = x_\alpha(a+b)` for :math:`\alpha\in \Psi` and relations .. math:: [x_\alpha(a),x_\beta(b)] = \prod_{i,j > 0} x_{i\alpha+j\beta}(C_{ij\alpha\beta}a^ib^j)\ for :math:`(\alpha,\beta)\in\Upsilon` and :math:`a,b\in B`. (If :math:`G(q)` were not simply connected we would need additional generators for the torus.) In Magma, the CST generators are represented by a pair of sequences :math:`X`, :math:`Y` .. math:: \eqalignno{ X &= [[x_\alpha(a) \mid a \in B] \mid \alpha \in \Psi ]\quad\hbox{and}\cr Y &= [[x_{-\alpha}(a) \mid a \in B] \mid \alpha \in \Psi],\cr} where :math:`X` (resp. :math:`Y`) may be regarded as a matrix whose rows are indexed by positive (resp. negative) roots and whose columns are indexed by basis elements of :math:`{\mathbb{F}}_q`. For many functions there are optional parameters ``OnlySimple`` and ``GS``. If ``OnlySimple`` is ``true``, only the CST generators :math:`x_\alpha(a)` where :math:`\pm\alpha` is a simple root are used. (The function ``ExtendGeneratorList`` can be used to extend the simple generators to the full collection of CST generators.) The functions generally use the default signs for the extraspecial pairs (Section :ref:`SectRDConstr`). However, if ``GS`` is ``true``, the root order and signs used by Gilkey and Seitz :cite:`gilkey-seitz-1988` are used; this only applies to groups of types :math:`\hbox{F}_4` and :math:`\hbox{G}_2`. .. magma:function:: CST\_Generators(t,r,q,w) :input_types: MonStgElt, RngIntElt, RngIntElt, SeqEnum :output_types: SeqEnum, SeqEnum :parameters: GS : BoolElt : \texttt{false}; OnlySimple : BoolElt : \texttt{false}; Weyl : BoolElt : \texttt{false}; Signs : Any : 1 The Curtis–Steinberg–Tits generators for the group of Lie type :math:`t` and rank :math:`r` over the field :math:`{\mathbb{F}}_q` in the irreducible representation with highest weight :math:`w`. If ``OnlySimple`` is ``true``, only generators for the simple roots are returned. If ``Weyl`` is ``true``, the Weyl representation of highest weight :math:`w` is returned. If :math:`w` is the empty sequence, the standard representation is used. The parameter ``Signs`` can take the values described in Section :ref:`SectRDConstr`. .. magma:function:: CST\_Presentation(t,r,q) :input_types: MonStgElt, RngIntElt, RngIntElt :output_types: GrpSLP, SeqEnum :parameters: GS : BoolElt : \texttt{false} The Curtis–Steinberg–Tits relations for the simply connected group of Lie type :math:`t` and rank :math:`r` over the field :math:`{\mathbb{F}}_q`. The function returns an SLP-group :math:`G` and a sequence containing the relations as straight-line programs in :math:`G`. If ``GS`` is ``true``, the Gilkey–Seitz structure constants are used and the simple roots for groups of type :math:`\hbox{G}_2` are swapped. .. magma:function:: CST\_VerifyPresentation(t,r,q,X,Y) :input_types: MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum :output_types: BoolElt, RngIntElt :parameters: GS : BoolElt : \texttt{false} Given Curtis–Steinberg–Tits generators :math:`X`, :math:`Y` for a simply connected group of Lie type :math:`t` and rank :math:`r` over the field :math:`{\mathbb{F}}_q`, verify that the generators satisfy the relations. Set ``GS`` to ``true`` if the Gilkey–Seitz conventions hold for :math:`X` and :math:`Y`. .. magma:example:: Example: CST Pres :label: CSTPres Verify that the CST generators for the 273-dimensional representation of :math:`{\rm F}_4(5)` satisfy the CST relations but not the relations for :math:`{\rm F}_4(5)`. When the relations are not satisfied, the index of the first relation which fails is returned. .. code-block:: magma > X,Y := CST_Generators("F",4,5,[0,0,1,0]); > CST_VerifyPresentation("F",4,5,X,Y); true > CST_VerifyPresentation("F",4,3,X,Y); false 1 > G, rels := CST_Presentation("F",4,3); > rels[1]; function(G) w1 := G.1^3; return w1; end function .. magma:function:: CSTtoChev(t,r,q,X,Y) :input_types: MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum :output_types: Map :label: CSTtoChev_MonStgElt_RngIntElt_RngIntElt_SeqEnum_SeqEnum :parameters: GS : BoolElt : \texttt{false}; UseMap : BoolElt : \texttt{false} Given Curtis–Steinberg–Tits generators :math:`X`, :math:`Y` which satisfy the presentation for a group of Lie type :math:`t` and rank :math:`r` over the field of :math:`q` elements, return a function :math:`f` from the group they generate to the standard Magma copy obtained from ``ChevalleyGroup(t,r,q)``. The function :math:`f` will be a homomorphism up to a scalar multiple. Set ``GS`` to ``true`` if the Gilkey–Seitz conventions hold for :math:`X` and :math:`Y`. If ``UseMap`` is ``true``, the function :math:`f` is returned as a Magma ``Map``, otherwise the type is ``UserProgram``. .. magma:example:: Example: CS Tto Chev :label: CSTtoChev Construct a map from the 28-dimensional representation of the simply connected version of the twisted group :math:`{}^3{\rm D}_4(3)` to its standard 8-dimensional representation. .. code-block:: magma > X,Y := CST_Generators("3D",4,3,[0,1,0,0]); > f := CSTtoChev("3D",4,3,X,Y : UseMap); > G := Domain(f); G:Minimal; MatrixGroup(28, GF(5^3)) > L := Codomain(f); L; GL(8, GF(5, 3)) > C := ChevalleyGroup("3D",4,3); > Order(C); 20560831566912 > forall{ x : x in Generators(G) | f(x) in C }; true .. magma:function:: ExtendGeneratorList(t,r,X,Y) :input_types: MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum :output_types: SeqEnum,SeqEnum :label: ExtendGeneratorList_MonStgElt_RngIntElt_RngIntElt_SeqEnum_SeqEnum :parameters: GS : BoolElt : \texttt{false} Given matrix generators (for the simple roots and their negatives) for a simply connected group of Lie type :math:`t` and rank :math:`k` over the field of :math:`q` elements, return the Curtis–Steinberg–Tits generators. IrreducibleHighestWeightRepresentation(G,w) .. magma:function:: IrreducibleHighestWeightRepresentation(G,w) :input_types: GrpLie, SeqEnum :output_types: Map :label: IrreducibleHighestWeightRepresentation_GrpLie_SeqEnum The function ``CST_Generators`` returns the Curti–Steinberg–Tits generators either for a Weyl module of weight :math:`w` or its irreducible quotient. This function returns the corresponding irreducible representation as a ``Map``. IrreducibleHighestWeightGenerators(G,w) .. magma:function:: IrreducibleHighestWeightGenerators(G,w) :input_types: GrpLie, SeqEnum :output_types: SeqEnum,SeqEnum :label: IrreducibleHighestWeightGenerators_GrpLie_SeqEnum :parameters: OnlySimple : BoolElt : \texttt{false} For a simply connected finite group :math:`G` over the field of :math:`q` elements and a :math:`q`-restricted weight :math:`w` return Curtis–Steinberg–Tits generators :math:`X`, :math:`Y` for the irreducible :math:`G`-module of weight :math:`w` for the group :math:`G`. If ``OnlySimple`` is ``true``, return generators for just the simple roots. If :math:`\varpi_1`, :math:`\varpi_2`,…,\ :math:`\varpi_k` are the fundamental weights, then :math:`w = a_1\varpi_n + a_2\varpi_2 + \cdots + a_k \varpi_k` is :math:`q`-restricted if :math:`0\le a_i < q` for :math:`1 \le i\le k`. IrreducibleHighestWeightFunction(G,w) .. magma:function:: IrreducibleHighestWeightFunction(G,w) :input_types: GrpLie, SeqEnum :output_types: UserProgram :label: IrreducibleHighestWeightFunction_GrpLie_SeqEnum This is a version of ``IrreducibleHighestWeightGenerators`` which returns the homomorphism from :math:`G` to the matrix representation of weight :math:`w`. .. magma:function:: VermaModule(G,w) :input_types: GrpLie, SeqEnum :output_types: ModGrp :label: VermaModule_GrpLie_SeqEnum For a finite group :math:`G` of Lie type and a weight :math:`w` this function returns a module :math:`M` of highest weight :math:`w` such that every highest weight module of weight :math:`w` is a quotient of :math:`M`. UniversalHighWeightRepresentation(G,w) .. magma:function:: UniversalHighWeightRepresentation(G,w) :input_types: GrpLie, SeqEnum :output_types: Map,SeqEnum,SeqEnum :label: UniversalHighWeightRepresentation_GrpLie_SeqEnum This function returns a homomorphism from :math:`G` into :math:`{\operatorname{GL}}(M)` and Curtis-Steinberg–Tits generators for the image, where :math:`M` is the module returned by the previous function. .. _SubsectGrpLieChev: .. _chevalley: Chevalley Groups ---------------- Let :math:`\cal L` be a complex semisimple Lie algebra with root system :math:`\Phi`, simple roots :math:`\Delta`, Cartan subalgebra :math:`H`, one-dimensional root spaces :math:`{\cal L}_\alpha` and Cartan decomposition :math:`{\cal L} = H\oplus \bigoplus_{\alpha \in \Phi}{\cal L}_\alpha`. We choose basis vectors :math:`e_\alpha\in{\cal L}_\alpha` such that :math:`[e_\alpha,e_\beta] = c_{\alpha,\beta}`, and the *structure constants* :math:`c_{\alpha,\beta}` are integers :math:`\pm (r+1)`, where :math:`r` is the greatest integer such that :math:`\beta-r\alpha` is a root. For all :math:`\alpha\in\Delta`, we have :math:`h_\alpha = [e_{-\alpha},e_\alpha]\in H` and the *Chevalley basis* of :math:`\cal L` is the set :math:`\{e_\alpha\}_{\alpha\in\Phi}\cup\{h_\alpha\}_{\alpha\in\Delta}`. The :math:`{\mathbb{Z}}`-span of the Chevalley basis is the Lie algebra :math:`{\cal L}_{\mathbb{Z}}`. Given a field :math:`{\mathbb{F}}`, define :math:`{\cal L}_{\mathbb{F}}= {\cal L}_{\mathbb{Z}}\otimes {\mathbb{F}}`. For all roots :math:`\alpha` there is a homomorphism :math:`x_\alpha` from the additive group of :math:`{\mathbb{F}}` to :math:`{\operatorname{GL}}({\cal L}_{\mathbb{F}})` given by .. math:: x_\alpha(\xi) = 1 + \xi\,\hbox{ad}\, e_\alpha + {\xi^2\over 2!}(\hbox{ad}\, e_\alpha)^2 + \cdots\ . Then .. math:: G_{\hbox{\egtrm ad}}({\mathbb{F}}) = \langle\;x_\alpha(\xi)\mid \xi\in{\mathbb{F}},\ \alpha\in \Phi\;\rangle. is the *adjoint Chevalley group*. Other than a few exceptions of rank 1 or 2 over fields of at most 3 elements these groups are simple. However, :math:`G_{\hbox{\egtrm ad}}({\mathbb{F}})` is generally **not** the adjoint group of Lie type in the sense of linear algebraic groups (see :raw-latex:`\cite[p. 39]{Carter-big}`). More generally, given a representation :math:`\varphi : {\cal L}_{\mathbb{Z}}\to {\operatorname{GL}}(M)`, where :math:`M` is a :math:`{\mathbb{Z}}`-module, we may define *root elements* .. math:: x_\alpha(\xi) = 1 + \xi\varphi(e_\alpha) + {\xi^2\over 2!}\varphi(e_\alpha)^2 + \cdots\ . and set .. math:: G_\varphi({\mathbb{F}}) = \langle\;x_\alpha(\xi)\mid \xi\in{\mathbb{F}},\ \alpha\in \Phi\;\rangle. This is also called a *Chevalley group*. Suppose that :math:`\Delta = \{\alpha_1,\dots,\alpha_n\}` and that :math:`\Phi'` is a root subsystem of :math:`\Phi` with simple roots :math:`\Delta'\subset\Delta` such that :math:`\Delta\setminus\Delta' = \{\alpha_i\}` for some :math:`i`. The restriction of the adjoint action of :math:`{\cal L}_{\mathbb{Z}}` to the Lie subalgebra :math:`{\cal L}_{\mathbb{Z}}'` corresponding to :math:`\Phi'` preserves the :math:`{\mathbb{Z}}`-submodule :math:`V` of :math:`{\cal L}_{\mathbb{Z}}` whose basis is the set :math:`X` of elements :math:`e_\beta` such that the coefficient of :math:`\alpha_i` is :math:`1` when :math:`\beta` is expressed as a sum of simple roots. For root data of types A, B, C, D and rank :math:`n` and types :math:`{\rm E}_6` and :math:`{\rm E}_7`, the embedding in the root datum of rank :math:`n+1` adds an extra node to the Dynkin diagram and the construction of the previous paragraph produces the “standard module” for the corresponding Chevalley group. For groups of type :math:`{\rm E}_8` the “standard module” is the adjoint representation. The construction of the “standard modules” for groups of types :math:`{\rm F}_4` and :math:`{\rm G}_2` is more complicated. In order to defined them we identify the Lie algebra of type :math:`{\rm F}_4` with the algebra of fixed points of the graph automorphism order 2 of :math:`{\rm E}_6` and identify the Lie algebra of type :math:`{\rm G}_2` with the fixed points of a graph automorphism of order 3 of :math:`{\rm D}_4`. StandardLieRepresentation(t,r) : MonStgElt, RngIntElt -> SeqEnum, SeqEnum This function returns two sequences of lower triangular integer matrices defining the action of the :math:`{\mathbb{Z}}`-form :math:`{\cal L}_{\mathbb{Z}}` of the simple Lie algebra of type :math:`t` and rank :math:`r` on its “standard module”. The first sequence represents the simple roots and the second sequence represents the negatives of the simple roots. AdjointChevalleyGroup(t,r,q) : MonStgElt,RngIntElt,RngIntElt -> GrpMat This function returns the adjoint Chevalley group of type :math:`t` and rank :math:`r` over the field of :math:`q` elements as a matrix group. The generators are Curtis–Steinberg–Tits generators. The adjoint Chevalley group of type :math:`{\rm B}_n(q)` is isomorphic to the permutation group :math:`{\rm P}\Omega(2n+1,q)`. > n := 2; > q := 5; > G := AdjointChevalleyGroup("B",n,q); > Type(G),Dimension(G); GrpMat 10 > H := POmega(2*n+1,q); > Type(H), Degree(H); GrpPerm 156 > flag, \_ := IsIsomorphic(G,H); > flag; true LieRootMatrix(R,\ :math:`\alpha`,B) : RootDtm,ModTupFldElt,SetIndx -> AlgMatElt The matrix of :math:`\hbox{ad}\,(e_\alpha)` acting (on the right) on the module with basis :math:`B`, where :math:`B` must be a subset of the positive or the negative roots of the root datum :math:`R`, as outlined in the construction above. The argument :math:`\alpha` is a vector representing a root in the root basis. LieRootMatrix(R,r,X) : RootDtm, RngIntElt, SeqEnum -> AlgMatElt Negative : BoolElt : ``false`` The matrix of :math:`\hbox{ad}\,(e_\alpha)` where :math:`\alpha` is the :math:`r`-th root acting (on the right) on the subspace of the Lie algebra of :math:`R` spanned by the roots indexed by :math:`X`. The elements of :math:`X` are indices of positive roots unless ``Negative`` is ``true``, in which case they they are indices of negative roots. LieTypeGenerators(t,k,q) : MonStgElt, RngIntElt, RngIntElt -> SeqEnum,SeqEnum LieTypeGenerators(t,k,K) : MonStgElt, RngIntElt, FldFin -> SeqEnum,SeqEnum LieTypeGenerators(G) : GrpLie -> SeqEnum,SeqEnum GS : BoolElt : ``false`` The Curtis–Steinberg–Tits generators of a simply connected group :math:`G` of Lie type or the simply connected group of Lie type :math:`t` and rank :math:`r` over the finite field :math:`K` or :math:`{\mathbb{F}}_q`. This function is available for both twisted and untwisted groups. If ``GS`` is ``true``, the Gilkey–Seitz structure constants and root order are used. SLPGeneratorList(t,r,q) : MonStgElt, RngIntElt, RngIntElt -> SeqEnum, SeqEnum GS : BoolElt : ``false`` The Curtis–Steinberg–Tits generators of the simply connected group of Lie type :math:`t` and rank :math:`r` over the field of :math:`q` elements, returned as straight-line programs. If ``GS`` is ``true``, the Gilkey–Seitz structure constants and root order are used. morphisms --------- Morphisms and the Row Reduction Algorithm. From an irreducible quasisimple matrix group :math:`H` of known Lie type :math:`t` and rank :math:`r` over the field of :math:`q` elements, the work of :cite:`Exceptional-LOB16` produces Curtis–Steinberg–Tits generators :math:`X`, :math:`Y` as part of the constructive recognition algorithm. This section describes some functions to construct homomorphisms :math:`\rho : G \to H` and their inverses from such generators, where :math:`G` is the simply connected group of Lie type :math:`t`, rank :math:`r` over :math:`{\mathbb{F}}_q`. From the homomorphism :math:`\rho : G\to H` and a matrix :math:`A\in H`, an element :math:`g\in G` such that :math:`\rho(g) = A` can be constructed using the Chevalley normal form of the Bruhat decomposition of :math:`A`. That is, we write :math:`g = uh\overdot wu'`, where :math:`u`, :math:`h`, :math:`\overdot w` and :math:`u'` have the properties described in Subsection :ref:`SubsectGrpLieBruhat`. This uses the “row reduction” algorithms for twisted :cite:`cohen-taylor` and untwisted :cite:`CohenMurrayTaylor` groups (a generalisation of Gaussian row reduction of matrices to groups of Lie type). Morphism(G,X,Y) : GrpLie,SeqEnum,SeqEnum -> Map OnlySimple : BoolElt : ``false`` GS : BoolElt : ``false`` Verify : BoolElt : ``false`` Given an algebraically simple, simply connected group :math:`G` of Lie type and Curtis–Steinberg–Tits generators for a representation, return the homomorphism from :math:`G` to the group generated by :math:`X` and :math:`Y`. If generators :math:`X` and :math:`Y` are available only for the simple roots and their negatives, set ``OnlySimple`` to ``true``. If the generators follow the Gilkey–Seitz conventions, set ``GS`` to ``true``. If ``Verify`` is true, the function first checks that :math:`X` and :math:`Y` satisfy the appropriate CST presentation. This function applies to both twisted and untwisted groups. ChevalleyForm(:math:`\rho`,A) : Map[GrpLie,GrpMat], GrpMatElt -> SeqEnum, FldFinElt Given a homomorphism :math:`\rho : G \to H` from a simply connected group :math:`G` of Lie type to a matrix group :math:`H` and a matrix :math:`A`, this function returns a sequence :math:`s` and a field element :math:`z`. If :math:`A` is not in the image of :math:`\rho` (modulo scalars) then :math:`s = [\ ]`, otherwise the elements of :math:`s = [u, h, \overdot w,u']` are the components of the Chevalley normal form of an element :math:`g = uh\overdot wu'` such that :math:`A = z\rho(g)`. Choose a random element in a twisted group of Lie type, get a scalar multiple of its image in an irreducible highest weight representation and then check the Chevalley normal form. > G := TwistedGroupOfLieType("2E",6,3); > RootDatum(G); Twisted simply connected root datum of dimension 6 of type 2E6,4 > Dimension(G); 78 > X,Y := CST_Generators("2E",6,3,[0,1,0,0,0,0]); > rho := Morphism(G,X,Y); > L := Codomain(rho); > Dimension(L); 77 > F := BaseRing(L); > I := sub; > g := Random(G); > A := L!ScalarMatrix(77,t)*rho(g); > s,z := ChevalleyForm(rho,A); > z; t > &\* s eq g; true PrepareRewrite(t,r,q,X,Y) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum -> UserProgram, Map TwistedPrepareRewrite(t,r,q,X,Y) : MonStgElt,RngIntElt,RngIntElt, SeqEnum,SeqEnum -> UserProgram, Map OnlySimple : BoolElt : ``false`` GS : BoolElt : ``false`` This function constructs the group :math:`G` of Lie type :math:`t` and rank :math:`r` over the field of :math:`q` elements and the homomorphism :math:`f : G \to H`, where :math:`H` is the matrix group generated by the CST generators :math:`X` and :math:`Y`. In addition to :math:`f` this function returns a map :math:`\varphi : H \to G` such that :math:`f\circ \varphi = \hbox{id}_H`. If generators :math:`X` and :math:`Y` are available only for the simple roots and their negatives, set ``OnlySimple`` to ``true``. If the generators follow the Gilkey–Seitz conventions, set ``GS`` to ``true``. LieTypeRewrite(t,r,q,X,Y,g) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum,GrpMatElt -> BoolElt, GrpSLPElt TwistedLieTypeRewrite(t,r,q,X,Y,g) : MonStgElt,RngIntElt,RngIntElt,SeqEnum,SeqEnum,GrpMatElt -> BoolElt, GrpSLPElt OnlySimple : BoolElt : ``false`` GS : BoolElt : ``false`` Given a finite (untwisted or twisted) matrix group :math:`H` with generators :math:`X`, :math:`Y` in CST format and an element :math:`g\in H`, return a boolean flag :math:`b` and, if :math:`b` is ``true``, an SLP :math:`\pi` that expresses :math:`g` as a word in the given generators. If the parameter ``OnlySimple`` is ``true``, the return value :math:`\pi` is an SLP in the generators corresponding to the simple roots and their negatives. Set ``GS`` to ``true`` if the generators follow the Gilkey–Seitz conventions. Check that the SLP returned by ``TwistedLieTypeRewrite`` evaluates to the correct matrix when evaluated on the CST generators. > X,Y := CST_Generators("3D",4,5,[]); > H := sub< Parent(X[1,1]) \| &cat X, &cat Y>; > g := Random(H); > flag, s := TwistedLieTypeRewrite("3D",4,5,X,Y,g); > flag; true > gens := &cat X cat &cat Y; > g eq Evaluate(s,gens); true RowReductionMap(:math:`\rho`) : Map[GrpLie,GrpMat] -> UserProgram TwistedRowReductionMap(:math:`\rho`) : Map[GrpLie,GrpMat] -> UserProgram Given an irreducible representation :math:`\rho : G(q)\to {\operatorname{GL}}(M)` of an untwisted (respectively twisted) finite group :math:`G` of Lie type, this function returns a function :math:`f` such that :math:`\rho(f(A)) = A` for all :math:`A` in the image of :math:`A`. More precisely, given :math:`A` in the codomain of :math:`\rho`, the application of :math:`f` to :math:`A` returns two values: a sequence :math:`w` of length 0 or 1, and an element :math:`z`. If :math:`A` is a scalar multiple of an element of the image of :math:`\rho`, then :math:`w[1]` is a Steinberg word in the domain of :math:`\rho` and :math:`z` is a field element such that :math:`z\rho(w[1]) = A`; otherwise :math:`w` is empty and :math:`z` is a message indicating the reason for failure. In particular, if :math:`A` is in the image of :math:`\rho`, then :math:`z` is 1.