It's about a formula (another word for algorithm) for computing the determinant, it's not like they shat a new theorem in category theory.
And however higher-mathy that may be, a link to a chunk of python code implementing the formula certainly would not have been detrimental to the paper.
Unless of course all of the other higher math folks would look down upon a despicable math researcher that would dare spoil a perfectly honorable higher math research paper by adding disgustingly usable code to it.
Think of the insult!
People could even get down to running the code just to check that the formula actually works !
Are you familiar with the different stages of research? This is "basic research" -- they found a new determinant formula and analyzed it. Others can pick up their work and continue, for example creating implementations and comparing their runtimes in practice. I think including a determinant implementation would be detrimental if it were not accompanied by this additional analysis, since people might use this implementation as the standard implementation, but very likely in practice there will be many implementation tricks to get it to work competitively.
They're certainly not above writing code. You seem to have missed the appendix, where they wrote some to prove that their bound on the tensor rank of 4x4 determinants over GF2 is exactly 12. https://gitlab.com/apgoucher/det4f2
Also, a formula is not an algorithm. You can oftentimes extract an algorithm from a formula, but the value of a formula in pure math is to be able to write something in a different way. Formulas reveal structure that (hopefully) can be exploited when solving other problems.
> People could even get down to running the code just to check that the formula actually works !
This is an interesting perspective, but you have to take into account that papers are written for some audience in mind -- this one is written for combinatorialists (hence the math.CO designation on the arXiv). It's not too hard of an exercise to plug this formula into Mathematica for this audience. But also, this audience would rather see a proof than computational evidence.
Sure, I'm a mathematician, but what point are you making beyond a potential ad hominem?
I myself include code in my own papers when it's useful. As the author of this paper mentioned (and it's something I'm a bit embarassed I missed), the asymptotics of this new algorithm do not compete with the usual O(n^3) algorithm, so it's not clear to me that having Python code would benefit anyone. Of course you never know, though I think the underlying concepts in their formula are significantly more difficult to learn than the notation itself, so the code also wouldn't help very much with understanding the formula.
Anyway, given that you're saying I'm in an ivory tower, doesn't that give me some authority to explain why the choice to not include code has nothing to do with it being an "insult" to the community or it "spoiling" the paper with "disgustingly usable code"?
> what point are you making beyond a potential ad hominem?
I guess I'm guilty of the exact same sin most math authors commit: I naively assumed that the readers of my post have the intellectual means to get to the obvious conclusion without crutches.
> so it's not clear to me that having Python code would benefit anyone
Please read my answer (and thanks) to the author where he addresses my complaint and does indeed publish the code (top of thread).
TL;DR: there are many (I'd wager most) people who vastly prefer reading code to reading obtuse abstract math papers written using specialized math jargon.
There is huge value in publishing your findings as code:
. it can be *understood* by people who happen not to live in your ivory tower and might neither be able to parse the language, the symbols, the "what is considered trivial by the author and not worth mentioning in the paper". Code is clear, unambiguous, down to earth and leaves no stone unturned.
. code can be *verified* by a machine, which goes a long way to prove that your entire paper isn't a giant pile of BS.
You jumped to conclusions that the code wasn't worth publishing because it isn't practical/efficient etc... You entirely missed the point. Code explains ideas clearly. Math papers very rarely do.
(Derailing this troll-initiated thread a bit with a serious answer)
> what’s the formula for quicksort
That is expressible! It’s what one would write in a proof assistant or powerful type system such as Coq, Agda, Idris. The formula is the algorithm, the type is the theorem (quicksort has type any-list and maps it to sorted-list, or in code – literally – `quicksort : Ordering(A) -> List(A) -> SortedList(A)`).
>It's about a formula (another word for algorithm)
They are not the same - there's plenty of formulas for which there is no algorithm, and even proofs in complexity theory proving there can never be an algorithm.
Algorithms merely formalize a tiny subset of math as things which are computable via a step by step process, and modern computers grew out of exactly the question of what things are computable. Turns out not much compared to the space of all "things."
A mathematical proof is a better guarantee that something works than a demonstration in code.
The higher math researchers usually pay for it being less accessible, because the first engineering paper that uses their works gets cited a lot more.
But that also leads to cargo-cult engineering, where the first implementation of the paper just gets copied around without understanding (e.g. if there are limitations/assumptions).
This, but unironically. Their formula (11) involves basics (sums and products), the only nontrivial part would be the partial partitions, and for that the first paragraph of chapter 2 explains how to get it from ordinary partitions, which is a standard function.