I called my evidence "certificates." An OEIS editor asked what they proved.

I do mathematics with AI agents: they write code, run it and write up the results, and I direct the work and check it. In September one of those results was a new term for the OEIS (the Online Encyclopedia of Integer Sequences), a large public database of number sequences that mathematicians use.

The count#

The sequence was A307185. It counts the basic shapes from which phylogenetic networks are built. A phylogenetic network is a family tree of species in which lineages can merge, as in hybridization, as well as split. Level 6 means shapes with exactly six merge points; specialists call these shapes generators. Every network of this complexity or less can be built from these shapes and simpler ones, with ordinary branches hung off them. Programs that reconstruct species histories from data start from this list of shapes, so a missing shape could mean a missed answer. The published entry stopped at level 5. My agents computed level 6 and found 5,539,121^▲ shapes.

The word#

New terms go into the OEIS as a public draft that the database's editors review, with a link to your evidence. My evidence was a public archive of the code and its output, and I labeled the link "enumeration code, certificates and the generator files."

"Certificates" came from software. To tell the shapes apart, the agents used nauty, a standard program that gives each graph (here, each shape) an ID string, and nauty's documentation calls that string a certificate. The agents used nauty's word in their run notes and file names, and I carried it into the archive's title and the link. To a mathematician, a certificate is a proof you can check without redoing the work.

On 2026-09-14, Andrew Howroyd, an OEIS editor, asked on the draft: "What does certificates mean here? This is some kind of self-certification - perhaps would be better called log file?" A few minutes later he asked: "How do these certificates allow someone to check the correctness of the terms without rerunning the code?"

What the files proved: at least this many, not exactly this many#

Anyone with the files can check that every listed shape is a valid level-6 shape, and can sort the ID strings to confirm that no shape appears twice. That shows the count is at least 5,539,121.

The files cannot show the count is exactly that. A shape the code never produced would simply be absent, and nothing in the files would reveal the gap. Showing that nothing is missing means rerunning the computation, which starts from the published list of level-5 shapes and applies published rules for building the next level. Two separately written programs had done that and produced identical lists. That is strong evidence for the exact count, but a reader cannot check it from the files alone.

The same day, I posted a reply under my name on the draft saying exactly this, and added the same statement to the archive's README. I replaced "certificates" with "canonical-form lists" (that is, lists of the ID strings) in the archive and the link. The files in the archive still have names ending in .cert, because the archive had already been published with those names; a note there explains the old word. The term was approved on 2026-09-25 with the count unchanged.

The checklist I use now#

My checks on this work were all aimed at the number. None of them read the wording, which had been copied from tool output. For every result I publish with files, I now write down three things:

• What a reader can confirm from the files alone. Here: each shape is valid, and none repeats.
• What still requires rerunning the code, or trusting that it was run. Here: that nothing is missing.
• Whether any word claims more than that. Before a word that means proof to the reader (certificate, certified, verified, proven) goes into a title, a metadata field or a database entry, I read it in that reader's sense, and spell out a narrower meaning or pick another word.

For specialists#

The level-6 set was produced by applying the two rules of Gambette, Berry and Paul (2009) to the published level-5 generators and deduplicating with two independently written canonical forms: nauty, and a nauty-free rooted traversal. The two routes produced byte-identical generator sets. Before the level-6 run, both reproduced a(1) to a(5) and matched the published level-4 and level-5 generator sets exactly.

From the files, a reader can validate each listed graph as a level-6 generator by a local check (vertex types by indegree and outdegree, exactly six indegree-2 vertices, acyclic, biconnected) and confirm pairwise distinctness by sorting the canonical forms. That certifies a lower bound on a(6). Completeness rests on rerunning the expansion, and on the source paper's result that the two rules generate every level-6 generator, which is taken from that paper and not re-proved here.

@misc{orden2026certificatemeantsomethingelse,
  author       = {Tyler Satchel Orden},
  title        = {I called my evidence "certificates." An OEIS editor asked what they proved.},
  year         = {2026},
  howpublished = {Cyborg Mathematics},
  url    = {https://cyborgmathematics.com/writing/certificate-meant-something-else}
}