ó
    ˆ*£h¦S  ã                   ó`   • S SK Jr  S SKJr  S SKJr  S SKJr   " S S\5      r " S S\5      r	g	)
é    ©Úisprime)ÚPermutationGroup)ÚDefaultPrinting)Ú
free_groupc                   ó2   • \ rS rSrSrSrSS jrS rS rSr	g)	ÚPolycyclicGroupé   TNc                 ó|   • Xl         X l        X0l        U(       d  [        U R                   X#5      U l        gUU l        g)a·  

Parameters
==========

pc_sequence : list
    A sequence of elements whose classes generate the cyclic factor
    groups of pc_series.
pc_series : list
    A subnormal sequence of subgroups where each factor group is cyclic.
relative_order : list
    The orders of factor groups of pc_series.
collector : Collector
    By default, it is None. Collector class provides the
    polycyclic presentation with various other functionalities.

N)ÚpcgsÚ	pc_seriesÚrelative_orderÚ	CollectorÚ	collector)ÚselfÚpc_sequencer   r   r   s        ÚZ/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/combinatorics/pc_groups.pyÚ__init__ÚPolycyclicGroup.__init__   s/   € ð$  Œ	Ø"ŒØ,ÔÞPYœ 4§9¡9¨iÓHˆ�Ð_hˆ�ó    c                 ó:   • [        S U R                   5       5      $ )Nc              3   ó8   #   • U  H  n[        U5      v •  M     g 7f©Nr   )Ú.0Úorders     r   Ú	<genexpr>Ú1PolycyclicGroup.is_prime_order.<locals>.<genexpr>$   s   é € ÐCÒ/B e”7˜5—>�>Ò/Bùs   ‚)Úallr   ©r   s    r   Úis_prime_orderÚPolycyclicGroup.is_prime_order#   s   € ÜÑC¨t×/BÒ/BÓCÓCÐCr   c                 ó,   • [        U R                  5      $ r   )Úlenr   r   s    r   ÚlengthÚPolycyclicGroup.length&   s   € Ü�4—9‘9‹~Ðr   )r   r   r   r   r   )
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Úis_groupÚis_solvabler   r    r$   Ú__static_attributes__© r   r   r	   r	      s   † à€HØ€Kôiò.Dõr   r	   c                   ój   • \ rS rSrSrSS jrS rS rS rS r	S	 r
S
 rS rS rS rS rS rS rSrg)r   é*   z„
References
==========

.. [1] Holt, D., Eick, B., O'Brien, E.
       "Handbook of Computational Group Theory"
       Section 8.1.3
Nc                 ó8  • Xl         X l        X0l        U(       d&  [        SR	                  [        U5      5      5      S   OUU l        [        U R                  R                  5       VVs0 s H  u  pgXv_M	     snnU l        U R                  5       U l
        gs  snnf )a©  

Most of the parameters for the Collector class are the same as for PolycyclicGroup.
Others are described below.

Parameters
==========

free_group_ : tuple
    free_group_ provides the mapping of polycyclic generating
    sequence with the free group elements.
pc_presentation : dict
    Provides the presentation of polycyclic groups with the
    help of power and conjugate relators.

See Also
========

PolycyclicGroup

zx:{}r   N)r   r   r   r   Úformatr#   Ú	enumerateÚsymbolsÚindexÚpc_relatorsÚpc_presentation)r   r   r   r   Úfree_group_r6   ÚiÚss           r   r   ÚCollector.__init__5   sy   € ð, Œ	Ø"ŒØ,ÔÞITœ* V§]¡]´3°t³9Ó%=Ó>¸qÒAÐZeˆŒÜ'0°·±×1HÑ1HÔ'IÔJÒ'I™t˜q�a’dÑ'IÒJˆŒ
Ø#×/Ñ/Ó1ˆÕùó Ks   Á)Bc                 ó~  • U(       d  gUR                   nU R                  nU R                  n[        [	        U5      5       H0  nX%   u  pgX4U      (       d  M  US:  d  XsXF      S-
  :”  d  M,  Xg44s  $    [        [	        U5      S-
  5       H.  nX%   u  pgX%S-      u  p‰XF   XH   :”  d  M  U	S:”  a  SOSn
Xg4XŠ44s  $    g)a  
Returns the minimal uncollected subwords.

Explanation
===========

A word ``v`` defined on generators in ``X`` is a minimal
uncollected subword of the word ``w`` if ``v`` is a subword
of ``w`` and it has one of the following form

* `v = {x_{i+1}}^{a_j}x_i`

* `v = {x_{i+1}}^{a_j}{x_i}^{-1}`

* `v = {x_i}^{a_j}`

for `a_j` not in `\{1, \ldots, s-1\}`. Where, ``s`` is the power
exponent of the corresponding generator.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> collector.minimal_uncollected_subword(word)
((x2, 2),)

Nr   é   éÿÿÿÿ)Ú
array_formr   r4   Úranger#   )r   ÚwordÚarrayÚrer4   r8   Ús1Úe1Ús2Úe2Úes              r   Úminimal_uncollected_subwordÚ%Collector.minimal_uncollected_subwordR   sÊ   € öF Øà—‘ˆØ× Ñ ˆØ—
‘
ˆä”s˜5“zÖ"ˆAØ‘X‰FˆBà˜‘)�}‰} " q£&¨B°E±I±¸q±Õ,@Ø˜�|Ò#ñ	 #ô ”s˜5“z !‘|Ö$ˆAØ‘X‰FˆBØ˜Q™3‘Z‰FˆBà‰y˜5™9Õ$Ø˜a›‘A R�Ø˜ 2 'Ð*Ò*ñ %ð r   c                 óœ   • 0 n0 nU R                   R                  5        H(  u  p4[        UR                  5      S:X  a  XAU'   M$  XBU'   M*     X4$ )a	  
Separates the given relators of pc presentation in power and
conjugate relations.

Returns
=======

(power_rel, conj_rel)
    Separates pc presentation into power and conjugate relations.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> power_rel, conj_rel = collector.relations()
>>> power_rel
{x0**2: (), x1**3: ()}
>>> conj_rel
{x0**-1*x1*x0: x1**2}

See Also
========

pc_relators

r<   )r6   Úitemsr#   r>   )r   Úpower_relatorsÚconjugate_relatorsÚkeyÚvalues        r   Ú	relationsÚCollector.relationsŒ   sV   € ð< ˆØÐØ×.Ñ.×4Ñ4Ö6‰JˆCÜ�3—>‘>Ó" aÓ'Ø&+˜sÓ#à*/ 3Ó'ñ	 7ð
 Ð1Ð1r   c                 óÎ   • SnSn[        [        U5      [        U5      -
  S-   5       H8  nUR                  XU[        U5      -   5      U:X  d  M&  UnU[        U5      -   n  X44$    X44$ )a|  
Returns the start and ending index of a given
subword in a word.

Parameters
==========

word : FreeGroupElement
    word defined on free group elements for a
    polycyclic group.
w : FreeGroupElement
    subword of a given word, whose starting and
    ending index to be computed.

Returns
=======

(i, j)
    A tuple containing starting and ending index of ``w``
    in the given word. If not exists, (-1,-1) is returned.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x1, x2 = free_group("x1, x2")
>>> word = x2**2*x1**7
>>> w = x2**2*x1
>>> collector.subword_index(word, w)
(0, 3)
>>> w = x1**7
>>> collector.subword_index(word, w)
(2, 9)
>>> w = x1**8
>>> collector.subword_index(word, w)
(-1, -1)

r=   r<   )r?   r#   Úsubword)r   r@   ÚwÚlowÚhighr8   s         r   Úsubword_indexÚCollector.subword_index³   sp   € ðV ˆØˆÜ”s˜4“y¤ Q£Ñ'¨Ñ)Ö*ˆAØ�|‰|˜A¤ Q£™xÓ(¨AÕ-Ø�Øœ˜Q›‘x�ØØˆyÐñ +ð
 ˆyÐr   c                 ó¤   • UR                   nUS   S   nUS   S   nUS4US4US44nU R                  R                  U5      nU R                  U   $ )aW  
Return a conjugate relation.

Explanation
===========

Given a word formed by two free group elements, the
corresponding conjugate relation with those free
group elements is formed and mapped with the collected
word in the polycyclic presentation.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics import free_group
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x0, x1 = free_group("x0, x1")
>>> w = x1*x0
>>> collector.map_relation(w)
x1**2

See Also
========

pc_presentation

r   r<   r=   )r>   r   Údtyper6   )r   rT   rA   rC   rE   rN   s         r   Úmap_relationÚCollector.map_relationç   sd   € ð> —‘ˆØ�1‰X�a‰[ˆØ�1‰X�a‰[ˆØ�Bˆx˜"˜a˜ 2 q 'Ð*ˆØ�o‰o×#Ñ# CÓ(ˆØ×#Ñ# CÑ(Ð(r   c                 óÀ  • U R                   n U R                  U5      nU(       d   U$ U R                  XR                  " U5      5      u  pEUS:X  a  MG  US   u  pg[	        U5      S:X  aã  U R
                  U R                  U      nXx-  n	XyU-  -
  n
US   S   U44nUR                  " U5      nU R                  U   (       aC  U R                  U   R                  nUS   u  pÞUS   S   U
4XÙU-  44nUR                  " U5      nO&U
S:w  a  US   S   U
44nUR                  " U5      nOSnUR                  UR                  " U5      U5      n[	        U5      S:X  ax  US   S   S:”  al  US   u  nnUS44nUR                  " U5      nU R                  UR                  " U5      5      nUX÷-  -  nUR                  " U5      nUR                  XEU5      nO‰[	        U5      S:X  az  US   S   S:  an  US   u  nnUS44nUR                  " U5      nU R                  UR                  " U5      5      nUS-  X÷-  -  nUR                  " U5      nUR                  XEU5      nGMR  )aü  
Return the collected form of a word.

Explanation
===========

A word ``w`` is called collected, if `w = {x_{i_1}}^{a_1} * \ldots *
{x_{i_r}}^{a_r}` with `i_1 < i_2< \ldots < i_r` and `a_j` is in
`\{1, \ldots, {s_j}-1\}`.

Otherwise w is uncollected.

Parameters
==========

word : FreeGroupElement
    An uncollected word.

Returns
=======

word
    A collected word of form `w = {x_{i_1}}^{a_1}, \ldots,
    {x_{i_r}}^{a_r}` with `i_1, i_2, \ldots, i_r` and `a_j \in
    \{1, \ldots, {s_j}-1\}`.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics import free_group
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3")
>>> word = x3*x2*x1*x0
>>> collected_word = collector.collected_word(word)
>>> free_to_perm = {}
>>> free_group = collector.free_group
>>> for sym, gen in zip(free_group.symbols, collector.pcgs):
...     free_to_perm[sym] = gen
>>> G1 = PermutationGroup()
>>> for w in word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G1 = PermutationGroup([perm] + G1.generators)
>>> G2 = PermutationGroup()
>>> for w in collected_word:
...     sym = w[0]
...     perm = free_to_perm[sym]
...     G2 = PermutationGroup([perm] + G2.generators)

The two are not identical, but they are equivalent:

>>> G1.equals(G2), G1 == G2
(True, False)

See Also
========

minimal_uncollected_subword

r=   r   r<   Né   )r   rH   rW   rZ   r#   r   r4   r6   r>   Úeliminate_wordr[   Úsubstituted_word)r   r@   r   rT   rU   rV   rC   rD   rB   ÚqÚrrN   ÚpresentationÚsymÚexpÚword_rE   rF   s                     r   Úcollected_wordÚCollector.collected_word  s‚  € ðB —_‘_ˆ
ØØ×0Ñ0°Ó6ˆAÞØðZ ˆðW ×*Ñ*¨4×1AÒ1AÀ!Ó1DÓE‰IˆCØ�b‹yÙà�q‘T‰FˆBÜ�1‹v˜‹{Ø×(Ñ(¨¯©°B©Ñ8�Ø‘H�Ø˜‘t‘G�à˜!™˜Q™ �}Ð'�Ø ×&Ò& sÓ+�Ø×'Ñ'¨×,Ø#'×#7Ñ#7¸Ñ#<×#GÑ#G�LØ+¨A™‘H�CØ ™d 1™g q˜\¨C°3±¨<Ð8�EØ&×,Ò,¨UÓ3‘Eà˜A“vØ"# A¡$ q¡'¨1 Ð 0˜Ø *× 0Ò 0°Ó 7™à $˜Ø×*Ñ*¨:×+;Ò+;¸AÓ+>ÀÓF�ä�1‹v˜‹{˜q ™t A™w¨›{Ø˜1™‘��BØ˜1�g�[�Ø×%Ò% bÓ)�Ø×)Ñ)¨*×*:Ò*:¸1Ó*=Ó>�Ø˜5™9™�Ø"×(Ò(¨Ó/�Ø×,Ñ,¨S¸Ó>‘ä�Q“˜1“  1¡ a¡¨1£Ø˜1™‘��BØ˜1�g�[�Ø×%Ò% bÓ)�Ø×)Ñ)¨*×*:Ò*:¸1Ó*=Ó>�Ø˜B™˜u™yÑ(�Ø"×(Ò(¨Ó/�Ø×,Ñ,¨S¸Ó>�ò] r   c                 ó°  • U R                   nU R                  n0 n0 nU R                  n[        XQR                  5       H  u  pgUS-  XFS-  '   XtU'   M     USSS2   nU R
                  SSS2   nUSSS2   n/ n	[        U5       GHM  u  p¦X*   nXF   U-  nXŠ   nUR                  Xk-  SS9nUR                  5         UR                  nU H
  nXôU   -  nM     U R                  U5      nU(       a  UOSX<'   X0l        U	R                  U5        [        U	5      S:”  d  M™  U	[        U	5      S-
     nUU   n[        [        U	5      S-
  5       Hƒ  nXIU      nUS-  U-  U-  nUS-  U	U   -  U-  nUR                  USS9nUR                  5         UR                  nU H
  nXôU   -  nM     U R                  U5      nU(       a  UOSX<'   X0l        M…     GMP     U$ )a¥  
Return the polycyclic presentation.

Explanation
===========

There are two types of relations used in polycyclic
presentation.

* Power relations : Power relators are of the form `x_i^{re_i}`,
  where `i \in \{0, \ldots, \mathrm{len(pcgs)}\}`, ``x`` represents polycyclic
  generator and ``re`` is the corresponding relative order.

* Conjugate relations : Conjugate relators are of the form `x_j^-1x_ix_j`,
  where `j < i \in \{0, \ldots, \mathrm{len(pcgs)}\}`.

Returns
=======

A dictionary with power and conjugate relations as key and
their collected form as corresponding values.

Notes
=====

Identity Permutation is mapped with empty ``()``.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> S = SymmetricGroup(49).sylow_subgroup(7)
>>> der = S.derived_series()
>>> G = der[len(der)-2]
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> len(pcgs)
6
>>> free_group = collector.free_group
>>> pc_resentation = collector.pc_presentation
>>> free_to_perm = {}
>>> for s, g in zip(free_group.symbols, pcgs):
...     free_to_perm[s] = g

>>> for k, v in pc_resentation.items():
...     k_array = k.array_form
...     if v != ():
...        v_array = v.array_form
...     lhs = Permutation()
...     for gen in k_array:
...         s = gen[0]
...         e = gen[1]
...         lhs = lhs*free_to_perm[s]**e
...     if v == ():
...         assert lhs.is_identity
...         continue
...     rhs = Permutation()
...     for gen in v_array:
...         s = gen[0]
...         e = gen[1]
...         rhs = rhs*free_to_perm[s]**e
...     assert lhs == rhs

r=   NT©Úoriginalr-   r<   )r   r   r   ÚzipÚ
generatorsr   r2   Úgenerator_productÚreverseÚidentityrg   r6   Úappendr#   r?   )r   r   Ú	rel_orderr5   Úperm_to_freer   Úgenr9   ÚseriesÚcollected_gensr8   rB   ÚrelationÚGÚlr@   ÚgÚconjÚ
conjugatorÚjÚ
conjugatedÚgenss                         r   r5   ÚCollector.pc_relatorsƒ  s  € ðF —_‘_ˆ
Ø×'Ñ'ˆ	ØˆØˆØ�y‰yˆä˜$× 5Ñ 5Ö6‰FˆCØ$% r¡EˆL˜b™Ñ!Ø !˜Óñ 7ð ‘D�b�D‰zˆØ—‘¡ " Ñ%ˆØ™d ˜d‘Oˆ	Øˆä —o‰FˆAØ‘ˆBØ#Ñ(¨"Ñ,ˆHØ‘	ˆAà×#Ñ# C¡G¸Ð#Ð=ˆAØ�I‰IŒKà×&Ñ&ˆDÛ�Ø¨™OÑ+’ñ ð ×&Ñ& tÓ,ˆDÞ,0¡D°bˆKÑ!Ø#.Ô à×!Ñ! #Ô&Ü�>Ó" QÕ&Ø%¤c¨.Ó&9¸!Ñ&;Ñ<�Ø)¨$Ñ/�
äœs >Ó2°1Ñ4Ö5�AØ!-¸QÑ.?Ñ!@�Jà)¨2™~¨jÑ8¸ÑC�HØ ™8 N°1Ñ$5Ñ5°dÑ:�Dà×+Ñ+¨D¸TÐ+ÐB�AØ—I‘I”KØ%×.Ñ.�DÛ˜Ø#°¡OÑ3šñ ð  ×.Ñ.¨tÓ4�DÞ48©D¸b�KÑ)Ø+6Ö(ô 6ñ+ &ðJ Ðr   c                 ó  • U R                   n[        5       nU R                   H  n[        U/UR                  -   5      nM     UR	                  USS9nUR                  5         0 n[        UR                  U R                  5       H  u  ptUS-  XdS-  '   XvU'   M     UR                  nU H
  nX†U   -  nM     U R                  U5      n	U R                  n
S/[        U5      -  nU	R                  n	U	 H  nUS   XºUS      '   M     U$ )a:  
Return the exponent vector of length equal to the
length of polycyclic generating sequence.

Explanation
===========

For a given generator/element ``g`` of the polycyclic group,
it can be represented as `g = {x_1}^{e_1}, \ldots, {x_n}^{e_n}`,
where `x_i` represents polycyclic generators and ``n`` is
the number of generators in the free_group equal to the length
of pcgs.

Parameters
==========

element : Permutation
    Generator of a polycyclic group.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> from sympy.combinatorics.permutations import Permutation
>>> G = SymmetricGroup(4)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> pcgs = PcGroup.pcgs
>>> collector.exponent_vector(G[0])
[1, 0, 0, 0]
>>> exp = collector.exponent_vector(G[1])
>>> g = Permutation()
>>> for i in range(len(exp)):
...     g = g*pcgs[i]**exp[i] if exp[i] else g
>>> assert g == G[1]

References
==========

.. [1] Holt, D., Eick, B., O'Brien, E.
       "Handbook of Computational Group Theory"
       Section 8.1.1, Definition 8.4

Trj   r=   r   r<   )r   r   r   rm   rn   ro   rl   rp   rg   r4   r#   r>   )r   Úelementr   rx   rz   r   rs   rd   rT   r@   r4   Ú
exp_vectorÚts                r   Úexponent_vectorÚCollector.exponent_vectorü  s  € ðZ —_‘_ˆ
ÜÓˆØ—”ˆAÜ  !  q§|¡|Ñ!3Ó4ŠAñ à×"Ñ" 7°tÐ"Ð<ˆØ�‰ŒàˆÜ˜*×/Ñ/°·±Ö;‰FˆCØ"% r¡'ˆL˜B™ÑØ!˜‹Oñ <ð ×ÑˆÛˆAØ˜q‘/Ñ!ŠAñ ð ×"Ñ" 1Ó%ˆà—
‘
ˆØ�Sœ˜Z›Ñ(ˆ
Ø�‰ˆÛˆAØ&'¨¡dˆJ˜Q˜q™T‘{Ó#ñ àÐr   c                 óˆ   • U R                  U5      n[        S [        U5       5       [        U R                  5      S-   5      $ )ai  
Return the depth of a given element.

Explanation
===========

The depth of a given element ``g`` is defined by
`\mathrm{dep}[g] = i` if `e_1 = e_2 = \ldots = e_{i-1} = 0`
and `e_i != 0`, where ``e`` represents the exponent-vector.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.depth(G[0])
2
>>> collector.depth(G[1])
1

References
==========

.. [1] Holt, D., Eick, B., O'Brien, E.
       "Handbook of Computational Group Theory"
       Section 8.1.1, Definition 8.5

c              3   óB   #   • U  H  u  pU(       d  M  US -   v •  M     g7f)r<   Nr-   )r   r8   Úxs      r   r   Ú"Collector.depth.<locals>.<genexpr>a  s   é € Ð@Ò%:™T˜Q¼a“S�Q�q–SÒ%:ùs   ‚“r<   )r…   Únextr2   r#   r   )r   r‚   rƒ   s      r   ÚdepthÚCollector.depthA  s:   € ð> ×)Ñ)¨'Ó2ˆ
ÜÑ@¤Y¨zÔ%:Ó@Ä#ÀdÇiÁiÃ.ÐQRÑBRÓSÐSr   c                 óŽ   • U R                  U5      nU R                  U5      nU[        U R                  5      S-   :w  a  X#S-
     $ g)aœ  
Return the leading non-zero exponent.

Explanation
===========

The leading exponent for a given element `g` is defined
by `\mathrm{leading\_exponent}[g]` `= e_i`, if `\mathrm{depth}[g] = i`.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> G = SymmetricGroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> collector.leading_exponent(G[1])
1

r<   N)r…   rŒ   r#   r   )r   r‚   rƒ   rŒ   s       r   Úleading_exponentÚCollector.leading_exponentc  sG   € ð* ×)Ñ)¨'Ó2ˆ
Ø—
‘
˜7Ó#ˆØ”C˜Ÿ	™	“N 1Ñ$Ó$Ø A™gÑ&Ð&Ør   c                 ót  • UnU R                  U5      nU[        U R                  5      :  a‹  XS-
     S:w  a€  XS-
     nU R                  U5      U R                  U5      S-  -  nX`R                  US-
     -  nXV* -  U-  nU R                  U5      nU[        U R                  5      :  a  XS-
     S:w  a  M€  U$ )Nr<   r=   )rŒ   r#   r   r�   r   )r   Úzrz   ÚhÚdÚkrG   s          r   Ú_siftÚCollector._sift~  s¶   € ØˆØ�J‰J�q‹MˆØ”#�d—i‘i“.Ó  Q¨¡s¡V¨q£[Ø�A‘#‘ˆAØ×%Ñ% aÓ(¨$×*?Ñ*?ÀÓ*BÀRÑ)GÑGˆAØ×'Ñ'¨¨!©Ñ,Ñ,ˆAØ�2‘�a‘ˆAØ—
‘
˜1“ˆAð ”#�d—i‘i“.Ó  Q¨¡s¡V¨q¥[ð ˆr   c                 ó   • S/[        U R                  5      -  nUnU(       a�  UR                  S5      nU R                  X$5      nU R	                  U5      nU[        U R                  5      :  a8  U H+  nUS:w  d  M  UR                  US-  US-  -  U-  U-  5        M-     XRUS-
  '   U(       a  M�  U Vs/ s H  owS:w  d  M
  UPM     nnU$ s  snf )ax  

Parameters
==========

gens : list
    A list of generators on which polycyclic subgroup
    is to be defined.

Examples
========

>>> from sympy.combinatorics.named_groups import SymmetricGroup
>>> S = SymmetricGroup(8)
>>> G = S.sylow_subgroup(2)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> gens = [G[0], G[1]]
>>> ipcgs = collector.induced_pcgs(gens)
>>> [gen.order() for gen in ipcgs]
[2, 2, 2]
>>> G = S.sylow_subgroup(3)
>>> PcGroup = G.polycyclic_group()
>>> collector = PcGroup.collector
>>> gens = [G[0], G[1]]
>>> ipcgs = collector.induced_pcgs(gens)
>>> [gen.order() for gen in ipcgs]
[3]

r<   r   r=   )r#   r   Úpopr–   rŒ   rq   )r   r   r’   rx   rz   r“   r”   rt   s           r   Úinduced_pcgsÚCollector.induced_pcgs‰  sÂ   € ð> ˆC”�D—I‘I“ÑˆØˆÞØ—‘�a“ˆAØ—
‘
˜1Ó ˆAØ—
‘
˜1“ˆAØ”3�t—y‘y“>Ó!Û�CØ˜a•xØŸ™  B¡ s¨B¡w¡¨q¡°Ñ!4Ö5ñ ð �!�A‘#‘÷ ˆañ Ó*šA�S¨¡�S™AˆÐ*Øˆùò +s   Â4	CÃCc                 ó„  • S/[        U5      -  nUnU R                  U5      n[        U5       H‡  u  pgU R                  U5      U:X  d  M  U R                  U5      U R                  U5      -  nX€R                  US-
     -  nXx* -  U-  nXƒU'   U R                  U5      nU R                  U5      U:X  a  Mk  M‰     US:X  a  U$ g)z.
Return the exponent vector for induced pcgs.
r   r<   F)r#   rŒ   r2   r�   r   )	r   Úipcgsrz   rG   r“   r”   r8   rt   Úfs	            r   Úconstructive_membership_testÚ&Collector.constructive_membership_test¶  sÁ   € ð ˆC”�E“
‰NˆØˆØ�J‰J�q‹MˆÜ Ö&‰FˆAØ—*‘*˜S“/ QÕ&Ø×)Ñ)¨!Ó,¨T×-BÑ-BÀ3Ó-GÑG�Ø×+Ñ+¨A¨a©CÑ0Ñ0�Ø˜"‘I˜a‘K�Ø�!‘Ø—J‘J˜q“M�ð —*‘*˜S“/ Q×&ñ 'ð �‹6ØˆHØr   )r   r4   r6   r   r   r   )NN)r&   r'   r(   r)   Ú__doc__r   rH   rP   rW   r[   rg   r5   r…   rŒ   r�   r–   rš   rŸ   r,   r-   r   r   r   r   *   sU   † ñô2ò:8òt%2òN2òh$)òNròjwòrCòJ TòDò6	ò+õZr   r   N)
Úsympy.ntheory.primetestr   Úsympy.combinatorics.perm_groupsr   Úsympy.printing.defaultsr   Úsympy.combinatorics.free_groupsr   r	   r   r-   r   r   Ú<module>r¦      s,   ðÝ +Ý <Ý 3Ý 6ô �oô  ôF\
�õ \
r   