{Topic was how the software computes signatures of invariant Hermitian
forms, and how Marc van Leeuwen has made that faster. Here is how to
tell how fast atlas does something:}

dav% time ../atlas all

{The unix command "time" asks the operating system to keep track of
how much CPU time the command takes.}

This is 'atlas' (version 1.0.7, axis language version 0.9.9),
the Atlas of Lie Groups and Representations interpreter,
compiled on Mar 18 2020 at 08:53:07.   http://www.liegroups.org/
atlas> is_unitary(SL(8,R).trivial)
Value: true
atlas> quit
Bye.
31.812u 0.738s 1:02.98 51.6%	0+0k 0+0io 0pf+0w

{The number 31.812u means 31.8 seconds of user time requested by the
process. The other numbers are less important: .738s means that the
operating system spend 3/4 of a second doing housekeeping: helping
this process take turns with other processes, allocating memory...}

{This is the "master" version of the software, that you are probably
running. Now I'll do the same thing on Marc's new "common_blocks"
version:}

% time ../atlas all
This is 'atlas' (version 1.0.7, axis language version 0.9.9),
the Atlas of Lie Groups and Representations interpreter,
compiled on Mar 24 2020 at 09:21:39.   http://www.liegroups.org/
atlas> is_unitary(SL(8,R).trivial)
Value: true
atlas> quit
Bye.
9.685u 0.123s 0:33.90 28.9%	0+0k 0+0io 0pf+0w

{So 9.7 seconds instead of 31.8. Pretty impressive!}

{Next came a bunch of atlas stuff meant to illustrate the theory I was
discussing (on the slides atlassem3.31.20SCRATCH.pdf

First topic was the meaning of the "height" of a parameter. It
measures the size of the discrete series part lambda in a parameter
(lambda, nu). Discrete series have large height, and
finite-dimensional reps (attached to the last, open, KGB orbit) have
small height.}

atlas> set p=parameter(Sp(4,R),0,[2,1],[0,0])
Variable p: Param

atlas> height(p)
Value: 7

{This is a discrete series representation, since it uses the smallest
KGB element #0.}

atlas> height(Sp(4,R).trivial) 
Value: 0


atlas> composition_series(Sp(4,R).trivial)

{this means the composition series not of the trivial representation
(BORING!) but of the standard representation I(gamma) with J(gamma) =
trivial.}

Value: 
1*parameter(x=10,lambda=[2,1]/1,nu=[2,1]/1) [0]
1*parameter(x=9,lambda=[2,1]/1,nu=[3,3]/2) [2]
1*parameter(x=8,lambda=[2,1]/1,nu=[2,0]/1) [3]
1*parameter(x=7,lambda=[2,1]/1,nu=[2,0]/1) [3]
1*parameter(x=6,lambda=[2,1]/1,nu=[0,1]/1) [6]
1*parameter(x=5,lambda=[2,1]/1,nu=[0,1]/1) [6]
2*parameter(x=4,lambda=[2,1]/1,nu=[1,-1]/2) [6]
1*parameter(x=1,lambda=[2,1]/1,nu=[0,0]/1) [7]
1*parameter(x=0,lambda=[2,1]/1,nu=[0,0]/1) [7]

{This composition series ends with the discrete series p I defined
earlier.}

atlas> p
Value: final parameter(x=0,lambda=[2,1]/1,nu=[0,0]/1)


{An atlas composition_series is always ordered by increasing
height. The height of each parameter in the composition series is the
last entry in each row.}

{This next thing, printing the heights of each term in the composition
series, was dumb, since the heights are already written above. But
I'll leave it here.}

atlas> set C = composition_series(Sp(4,R).trivial)
Variable C: ParamPol (overriding previous instance, which had type
string (constant))

atlas> void: for q in monomials(C) do prints(height(q)," ",q) od

0 final parameter(x=10,lambda=[2,1]/1,nu=[2,1]/1)
2 final parameter(x=9,lambda=[2,1]/1,nu=[3,3]/2)
3 final parameter(x=8,lambda=[2,1]/1,nu=[2,0]/1)
3 final parameter(x=7,lambda=[2,1]/1,nu=[2,0]/1)
6 final parameter(x=6,lambda=[2,1]/1,nu=[0,1]/1)
6 final parameter(x=5,lambda=[2,1]/1,nu=[0,1]/1)
6 final parameter(x=4,lambda=[2,1]/1,nu=[1,-1]/2)
7 final parameter(x=1,lambda=[2,1]/1,nu=[0,0]/1)
7 final parameter(x=0,lambda=[2,1]/1,nu=[0,0]/1)

{Here I was pointing out that atlas can figure out which standard
representations are reducible; and in particular, for which values of
t in [0,1] is I(lambda,t.nu) reducible.}

atlas> test_line(Sp(4,R).trivial)
testing line through final parameter(x=10,lambda=[2,1]/1,nu=[2,1]/1)
reducibility points: [1/3,1/2,1/1]
integrality points (for 2*nu): [1/6,1/4,1/3,1/2,2/3,3/4,5/6,1/1]
[ 2, 1 ]/6: true
[ 2, 1 ]/3: true
[ 10,  5 ]/12: false
[ 2, 1 ]/2: false
[ 6, 3 ]/4: false
[ 2, 1 ]/1: true

{The software is reporting whether J(lambda,t.nu) is unitary at each
reducibility point, and at a random point along each irreducibility
interval (t_{i-1},t_i).}

{I explained that the unitarity calculation requires keeping track of
a large library of parameters and their corresponding blocks. Last
thing I did was run a version of atlas that reports exactly how many
blocks and how many parameters it considered.}

atlas> is_unitary(Sp(4,R).trivial)
Value: true #blocks = 11 #param_table = 17

{The block of the trivial representation in Sp(4,R) has 12
parameters. In order to complete the unitarity calculation, it needs
to look at ten _more_ blocks and five more parameters. (The number
five sounds too low; probably I put in the counting code in some
incomplete way.)

atlas> is_unitary(F4_s.trivial)
Value: true #blocks = 48912 #param_table = 87343
atlas> {constructed almost 50,000 blocks: deformation CHANGES infl char}

{Turns out I REALLY don't understand what these numbers are, so I'm
not going to say any more about it now.}