# MightBe paper — arXiv submission package

Author: yxpil
Artifact: <https://github.com/yxpil/MightBe>

## Title

**MightBe: An Audited Neural Runtime with Hot Structural Mutation and Traceable Multi-Hop Reasoning**

## Suggested arXiv classification

- Primary: `cs.LG` (Machine Learning)
- Cross-lists: `cs.AI` (Artificial Intelligence), `cs.DB` (Databases), `cs.CL` (Computation and Language)

`cs.LG` is the right primary because the subject is a training/inference
runtime and its autodiff tape. `cs.DB` is the natural cross-list: half the
system is a paged, logged, encrypted key-value store with a SQL dialect and a
learned index, and the insert-trigger contribution is a database mechanism
rather than a learning one. `cs.CL` covers the text pipeline (normalisation,
tokenisation, TF-IDF, TextRank, PMI); `cs.AI` covers the reasoning layer.

## Abstract (verbatim)

> MightBe is a single-process system that couples a from-scratch neural-network
> runtime to a relational store through a learned, auditable index. We make
> three contributions. First, we specify a hot-mutation protocol for a live
> network: an \textsc{alter} operation is merged into a candidate specification,
> validated, rebuilt, and re-hydrated with weights migrated by
> (layer, parameter, shape); the candidate must then pass a smoke forward pass
> on a zero tensor before it is published, and publication is a lock-free atomic
> swap of an `ArcSwap`-held snapshot, so readers in flight continue to
> observe the previous version and any failure leaves the previous version
> serving unchanged. Second, we give an auditable inference graph in which every
> answer is a scored path together with a bounded evidence set, and we specify
> the confidence algebra exactly: a path score is a product of per-step
> contributions, several paths reaching the same node are combined by a noisy-OR,
> and a verifier reranks the result by geometric interpolation with a semantic
> similarity term. Third, we couple the store to the learned index with an
> idempotent insert trigger that routes text rows through a normalization,
> tokenization, TF-IDF, TextRank and pointwise-mutual-information pipeline before
> the association graph is built. We report the complete result of the
> artifact's own test suite --- 32 test targets, 251 tests, all passing, one
> doc-test ignored --- and we state plainly that the repository contains no
> benchmarks and no accuracy or latency measurements, so we give a measurement
> protocol rather than results. We also disclose that the test suite itself was
> generated with the assistance of a large language model, and that six modules
> named in the project's own documentation have no implementation.

*(When entering the abstract on arXiv, replace the Markdown backticks around
`ArcSwap` with plain text or `\texttt{}` as appropriate; the metadata field is
plain text, so write `ArcSwap` without markup.)*

## Abstract for the arXiv form (1,920-character limit)

The abstract printed in the paper is longer than the form accepts; paste this
version into the arXiv metadata field instead. It keeps every measured number
and drops only prose.

> MightBe is a single-process system that couples a from-scratch
> neural-network runtime to a relational store through a learned, auditable
> index. We make three contributions. First, we specify a hot-mutation
> protocol for a live network: an alter operation is merged into a candidate
> specification, validated, rebuilt, and re-hydrated with weights migrated by
> (layer, parameter, shape); the candidate must pass a smoke forward pass on a
> zero tensor before publication, and publication is a lock-free atomic swap
> of an ArcSwap-held snapshot, so readers in flight keep the previous version
> and any failure leaves the previous version serving unchanged. Second, we
> give an auditable inference graph in which every answer is a scored path
> with a bounded evidence set, and we specify the confidence algebra exactly:
> a path score is a product of per-step contributions, paths reaching the same
> node combine by noisy-OR, and a verifier reranks the result by geometric
> interpolation with a semantic similarity term. Third, we couple the store to
> the learned index with an idempotent insert trigger that routes text rows
> through normalization, tokenization, TF-IDF, TextRank and pointwise mutual
> information before the association graph is built. We report the artifact's
> own test suite — 32 test targets, 251 tests, all passing, one doc-test
> ignored — and state plainly that the repository contains no benchmarks and
> no accuracy or latency measurements, so we give a measurement protocol
> rather than results. We also disclose that the test suite was generated with
> the assistance of a large language model, and that six modules named in the
> project's documentation have no implementation.

## Files

```
main.tex                       the paper
refs.bib                       bibliography
common.tex                     shared preamble (copied in at packaging time)
figures/fig1_architecture.pdf  the nine crates and their data flows
figures/fig2_hot_mutation.pdf  the hot-mutation pipeline
figures/fig3_reasoning.pdf     the reasoning graph and confidence algebra
figures/fig4_insert_trigger.pdf  the insert-trigger chain
scripts/count_structure.py     counts crates/lines/tests from the source tree
scripts/summarise_test_log.py  parses a `cargo test --workspace` log
scripts/run_tests.sh           runs the workspace suite and tees the log
scripts/make_figures.py        regenerates the four PDF figures
```

## Build

```bash
cd papers/mightbe
cp ../_shared/common.tex common.tex

pdflatex main
bibtex main
pdflatex main
pdflatex main
```

or, with `tectonic` (fetches packages on demand, runs bibtex automatically):

```bash
tectonic -X compile main.tex --keep-logs
```

## Package for arXiv

```bash
bash papers/make_package.sh mightbe
```

This produces `papers/dist/mightbe.tar.gz` containing `main.tex`,
`common.tex`, `refs.bib`, `figures/`, and `scripts/`.

## Submit

1. Go to <https://arxiv.org/abs/cs.LG> and click **Submit new paper**.
2. Upload `papers/dist/mightbe.tar.gz`.
3. Category: `cs.LG` primary; add `cs.AI`, `cs.DB`, `cs.CL` as cross-lists.
4. Copy the abstract above into the metadata form.
5. License: the arXiv perpetual non-exclusive license is fine.
6. **Author identity.** The author block currently reads `yxpil`. arXiv
   requires the listed name to match the account holder; change `\author{}` in
   `main.tex` before packaging if you want the byline to read
   *Daozhendong Yang*.

## Reproducing the numbers

Every number in the paper comes from one of two scripts run against a
checkout of the MightBe workspace:

```bash
# structural counts: crates, source lines, #[test] attributes, Op variants
python papers/mightbe/scripts/count_structure.py --repo <MightBe checkout>

# the test suite and its parsed summary
bash papers/mightbe/scripts/run_tests.sh <MightBe checkout>
python papers/mightbe/scripts/summarise_test_log.py <logfile>

# the four figures
python papers/mightbe/scripts/make_figures.py --out papers/mightbe/figures
```

The paper quotes 32 test targets, 251 passing tests, 0 failures, 1 ignored
doc-test, and a slowest target of `tests/mdb.rs` at 78.39 s. All five numbers
come from the parsed log, not from the README.

## What the paper does not claim

This is the single most important section of this package. The repository's
documentation describes capabilities that the code does not implement. The
paper is written against the code, and it says so. Before submitting, read the
paper's Limitations section and confirm you are comfortable with every item:

- **No benchmarks, no accuracy results, no latency measurements exist.** The
  evaluation section is therefore a *protocol*, not a results section. It
  reports the test suite and specifies what a real evaluation would have to
  measure. Do not let anyone describe this paper as having an experimental
  evaluation of performance.
- **The test suite was generated with LLM assistance**, as the project's own
  testing document states. The paper treats the suite as evidence that the
  artifact builds and that its invariants hold under its own tests — explicitly
  *not* as independent evidence of correctness.
- **Six modules named in the project's documentation have no implementation.**
  They are listed as planned work, never as contributions.
- **The retrieval path is brute-force cosine similarity**, not an approximate
  nearest-neighbour index. If the README says ANN/IVF, the README is wrong and
  the paper follows the code.
- **Plugins are not sandboxed.** The paper states this twice, because an
  unsandboxed plugin is a security boundary that does not exist.
- **The confidence score is not calibrated.** The calibration machinery
  exists, but without labelled data the paper cannot report a calibrated
  score, and it says so rather than reporting a number.
