geometry_tools.utils.words 

 1import re
 2from collections import defaultdict
 3
 4def invert_gen(generator):
 5    if generator.lower() == generator:
 6        return generator.upper()
 7    return generator.lower()
 8
 9def formal_inverse(word, simple=True):
10    joinchar = ""
11    if not simple:
12        joinchar = "*"
13    return joinchar.join([invert_gen(g) for g in word[::-1]])
14
15def asym_gens(generators):
16    """Get an iterable of semigroup generators from an iterable of group generators.
17
18    Given a sequence of lowercase/uppercase letters, return only the
19    lowercase ones.
20
21    Parameters
22    ----------
23    generators : iterable of strings
24        Sequence of semigroup generators
25
26    Yields
27    ------
28    gen : string
29        the lowercase characters in `generators`
30
31    """
32    for gen in generators:
33        if gen.lower() == gen:
34            yield gen
35
36def simplify_word(word):
37    simp = ""
38    for let in word:
39        if len(simp) == 0 or let != invert_gen(simp[-1]):
40            simp += let
41        else:
42            simp = simp[:-1]
43    return simp
44
45def simplify(zmod):
46    return defaultdict(int, {simplify_word(word):zmod[word] for word in zmod})
47
48def aug(zmod):
49    return sum(zmod.values())
50
51def commutator(w1, w2):
52    return simplify_word(w1 + w2 + formal_inverse(w1) + formal_inverse(w2))
53
54def act_left(word, zmod):
55    prod = {word + zword:zmod[zword] for zword in zmod}
56    return simplify(prod)
57
58def act_right(zmod1, zmod2):
59    mult = aug(zmod2)
60    return defaultdict(int, {word:zmod1[word] * mult for word in zmod1})
61
62def zmod_sum(z1, z2):
63    z_sum = defaultdict(int, {word:coeff for word, coeff in z1.items()})
64    for word in z2:
65        z_sum[word] += z2[word]
66    return z_sum
67
68def fox_word_derivative(differential, word):
69    if len(word) == 1:
70        if word == differential:
71            return defaultdict(int, {"":1})
72        if word == formal_inverse(differential):
73            return defaultdict(int, {word:-1})
74        return defaultdict(int, {})
75
76    return zmod_sum(
77        fox_word_derivative(differential, word[0]),
78        act_left(word[0], fox_word_derivative(differential, word[1:]))
79    )
def invert_gen(generator): 
5def invert_gen(generator):
6    if generator.lower() == generator:
7        return generator.upper()
8    return generator.lower()
def formal_inverse(word, simple=True): 
10def formal_inverse(word, simple=True):
11    joinchar = ""
12    if not simple:
13        joinchar = "*"
14    return joinchar.join([invert_gen(g) for g in word[::-1]])
def asym_gens(generators): 
16def asym_gens(generators):
17    """Get an iterable of semigroup generators from an iterable of group generators.
18
19    Given a sequence of lowercase/uppercase letters, return only the
20    lowercase ones.
21
22    Parameters
23    ----------
24    generators : iterable of strings
25        Sequence of semigroup generators
26
27    Yields
28    ------
29    gen : string
30        the lowercase characters in `generators`
31
32    """
33    for gen in generators:
34        if gen.lower() == gen:
35            yield gen

Get an iterable of semigroup generators from an iterable of group generators.

Given a sequence of lowercase/uppercase letters, return only the lowercase ones.

Parameters
  • generators (iterable of strings): Sequence of semigroup generators
Yields
  • gen (string): the lowercase characters in generators
def simplify_word(word): 
37def simplify_word(word):
38    simp = ""
39    for let in word:
40        if len(simp) == 0 or let != invert_gen(simp[-1]):
41            simp += let
42        else:
43            simp = simp[:-1]
44    return simp
def simplify(zmod): 
46def simplify(zmod):
47    return defaultdict(int, {simplify_word(word):zmod[word] for word in zmod})
def aug(zmod): 
49def aug(zmod):
50    return sum(zmod.values())
def commutator(w1, w2): 
52def commutator(w1, w2):
53    return simplify_word(w1 + w2 + formal_inverse(w1) + formal_inverse(w2))
def act_left(word, zmod): 
55def act_left(word, zmod):
56    prod = {word + zword:zmod[zword] for zword in zmod}
57    return simplify(prod)
def act_right(zmod1, zmod2): 
59def act_right(zmod1, zmod2):
60    mult = aug(zmod2)
61    return defaultdict(int, {word:zmod1[word] * mult for word in zmod1})
def zmod_sum(z1, z2): 
63def zmod_sum(z1, z2):
64    z_sum = defaultdict(int, {word:coeff for word, coeff in z1.items()})
65    for word in z2:
66        z_sum[word] += z2[word]
67    return z_sum
def fox_word_derivative(differential, word): 
69def fox_word_derivative(differential, word):
70    if len(word) == 1:
71        if word == differential:
72            return defaultdict(int, {"":1})
73        if word == formal_inverse(differential):
74            return defaultdict(int, {word:-1})
75        return defaultdict(int, {})
76
77    return zmod_sum(
78        fox_word_derivative(differential, word[0]),
79        act_left(word[0], fox_word_derivative(differential, word[1:]))
80    )