[Edited to take comments into account.]

## Bicyclic graphs with top algebraic connectivity

One can construct the list using Nauty's generator and filtering
by the desired conditions.

Note that Nauty's generator can already filter by minimum and maximum
number of edges using `mine:maxe`

(for "**min**imum number of **e**dges",
"**max**imum number of **e**dges") -- thanks to @rburing for pointing
this out; see note below on ways to browse the documentation.

There are 236 bicyclic graphs on 8 vertices:

```
sage: bicy8 = [g for g in graphs.nauty_geng("8 9:9 -c")]
sage: len(bicy8)
236
```

For a given graph `g`

, its algebraic connectivity is the second
smallest laplacian eigenvalue, so it can be obtained as
`sorted(g.laplacian_matrix().eigenvalues())[1]`

.

Compute their algebraic connectivity, and the top algebraic connectivity:

```
sage: ac = [sorted(g.laplacian_matrix().eigenvalues())[1] for g in bicy8]
sage: tac = max(ac)
1
```

Extract graphs with top algebraic connectivity:

```
sage: gg = [g for i, g in enumerate(bicy8) if ac[i] == tac]
```

There are three:

```
sage: len(gg)
3
```

Their edges:

```
sage: for g in gg:
....: print(g.edges(labels=None))
....:
[(0, 6), (0, 7), (1, 6), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7)]
[(0, 5), (0, 7), (1, 6), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7)]
[(0, 3), (0, 6), (1, 4), (1, 6), (2, 5), (2, 6), (3, 7), (4, 7), (5, 7)]
```

Show them:

```
sage: for g in gg:
....: g.show()
```

## Documentation of Nauty's graph generator

The documentation is available via any of the following solutions,
which respectively give the documentation in text mode, the full
source code in text mode, and the documentation in html mode:

```
$ graphs.nauty_geng?
$ graphs.nauty_geng??
$ browse_sage_doc(graphs.nauty_geng)
```

The html documentation can also be browsed locally (at least if you installed
from source or from binaries from the Sage download pages) by pointing a browser
to `SAGE_ROOT/local/share/doc`

(where `SAGE_ROOT`

denotes the root directory
of your local Sage installation).

Or see the online SageMath documentation (html or pdf).

## To avoid storing a long list graphs

To avoid storing all bicyclic graphs on 8 vertices in a list, one could run
through them, keeping and updating a current value of the top algebraic
connectivity and a current list of graphs achieving it.

```
sage: tac = 0
sage: gtac = []
sage: for g in graphs.nauty_geng("8 9:9 -c"):
....: ac = sorted(g.laplacian_matrix().eigenvalues())[1]
....: if ac == tac:
....: gtac.append(g)
....: elif ac > tac:
....: tac, gtac = ac, [g]
```

In the end we get the top algebraic connectivity:

```
sage: tac
1
```

and know how many graphs achieve it:

```
sage: len(gtac)
3
```

and we can show their edges:

```
sage: [g.edges(labels=None) for g in gtac]
[[(0, 6), (0, 7), (1, 6), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7)],
[(0, 5), (0, 7), (1, 6), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7)],
[(0, 3), (0, 6), (1, 4), (1, 6), (2, 5), (2, 6), (3, 7), (4, 7), (5, 7)]]
```

or visualize them:

```
sage: for g in gtac:
....: g.show(layout='circular')
```

Note there are other options for visualization, including:

`g.show(layout='circular')`

`g.show(layout='planar')`

`g.show(method='js')`

## Defining a function

The code above can be turned into a function of the number of vertices:

```
def top_alg_conn(n):
m = n + 1
tac = 0
gtac = []
for g in graphs.nauty_geng("{} {}:{} -c".format(n, m, m)):
ac = sorted(g.laplacian_matrix().eigenvalues())[1]
if ac == tac:
gtac.append(g)
elif ac > tac:
tac, gtac = ac, [g]
return tac, gtac
```

For 9 vertices this might take something like 10 seconds:

```
sage: tac, gtac = top_alg_conn(9)
sage: tac, len(gtac)
(1, 2)
sage: for g in gtac:
....: print(g.edges(labels=False))
[(0, 7), (0, 8), (1, 7), (1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 8), (7, 8)]
[(0, 6), (0, 8), (1, 7), (1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 8), (7, 8)]
```

For 10 vertices this might take on the order of 30 seconds:

```
sage: tac, gtac = top_alg_conn(10)
sage: tac, len(gtac)
(1, 2)
sage: for g in gtac:
....: print(g.edges(labels=False))
[(0, 8), (0, 9), (1, 8), (1, 9), (2, 9), (3, 9), (4, 9), (5, 9), (6, 9), (7, 9), (8, 9)]
[(0, 7), (0, 9), (1, 8), (1, 9), (2, 9), (3, 9), (4, 9), (5, 9), (6, 9), (7, 9), (8, 9)]
```

For 11 vertices this might take on the order of 2 minutes:

```
sage: %time tac, gtac = top_alg_conn(11)
CPU times: user 2min 5s, sys: 960 ms, total: 2min 6s
Wall time: 2min 9s
sage: tac, len(gtac)
(1, 2)
sage: for g in gtac:
....: print(g.edges(labels=False))
[(0, 9), (0, 10), (1, 9), (1, 10), (2, 10), (3, 10), (4, 10), (5, 10), (6, 10), (7, 10), (8, 10), (9, 10)]
[(0, 8), (0, 10), (1, 9), (1, 10), (2, 10), (3, 10), (4, 10), (5, 10), (6, 10), (7, 10), (8, 10), (9, 10)]
```

And so on...

See also Graphs having highest second smallest laplacian eigen value from a collection.

@rburing -- I had missed that. Indeed the answer there adapts to the question here.