I come from a mathematical physics background, so I have very little experience with other areas of Math, so what I say may not apply to mathematics research in general obviously (and probably much less for other areas of theoretical sciences). Please let me know if this question is suitable for this site.
In short, what I observed my field of mathematical physics is that most recent advancements generally consists of either finding links between physical models (like percolation, random walks, and spin models), or making an incremental (yet non-trivial) improvement over previous state-of-the-art techniques to solve major open problems. I suspect this to be true for most science fields as well (say theoretical physics or computer science).
I think the latter is exemplified in a very important paper by Duminil-Copin that rigorously establishes the criticality of the self-dual point for the random-cluster model. The paper is almost 30 pages long, but most of it is just basic motivation and introducing standard definitions or classical theorems to set up the main arguments. The core idea is encapsulated in exactly one figure (Figure 6 in the paper), and that is a modified box-crossing argument for percolation models satisfying the FKG inequality. However, to convey this very important argument, the author had to (justifiably) spend much ink on giving context, and I think this is a fundamental inefficiency of the paper-publishing medium.
On the contrary, I find that many software-development principles/techniques may address the inefficiency of paper-publishing, and perhaps they can be implemented in some sort of online system like Github. Note that I'm not suggesting that we should do mathematical research programmatically, or invent a new language that allows us to "code-up" proof. These software-development principles should only pertain to organizing and communicating the mathematical results (and not the act of deriving them). To give a few examples for concreteness.
Reducing code repetition: this one translates to collating and organizing a list of classical or recent results that is verified and deemed useful by most researchers into a "repository". Whenever a researcher wishes to communicate a result that heavily relies of them, they can simply "import" them from the corresponding repositories accepted by the community. Similar to how you would pip install and import numpy for Python projects, instead of rewriting these packages yourself from scratch (which most likely contains errors or be inefficient).
Incremental updates and version control: if one finds an improvement of an existing theorem/technique, then they should "clean-up" the findings and make the minimal changes necessarily to the existing "codebase". The referee process would then be some sort of pull-request review, and the "moderator" can then choose to accept or reject the changes based on correctness and relevance. Of course, this may be very difficult in practice, as it is unclear who that "moderator" should be, especially if the "commit" is exceptionally novel or difficult to understand. Of course, if the commit is later discovered to be incorrect, some sort of version control system would allow it to be easily undone.
Abstraction and inheritance: The act of "finding links between models/areas" would be analogous to a code-refactoring effort, which would better organize the existing "mathematical objects". For instance, the Ising model is a special case of the random-cluster model, so the former can simply subclass from the latter, inheriting the latter's "attributes and methods". Of course, the Ising model has many attributes/representations that the random-cluster model does not have, such as the random-current expansion. To handle this, one can simply add new attributes to the Ising model class without repeating the attributes inherited from the random-cluster model.
If everything goes well, the paper-publishing process would be akin to writing some custom scripts that rely on existing packages. For example, you would organize all the technical lemmas (that are not sufficiently general for committing to a major repo) into utility files, and the "paper" itself would be a main script that contains the actual logic of the proof using these lemmas and packages.
My questions are:
- Are there already existing systems that attempt to organize scientific research, or at least a very small research topic, into this sort of system? I know about the polymath project, but it's still a bit lacking in terms of the above-mentioned Github-like functionalities.
- Is this system any practical for mathematical research in general, especially for fields where results are generally less incremental or less problem-solving in nature?
- How would you think writing textbooks, monographs, or review papers would work under this framework, especially if they are pedagogical in nature?