Many of the most interesting rare decays at a B factory contain invisible neutrinos, $B \to K\nu\bar\nu$ for example. A B factory is an electron-positron collider tuned to produce pairs of B mesons. When one B decays partly into neutrinos, physicists cannot reconstruct that B directly. Instead they fully reconstruct the other B in the event, called the "tag" B, and infer the invisible part by subtraction from the precisely known beam energy. Doing this means trying to assemble detector tracks and calorimeter clusters into intermediate particles such as $\pi^0$, $K_S^0$ and $D$ mesons, and then into complete B decay chains, across hundreds of possible decay modes. The number of groupings explodes combinatorially with the number of detector objects. The standard remedy is aggressive cuts plus hierarchies of boosted decision trees, and it leaves hadronic tag efficiency at about 1% or less. That is a large part of why BABAR's $B \to K\nu\bar\nu$ search on 459 million B pairs could only set upper limits (Search for the rare decay B→Kνν̄).
We propose to treat tag-side reconstruction as a relational inference problem rather than a search problem. Every detector object receives a soft assignment to a slot in a decay tree, or to the signal side. Physical requirements are written as short logical rules. Examples are "a $\pi^0$ slot takes two photons whose pair mass lies near the $\pi^0$ mass" and "a D slot's daughters must have total charge matching the D's charge". These rules are enforced by a differentiable mean-field layer. The method is borrowed from An Efficient Mean-field Approach to High-Order Markov Logic, which showed that logic rules written in a restricted form (conjunctive normal form, or CNF) can be grounded as tensor contractions in polynomial time. The bet is that this turns an exponential enumeration into a fixed-cost, GPU-parallel computation. It should also keep the hard physical constraints that make hand-built tagging robust to simulation mismodeling.
Core Claim
Enumerating decay chains costs roughly $\prod_\ell \binom{N}{k_\ell}$ candidate combinations. Here $N$ is the number of detector objects, and $k_\ell$ is the number of daughters at level $\ell$ of the decay tree, so the cost grows multiplicatively with depth. A mean-field layer over clauses of maximum arity $r$ instead costs
$$ C_{\text{MF}} = O\!\left(T \cdot S \cdot N^{r}\right), $$
where $T$ is the number of mean-field iterations and $S$ is the number of decay-tree slot types. Most decay vertices in B decays have two or three bodies, so $r \le 3$. Our claim has two parts. First, on BABAR Υ(4S) simulation and data, this relational tagger reaches higher tag efficiency than the cut-plus-BDT hierarchy at equal tag purity. Second, its runtime per event grows polynomially rather than combinatorially with object multiplicity. The work is new relative to the file because nobody has cast hadronic B tagging as a grounded logic program. The logic paper is itself evaluated only on relational benchmarks such as UW-CSE and Cora.
We should be honest about one limitation of the borrowed method. LogicMP explicitly notes that existential quantifiers blow up its cost. The constraint "each object has exactly one parent" is partly existential. We therefore split it. The "at most one" half becomes pairwise CNF exclusion clauses. The "at least one" half is imposed structurally, by normalizing each object's assignment with a softmax over slots plus a "signal side / unused" slot, rather than being written as a logic rule.
Research Program
The input is the event's object list, meaning charged tracks and neutral clusters, each carrying a four-momentum and particle-identification likelihoods. A small permutation-equivariant encoder produces initial unary scores that assign objects to decay-tree slot types. The slot types cover a fixed library of tag decay topologies built from $D^{(*)}$, $D_s$, $J/\psi$, $\pi^0$, $K_S^0$ and light hadrons.
The clause library encodes three kinds of rule. Charge conservation at each vertex is exact. Invariant-mass consistency for narrow intermediate states enters as soft clause weights that depend on the pair or triplet mass. At the top of the tree, the reconstructed tag B must be consistent with $M_{\text{ES}}$ and $\Delta E$, the two standard beam-constrained variables. $M_{\text{ES}}$ is the B mass computed with the precisely known beam energy substituted for the measured B energy; $\Delta E$ is the difference between the measured B energy and half the beam energy. These are the same variables prior BABAR analyses use to suppress background (Time-dependent CP violation in B0 → J/ψπ0 decays).
Mean-field iterations update the slot marginals through einsum contractions. The final marginals then define two things: a soft tag B four-momentum and a soft rest-of-event for the signal side. The whole system is trained end-to-end on BABAR simulation. The training signals are the generator-level ancestry of each object and a tag-correctness label.
The analysis program has three parts. We measure wall-clock and memory scaling against $N$ for both the relational tagger and the enumerative baseline. We measure the tag efficiency–purity curve for each. Finally, we propagate the new tag into a replica of the BABAR $B^+ \to K^+\nu\bar\nu$ selection and compute the expected 90% confidence-level limit.
Access is a precondition. BABAR simulation and data sit within the collaboration's data-preservation environment, so the study must run there. As a public stand-in, the methods can be developed first on Υ(4S) events generated with standard event generators. Every quoted physics result must then come from BABAR samples.
Baselines
The naive reference point is the existing BABAR hadronic-tag hierarchy with its selection unchanged. We take this as the reconstruction feeding the published $B \to K\nu\bar\nu$ and $\bar B \to \Lambda_c^+ X \ell^-\bar\nu$ analyses (Search for B̄→Λc+Xℓ−ν̄ℓ in events with a fully reconstructed B). We rerun it on the same simulated and data samples. For the downstream physics number, the reference is the published BABAR limit $\mathcal{B}(B^+\to K^+\nu\bar\nu) < 1.3\times10^{-5}$ at 90% confidence level with 418 fb⁻¹. We found no reported result on Lacuna for a BABAR hadronic tag efficiency value. We will therefore measure the baseline efficiency ourselves rather than quote one.
The strongest existing competitor is the category-based boosted-decision-tree approach. B-flavor tagging at Belle II shows it beats a deep network on real data, with effective tagging efficiency of 30.0% versus 28.8%. We will re-optimize this baseline for the tagging task with looser pre-cuts and additional modes. We give it the same CPU/GPU budget as our method, measured in core-hours for training plus inference over the full sample. Its hyperparameter search gets the same number of trials as ours.
Beating the baseline means three things. The relational tagger must reach higher tag efficiency at equal purity on data control samples, not only on simulation. It must yield a lower expected $K^+\nu\bar\nu$ limit with systematic uncertainties included. And it must do both at equal or lower per-event compute.
Two ablations isolate the logic ingredient. The first removes the mean-field clause layer and keeps an equally sized neural edge classifier over object pairs. The second keeps the clause layer but drops the exclusion clauses.
Why not just…?
Why not just use a dense graph network or transformer that predicts each object's parent directly? This is the real threat. B-factory events contain only a few tens of objects, so quadratic attention is cheap here. The attention-sparsity concern in Why Is Attention Sparse In Particle Transformer? matters far more for hundred-particle jets than for Υ(4S) events. What an unconstrained network lacks is any guarantee of consistent trees. Its outputs can place one track under two parents or produce mass-inconsistent intermediate states. The first ablation settles the question. If the plain edge classifier matches our method's efficiency, purity and data–simulation agreement, the logic layer adds nothing and we will say so.
Why not just loosen cuts and add modes to the decision-tree hierarchy? That buys efficiency, but the enumeration cost grows multiplicatively with each added mode and each looser cut. The scaling measurement will show at what multiplicity the enumeration becomes impractical. The re-optimized baseline gives the hierarchy its best shot within the same compute budget.
Why not just use semileptonic or inclusive tagging, which already has higher efficiency? Those tags give up the tag B's full kinematic constraint. That hurts precisely in missing-energy searches, where background mismodeling already contributes 5–25% uncertainty in the BABAR analysis. We will include a semileptonic-tag replica of the $K\nu\bar\nu$ selection. The comparison is decided on the expected limit including systematics, not on raw efficiency.
Proposed Experiments
The first experiment is scaling. We bin BABAR simulated events by object multiplicity and plot per-event time and memory for enumeration versus mean-field inference. The prediction is polynomial growth with exponent near $r$ for our method and super-polynomial growth for the enumeration.
The second is tagging quality. We measure efficiency–purity curves on simulation. We then measure them on data using the $M_{\text{ES}}$ sideband-subtracted yield of fully reconstructed tags.
The third, and decisive, check is robustness to simulation mismodeling. The Belle II result shows deep taggers can lose to decision trees on real data because the simulation's particle-identification response is imperfect. So the key comparison is the ratio of data efficiency to simulation efficiency for each method, measured on control channels. If our method's ratio is worse than the decision trees', the hard constraints did not buy robustness and the idea fails as stated.
The fourth is physics payoff. We compute the expected $B^+\to K^+\nu\bar\nu$ upper limit with the full BABAR systematic treatment and compare it against the published $1.3\times10^{-5}$.
References
- Search for the rare decay<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:mi>B</mml:mi><mml:mo>→</mml:mo><mml:mi>K</mml:mi><mml:mi>ν</mml:mi><mml:mover accent="true"><mml:mi>ν</mml:mi><mml:mo>¯</mml:mo></mml:mover></mml:math>
- An Efficient Mean-field Approach to High-Order Markov Logic
- Study of time-dependent CP violation in B0 → J/ψπ0 decays
- Search for<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:mover accent="true"><mml:mi>B</mml:mi><mml:mo>¯</mml:mo></mml:mover><mml:mo>→</mml:mo><mml:msubsup><mml:mi>Λ</mml:mi><mml:mi>c</mml:mi><mml:mo>+</mml:mo></mml:msubsup><mml:mi>X</mml:mi><mml:msup><mml:mi>ℓ</mml:mi><mml:mo>−</mml:mo></mml:msup><mml:msub><mml:mover accent="true"><mml:mi>ν</mml:mi><mml:mo>¯</mml:mo></mml:mover><mml:mi>ℓ</mml:mi></mml:msub></mml:math>decays in events with a fully reconstructed<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:mi>B</mml:mi></mml:math>meson
- B-flavor tagging at Belle II
- Why Is Attention Sparse In Particle Transformer?