The repository contains code for running experiments for
[_Hyperbolic generalized triangle groups, property (T) and finite simple quotients_](https://arxiv.org/abs/2011.09276) by
[Pierre-Emmanuel Caprace](https://perso.uclouvain.be/pierre-emmanuel.caprace/),
[Marston Conder](https://www.math.auckland.ac.nz/~conder/),
[Marek Kaluba](https://kalmar.faculty.wmi.amu.edu.pl/) and
[Stefan Witzel](https://www.math.uni-bielefeld.de/~switzel/).

# Introduction
If you arrived here after reading the article looking for groups and
 1. you don't understand any of this, you probably want to visit [this page](https://kalmarek.github.io/SmallHyperbolic/) instead;
 2. you want just the machine-readable data, then the `json` file is available [here](https://github.com/kalmarek/SmallHyperbolic/blob/master/data/triangle_groups.json) (the file was generated by calling `julia ./scripts/create_json/create_json.jl`);
 3. you want to re-run some of the computations that lead to the results, then continue reading.

# Computations

There are three disjoint computations covered in this repository:
 1. certified eigenvalue computations for _PSL₂(p)_,
 2. sum of squares computations in an attempt to prove property (T) by estimating spectral gap of the group Laplacian,
 3. generation of magma files used to compute e.g. witnesses for non-hyperbolicity, rank of abelianization, etc.

## Eigenvalues computations for _PSL₂(p)_

This computations uses package
[RamanujanGraphs.jl](https://github.com/kalmarek/RamanujanGraphs.jl) which
implements (projective, special) linear groups of degree 2 (_PSL₂(p)_, _SL₂(p)_,
_PGL₂(p)_ and _GL₂(p)_) and the irreducible representations for _SL₂(p)_.

The script `adj_psl2_eigvals.jl` computes a subset of irreps of _SL₂(p)_ which
descend to (mostly irreducible) representations of _PSL₂(p)_ in the following
fashion.

### Principal Series

These representations are associated to the induced representations of _B(p)_,
the _Borel subgroup_ (of upper triangular matrices) of _SL₂(p)_.
All representations of the Borel subgroup come from the representations of the
torus inside (i.e. diagonal matrices), hence are _1_-dimensional.

Therefore to define a matrix representation of _SL₂(p)_ one needs to specify:
 * a complex character of 𝔽ₚ (finite field of _p_ elements)
 * an explicit set of representatives of _SL₂(p)/B(p)_.

In code this can be specified by

```julia
p = 109 # our choice of a prime
ζ = root_of_unity((p-1)÷2, ...) # ζ is (p-1)÷2 -th root of unity
# two particular generators of SL₂(109):
a = SL₂{p}([0 1; 108 11])
b = SL₂{p}([57 2; 52 42])

S = [a, b, inv(a), inv(b)] # symmetric generating set
SL2p, _ = RamanujanGraphs.generate_balls(S, radius = 21)

Borel_cosets = RamanujanGraphs.CosetDecomposition(SL2p, Borel(SL₂{p}))
# the generator of 𝔽ₚˣ
α = RamanujanGraphs.generator(RamanujanGraphs.GF{p}(0))

ν₅ = let k = 5 # k runs from 0 to (p-1)÷4, or (p-3)÷4 depending on p (mod 4)
  νₖ = PrincipalRepr(
      α => ζ^k, # character sending α ↦ ζᵏ
      Borel_cosets
    )
end

```

### Discrete Series

These representations are associated with the action of _SL₂(p)_ (or in more
generality of _GL₂(p)_) on ℂ[𝔽ₚ], the vector space of complex valued functions
on 𝔽ₚˣ. There are however multiple choices how to encode such action.

Let _L_ = 𝔽ₚ(√_α_) be the unique quadratic extension of 𝔽ₚ by a square of a
generator _α_ of 𝔽ₚˣ. Comples characters of _Lˣ_ can be separated into
_decomposable_ (the ones that take constant 1 value on the unique cyclic
subgroup of order _(p+1)_ in _Lˣ_) and _nondecomposable_. Each _nondecomposable_
character corresponds to a representation of _SL₂(p)_ in discrete series.

To define matrix representatives one needs to specify
* _χ_:𝔽ₚ⁺ → ℂ, a complex, non-trivial character of the _additive group_ of 𝔽ₚ
* _ν_:_Lˣ_ → ℂ, a complex indecomposable character of _Lˣ_
* a basis for ℂ[𝔽ₚ].

Continuing the snippet above we can write

```julia
α = RamanujanGraphs.generator(RamanujanGraphs.GF{p}(0)) # a generator of 𝔽ₚˣ
β = RamanujanGraphs.generator_min(QuadraticExt(α))
# a generator of _Lˣ_ of minimal "Euclidean norm"

ζₚ = root_of_unity(p, ...)
ζ = root_of_unity(p+1, ...)

ϱ₁₇ = let k = 17 # k runs from 1 to (p-1)÷4 or (p+1)÷4 depending on p (mod 4)
    DiscreteRepr(
    RamanujanGraphs.GF{p}(1) => ζₚ, # character of the additive group of 𝔽ₚ
    β => ζ^k, # character of the multiplicative group of _L_
    basis = [α^i for i in 1:p-1] # our choice for basis: the dual of
)
```

A priori ζ needs to be a complex _(p²-1)_-th root of unity, however one can show
that a reduction to _(p+1)_-th Cyclotomic field is possible.

The script computing eigenvalues should be invoked by running

```bash
julia --project=. adj_psl2_eigvals.jl -p 109
```

The results will be written into `log` directory.

## Sum of squares approach to property (T)

> **NOTE**: This is mostly __unsuccessful computation__ as for none of the groups we examined
the computations returned positive result (with the exception of Ronan's
examples of groups acting on Ã₂-buildings).

We try to find a sum of squares for various finitely presented groups using
julia package [PropertyT.jl](https://github.com/kalmarek/PropertyT.jl). For
full description of the method plesase refer to
[1712.07167](https://arxiv.org/abs/1712.07167).

The groups available are in the `./data` directory in files
`presentations*.txt` files (in Magma format). For example
```
G_8_40_54_2 := Group< a, b, c  |
    a^3, b^3, c^3,
    b*a*b*a,
    (c*b^-1*c*b)^2,
    (c^-1*b^-1*c*b^-1)^2,
    c*a*c^-1*a^-1*c^-1*a*c*a^-1,
    (c*a*c^-1*a)^3>
```
specifies group `G_8_40_54_2` as finitely presented group.

The script needs GAP to be installed on the system (one can set `GAP_EXECUTABLE`
environmental variable to point to `gap` exec). and tries to find both an
automatic structure and a confluent Knuth-Bendix rewriting system on the given
presentation. To attempt sum of squares method for proving property (T) one can
execute
```bash
make 8_40_54_2
```

One can perform those computations in bulk by e.g. calling
```bash
make 2_4_4
```
to run all examples in `presentations_2_4_4.txt` in parallel.

## Creating the tables of [arXiv:2011.09276](https://arxiv.org/abs/2011.09276)

The scripts are located in `magma` directory and thoroughly commented.
There are two files, one contains the core Magma code used to create the tables,
the other one is a python script that augments the magma file by a list of
hyperbolic words. To use it put both files in a common folder, run
```bash
python3 hyperbolic_words.py
```
and then load the resulting file `small_hyperbolic.magma` in Magma.