Créons un groupe gratuit avec Python

Qu'est-ce qu'un groupe

Un ensemble non vide $ G $ qui peut faire une "opération binaire" (Autrement dit, si $ g, h \ dans G $, il y a une opération binaire $ g \ cdot h $, et le résultat de l'opération est également l'élément de G, c'est-à-dire $ g \ cdot h \ dans G $) Ceux qui remplissent les conditions suivantes sont appelés groupes.

• (Élément unitaire) Il y a un élément $ e \ dans G $ appelé un élément unitaire, et $ e \ cdot a = a \ cdot e = a $ vaut pour tout élément $ a \ dans G $.
• (Élément inversé) Pour tout élément $ a \ dans G $, un certain élément $ b \ dans G $ existe, et $ a \ cdot b = b \ cdot a = e $ est valable. $ b $ est appelé l'élément inverse de $ a $ et s'écrit $ a ^ {-1} $
• (Loi de jonction) $ (a \ cdot b) \ cdot c = a \ cdot (b \ cdot c) $ vaut pour tout élément $ a, b, c \ dans G $

Exemple de groupe

--Les entiers qui peuvent être ajoutés sont des groupes (élément unitaire → $ 0 $, élément inverse de $ a $ → $ -a $, loi de combinaison → l'addition est connue pour contenir la loi de combinaison) --Il existe également des groupes de nombres rationnels qui peuvent être ajoutés (comme ci-dessus). Il existe également un groupe de nombres rationnels moins 0 qui peut être multiplié. (S'il s'agit d'un nombre rationnel comprenant 0, ce n'est pas un groupe car l'élément inverse de 0 ne peut pas être défini.)

Groupe gratuit

Les groupes libres n'ont aucune restriction autre que la définition des groupes.

Ici, considérons $ F_2 $ généré à partir de deux éléments du groupe libre. En d'autres termes, à partir de l'élément unit, les deux éléments $ a, b \ dans F_2 $, et les éléments inverses $ a ^ {-1}, b ^ {-1} $, sélectionnez celui que vous aimez et calculez, et vous aimez Pensez à quelque chose qui peut être répété autant de fois que possible.

F_2 = \\{e, a, b, a^{-1}, b^{-1}, aa, ab, ab^{-1}, ba, ba^{-1}, bb, a^{-1}b, a^{-1}a^{-1}, a^{-1}b^{-1}, \dots\\}

Quelle est la source inverse?

Je comprends que l'inverse de $ a $ est $ a ^ {-1} $, mais qu'en est-il de l'inverse d'une combinaison, telle que $ ab ^ {-1} aab $? En fait, c'est l'inverse de chaque original, et l'ordre est inversé, c'est-à-dire $ b ^ {-1} a ^ {-1} a ^ {-1} ba ^ {-dans ce cas. 1} $ est la source inverse. En fait, quand j'essaye de calculer ces

\begin{eqnarray}
ab^{-1}aab\cdot b^{-1}a^{-1}a^{-1}ba^{-1} & = & ab^{-1}aa \cdot a^{-1}a^{-1}ba^{-1}\\
& = & ab^{-1}a \cdot a^{-1}ba^{-1}\\
& = & ab^{-1} \cdot ba^{-1}\\
& = & a \cdot a^{-1}\\
&=&e\\
\\
b^{-1}a^{-1}a^{-1}ba^{-1}\cdot ab^{-1}aab & = & b^{-1}a^{-1}a^{-1}b\cdot b^{-1}aab\\
& = & b^{-1}a^{-1}a^{-1}\cdot aab\\
& = & b^{-1}a^{-1}\cdot ab\\
& = & b^{-1}\cdot b\\
& = & e
\end{eqnarray}

Certes, vous pouvez voir que c'est l'inverse.

Faisons-le avec Python

Python est facile à faire car la surcharge d'opérateurs est facile. Je vais l'essayer immédiatement.

En tant que politique de mise en œuvre, nous aurons $ a $ et $ ab $ comme chaînes. De plus, l'élément inverse sera conservé par les lettres majuscules A et B.

Pour le calcul inverse, utilisez la méthode str.swapcase pour retourner la chaîne. J'utilise Python depuis de nombreuses années, mais c'est la première fois que j'utilise «swapcase» de ma vie. Cette méthode est une méthode qui rend les majuscules et minuscules minuscules et minuscules majuscules.

'heLLo woRLd,ゎ ゎ ゎ ωπ'.swapcase() # =>Le résultat est le suivant
'HEllO WOrlD,ゎ ゎ ΩΠ'

Malheureusement (?), Small hiragana ne grossit pas, mais il semble que les caractères grecs sont convertis même s'ils ne sont pas des caractères ASCII. Eh bien, je m'en fiche, alors mettons-le en œuvre.

J'ai pensé aux choses importantes, alors écrivons le code.

from collections import namedtuple

FreeGroupBase = namedtuple('FreeGroupBase', 's')
class FreeGroup(FreeGroupBase):
    def __init__(self, s: str):
        if s.lower().replace('a', '').replace('b', ''):
            # a,Vérifiez s'il est généré uniquement à partir de b
            raise ValueError('Unexpected element is contained')

    #Source inverse~Je vais le prendre comme un
    def __invert__(self) -> 'FreeGroup':
        return FreeGroup(self.s.swapcase()[::-1])

    #Arithmétique*Je vais le faire dans
    def __mul__(self, other: 'FreeGroup') -> 'FreeGroup':
        return FreeGroup(self._mul_impl(self.s, other.s))

    @classmethod
    def _mul_impl(cls, lhs: str, rhs: str) -> str:
        'Implémentation de l'arithmétique'
        if not lhs: #lhs est l'élément unitaire
            return rhs
        if not rhs: #rhs est l'unité
            return lhs
        if lhs[-1].swapcase() == rhs[0]: # ...a * ~a...Sous la forme d'un* ~peut annuler un
            return cls._mul_impl(lhs[:-1], rhs[1:])
        return lhs + rhs #Sinon, c'est juste une chaîne de chaînes

    def __repr__(self) -> 'str':
        if not self.s:
            return 'e'
        return ' * '.join(e if e.lower() else '~' + e.tolower() for e in self.s)

a = FreeGroup('a')
b = FreeGroup('b')
e = FreeGroup('')

g = a * b * b * a * ~b * ~b * ~a * a * b * (a * a * b)
print(g)
print(g * ~g)
print(~g * g)

Ouais, ça fait du bien.