Marek Kaluba
f751a318b9
Mk/final touches |
||
---|---|---|

data | ||

docs | ||

magma | ||

scripts | ||

src | ||

.gitignore | ||

Makefile | ||

Manifest.toml | ||

Project.toml | ||

README.md | ||

adj_psl2_eigvals.jl | ||

runcomputations.jl |

####
**README.md**

**README.md**

The repository contains code for running experiments for
*Hyperbolic generalized triangle groups, property (T) and finite simple quotients* by
Pierre-Emmanuel Caprace,
Marston Conder,
Marek Kaluba and
Stefan Witzel.

# Introduction

If you arrived here after reading the article looking for groups and

- you don't understand any of this, you probably want to visit this page instead;
- you want just the machine-readable data, then the
`json`

file is available here (the file was generated by calling`julia ./scripts/create_json/create_json.jl`

); - 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:

- certified eigenvalue computations for
*PSL₂(p)*, - sum of squares computations in an attempt to prove property (T) by estimating spectral gap of the group Laplacian,
- 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 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

```
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

```
α = 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

```
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 mostlyunsuccessful computationas 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. For full description of the method plesase refer to 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

```
make 8_40_54_2
```

One can perform those computations in bulk by e.g. calling

```
make 2_4_4
```

to run all examples in `presentations_2_4_4.txt`

in parallel.

## Creating the tables of arXiv: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

```
python3 hyperbolic_words.py
```

and then load the resulting file `small_hyperbolic.magma`

in Magma.