§ 2 · The algorithm

FBMP, one iteration at a time.

A single SAE latent rarely captures an attribute on its own — concepts get split across multiple specialised units. Fully-Binary Matching Pursuit greedily assembles a small coalition of latents whose logical-OR best reconstructs the binary attribute vector. The trick: every operation stays in the binary domain — selection by F_β, residual update by AND NOT, approximation update by OR.

Step through the toy below. Watch how the residual shrinks and the coalition’s joint approximation grows, then compare against a naïve top-k baseline that just picks the three best individual latents.

β =

{[0.25, 0.5, 1].map((b) => )}

k =

{mode === "fbmp" ? [1, 2].map((k) => ) : [1, 3].map((k) => ) }

{/* LEFT: data view */}

{mode === "fbmp" &&

{/* target */}

Residual r_{curStep}

r ← r ∧ ¬z*

{currentResidual.map((v, i) =>

{v}

)}

{/* candidate latents */} {data.latents.map((l, i) => { const isPicked = trajectory.slice(0, curStep).some((t) => t.picked === i); const isJustPicked = cur && cur.picked === i; const score = fbeta(currentResidual, l.z, beta); return (

{l.label} picked

{l.z.map((v, j) =>

{v}

)}

F_{beta}={score.toFixed(2)}

); })}

{/* coalition approx */}

Approx ŷ_{curStep}

ŷ ← ŷ ∨ z*

{currentApprox.map((v, i) => )}

F1 = {currentF1.toFixed(2)}

} {mode === "topk" &&

Naïve baseline: rank latents by their individual F1 against the target, take the top {naiveK}.

{naiveTopK.map((r, i) =>

#{i + 1} {r.label}

{r.z.map((v, j) =>

{v}

)}

F1={r.score.toFixed(2)}

)}

OR of top-{naiveK}

{naiveApprox.map((v, i) => )}

F1 = {f1Stats(target, naiveApprox).F1.toFixed(2)}

}

true positive false positive false negative

{/* Step info + controls — lives below the data, left of Why β */} {mode === "fbmp" &&

Step {curStep} of {maxStep}

Picked: {cur ? cur.pickedLabel : "—"}

F_{beta} on residual = {cur ? cur.fbetaScore.toFixed(3) : "—"}

Joint F1: {cur ? <>{cur.f1Before.toFixed(2)} → {cur.f1After.toFixed(2)} : "—"}

}

{/* RIGHT: algorithm + explainer */}

Algorithm

{`r₀ ← y          # Initialize residual
ŷ₀ ← 0          # Initialize approximation
S  ← ∅          # Initialize empty subset
for κ = 0 to k−1:
  l* ← argmax_l SIMbin(rκ, zₗ)   # Select most-aligned concept
  rκ₊₁ ← rκ ∧ ¬zₗ*               # Update residual
  ŷκ₊₁ ← ŷκ ∨ zₗ*                # Update approximation
  if F₁(y, ŷκ₊₁) ≤ F₁(y, ŷκ):   # Stopping criterion
    break
  S ← S ∪ {l*}                    # Add to subset
return S`}

Why β ≤ 1?

Lower β favours precision over recall when picking each new atom. Because several latents will be OR’d together, individual recall isn’t crucial — we want each pick to be specific. F_0.5 tends to win across our experiments.

Try it

Click cells in the target row to flip them, then step through again.

{target.map((v, i) => )}

{/* Bottom comparison bar */}

FBMP F_{beta} — final F1 on S ({maxStep} latent{maxStep !== 1 ? "s" : ""})

0 ? "var(--accent)" : "var(--ink-3)" }}> {maxStep > 0 ? finalF1.toFixed(2) : "—"} {maxStep > 0 && {trajectory.map(t => t.pickedLabel).join(" + ")}}

Naïve top-{naiveK} OR baseline

{f1Stats(target, naiveApprox).F1.toFixed(2)} F1 · {naiveTopK.map(r => r.label).join(" + ")}

Fig. 2. Interactive FBMP run on 5 candidate latents. Step through to see how the coalition is assembled — FBMP F_0.5 recovers the target with fewer latents than even the OR of the three best by individual F1. Click cells in the target row (right panel) to explore different attributes.