Balthazar is starting a PhD in modular representation theory of semigroups

- Representation theory of groups: a grand old topic; 10k+ papers in a century
- Representation theory of the symmetric group $\mathfrak{S}_n$: beautiful combinatorics

- Modular representation theory of groups: 1k+ papers in the last 50 years

- Representation theory of semigroups: dozens of papers in the last decades

- Motto of semigroup theory: reduce to
**combinatorics**+**group theory**

- Implement a algorithm of 2010 in full generality

Computing the Cartan Matrix of a semigroup - Adapt this algorithm to the modular</modular> case
- Explore the representation theory of the transformation semigroup $T_n$

beautiful combinatorics?

**Program**and**explore**- Take advantage of
**all the existing computational tools**

Built from many tools in our toolkit :

In [1]:

```
import sage_annotations
from mygap import mygap
mygap.LoadPackage("Semigroups");
import sage_semigroups
import sage_combinat_widgets
from sage_explorer import explore
from sage_explorer.sage_explorer import Settings
Settings.add_property('cardinality', predicate=Groups().Finite().__contains__)
Settings.add_property('conjugacy_classes', predicate=Groups().Finite().__contains__)
Settings.add_property('multiplication_table', predicate=Groups().Finite().__contains__)
%display unicode_art
tensor.symbol = " ⊗ "
%run style/odk.py
```

In [ ]:

```
T5 = mygap.FullTransformationSemigroup(5)
```

In [ ]:

```
T3 = mygap.FullTransformationSemigroup(3)
graph = T3.cayley_graph()
graph.set_latex_options(format="dot2tex")
view(graph)
```

In [ ]:

```
from francy_widget import FrancyWidget
from networkx import DiGraph
g = DiGraph()
g.add_edges_from([(e[0], e[1]) for e in graph.edges()])
FrancyWidget(g)
```

In [ ]:

```
T5.cardinality()
```

In [ ]:

```
d_classes = T5.d_classes()
for d_class in d_classes:
print(d_class)
```

In [ ]:

```
G = d_classes[1].schutzenberger_group()
G
```

In [ ]:

```
reps = G.irreducible_representations(GF(3))
for rho in reps:
display([matrix(rho(g).gap()) for g in G.group_generators()])
```

In [ ]:

```
all( [ rho(g)*rho(h) == rho(g*h) for g in G for h in G ] )
```

- Sage uses GAP for groups

- GAP uses MeatAxe (C library)

parallelism of MeatAxe64

- Sage uses GAP's Semigroup packages for semigroups

J. Mitchell et al.

- Semigroups uses libsemigroups (C++ library)

J. Mitchell, inspired by Semigroupe of J.-E. Pin

- libsemigroups uses HPC Combi

F. Hivert , with feedback from J. Mitchell

One of ODK case studies for interfacing with other systems

libgap used to be a fragile hard to maintain fork of GAP

Volker Braunlibgap is now a standard feature of GAP

M. Horn, A. Konovalov , M. Pfeiffer , J. Demeyer , E. M. Bray , N. Thiéry , D. Pasechnik

GAP-Sage Days 2016, 2017, 2018Made possible by GAP's build system refactoring

M. Horn, A. Konovalov , ...A major step for sustainable packaging of GAP and Sage

One of ODK case study for extracting independent low-level libraries C++

libsemigroups API design:

J. Mitchell with F. Hivert and N. Thiéry: Cernay 2017, 2018libsemigroups Python bindings

J. Mitchell and N. Thiéry : Edinburgh, 2017, Cernay 2017, 2018libsemibroups usable directly in Jupyter thanks to xeus-cling

S. Corlay, J. Mabile, L. Gouarinlibsemigroups packaging

J. Mitchell and N. Thiéry : Jupyter for Mathematics Workshop, Edinburgh, 2017

In [ ]:

```
A = T5.algebra(QQ); A
```

In [ ]:

```
A.an_element() ^ 3
```

- Enriched libgap handles with
- Semantic carried over using
Alignments provided as annotations

@semantic(mmt="Group", variant="multiplicative") class Groups: class ParentMethods: @semantic(gap="GeneratorsOfGroup", codomain=Family[Self]) @abstract_method def group_generators(self): pass

In [ ]:

```
explore(G)
```

In [ ]:

```
StandardTableaux(10).random_element()
```

In [ ]:

```
Sym = SymmetricFunctions(QQ['t']);
s = Sym.s()
```

In [ ]:

```
s[2,1].coproduct()
```

In [ ]:

```
@interact
def f(p1 = Partition([2,1])._widget_()):
return s[p1].coproduct()
```

In [ ]:

```
list(RibbonTableaux([[5,4,3],[2,1]], [2,1], 3))
```

In [ ]:

```
Sym.llt(3)
```

Balthazar has at his fingertips the **best computational tools** developed by **different math communities**, all from a **single Virtual Research Environment**:

- Modular representation theory of groups
- Combinatorial Representation theory
- Semigroup theory
- Algebraic Combinatorics

And:

- Experimental code from his research group
- His own code

*Balthazar can:*

- easily
**record**and**reuse**data he computes (e.g. character tables, ...)

py-persist, Memoize **document**it with metadata**publish**it online, e.g. on http://data.mathhub.info !

*Balthazar can use his Basic Lab Skills to:*

Prepare

**proper computational logbooks****Track**his work with version control (nbdime )Turn his notebooks into slideshows

**Publish**his work on a public repository, e.g. on GitHubDocument the software dependencies, e.g. as a Dockerfile

Make it easy for others to

**reuse**and**reproduce**, e.g. on BinderRun his computations elsewhere, e.g. on a powerful VRE

Use

**live-collaboration**, e.g. to get help from his advisor!

Modularity, ease of installation and deployment, sustainability:

- Packaging in Docker, Debian, Conda

E. Bray , J Rüth , et al. et al.

Cernay 2016, 2017, 2019 - Ease to install packages in GAP: GAP's PackageManager

Michael Torpey - Integration in Sage of libsemigroups and Semigroups

D. Paseshnik et al. - Ease of authoring and distributing packages for Sage

Sage package repository with pip ( et al.)

Examples: sage-annotations , sage-explorer , sage-combinat-widgets , sage-gap-semantic interface , sage-semigroups

N. Thiéry , O. Bénassy et al. - Migration to Python 3

F. Chapoton, E. Bray , D. Paseshnik , J Demeyer , ...

Needed:

- Group theory: GAP
- Computer Algebra: MuPAD
- Gröbner bases: FGb

PerMuVAR in MuPAD

- Ugly homegrown C++ permutation group library (GLIP) + low level interface
- Text interface to FGb
- Student project: Lyx as notebook interface

Was MuPAD the right choice?

SageMath: finally GAP, PARI, Singular, Python, ... all under the same open source roof!

In [ ]:

```
G = gap.SymmetricGroup(7)
%time l = list(G.List())
```

- 201?: first libgap prototype: C-level interface to GAP

In [ ]:

```
G = libgap.SymmetricGroup(7)
%time l = list(G.List())
```

- Collaboration Hivert / Borie
- 1000x speedup!
- Value of vectorization and low level parallelism for combinatorics

Needs:

- Coxeter groups (in GAP3)
- Semigroups (GAP's Semigroup package, Semigroupe)
- Combinatorics, Algebra, ... (Sage)

Technical problems:

- Semigroupe unusable as C++ library beyond proof of concept
- libgap incompatible with GAP packages
- libgap hard to maintain

Usability problems:

- GAP groups behaving as native Sage groups
- GAP semigroups
**not**behaving as native Sage semigroups

Consequences:

- Fragmented communities: users have to choose between systems
- Lots of reimplemented code in Sage
- An algorithm of 2010 still not implemented in full generality

Semigroupe -> Jean-Eric Pin

Proof of concept binding from Sage, but does not scale

libsemigroups

Python bindings (joint sprint with James)

Conda packaging (joint sprint with James)

Bindings with cppy (Cernay workshop): non functional

Use from xeus-cling (@LoicGouarin, Johan Mabile, ): functional: run the index.ipynb notebook of https://github.com/james-d-mitchell/libsemigroups on binder.

Use sage-explorer

A widget to display tableaux

Modular rep theory from GAP.

MeatAxe

LLT, symmetric functions, ...

- Call for help: live-collaboration @minrk

pypersist / Memoize

Already used by Pauline.

Working at Huawey and YouTube; using Jupyter on a daily basis for machine learning!