CodeEraser™

t = window + kgram - 1 = 26 + 25 - 1 = 50 tokens

Any common run of at least t normalized tokens yields at least one shared fingerprint: the Schleimer et al. SIGMOD'03 no-miss bound, held as a correctness contract.

TSED(a, b) = (max(n1, n2) - ted(a, b)) / max(n1, n2)
cloneDecidesWith (num, den) t n1 n2 = (mx - t) * den >= num * mx  where mx = max n1 n2

Zhang-Shasha edit distance is always integral, so a near-miss clone at TSED ≥ 0.85 is decided by exact cross-multiplication.

dupDecidesWith num den inter union  =  inter * den >= num * union

Two documentation blocks are duplicates at Jaccard ≥ 0.80 over five-word shingles, or on a verbatim run of 50 words; MinHash/LSH only proposes the pairs.

tsallis2Norm cs = tsallis2 cs / (1 - 1/n)  -- n = nonzero bins, n > 1
chi2 pairs      = Σ_{r > 0} (p - q)^2 / q  -- p = o/Σo, q = r/Σr

Directory diversity and layout divergence in exact rationals: the log-free members of the entropy and KL families, so every boundary is decidable.

rho = q / qMax = (e*m − o*i) / (mu*(m − mu))

Each directory's modularity contribution as a share of the most it could earn: 1000‰ when it never reaches out, 0 at the null model's expectation.

score   = max 0 (scoreScale - raw `div` (violCostNeutral * wTotal))
tolerated(c) = max (c * tolNum `div` tolDen) (c + tolAbs)
added   = current \ baseline        -- non-empty => fail

The axes fold into one 0–1000 score under a convex size penalty; each file's ceiling only shrinks, and growth past max(+2 %, +10) fails the gate.

+1 for each method in a recursion cycle, whether direct or indirect

SonarSource's cognitive complexity with the recursion increment of S3776 Appendix B1, which SonarSource's own analysers leave out: the core finds the call cycles and every member pays once.

reach = ⋃ { reachable(G, s) | s ∈ entries(entryMask, flags) }
judged     = i ∉ reach

A file nothing live reaches is dead; cycles are found once, by Tarjan's strongly connected components, and reported, never judged.

benefitMilli(u) = max 0 (floor (1000 * (p(total) - p(end_u) - p(total - end_u))))
viable          ⇔ b >= c            -- ROI >= 1, evaluated without division

The penalty curve is convex with p(0) = 0, hence superadditive: a seam's benefit is never negative, and it is priced against what the cut costs.

slope = median{ (y_j - y_i) / (x_j - x_i) : x_i ≠ x_j }   -- Theil-Sen

The trend is the median of pairwise slopes: one wild commit cannot move it past its neighbours.

score  = Σ w · idf · 22·tf·avg / (10·tf·avg + 3·avg + 9·len)   (k1 = 6/5, b = 3/4; integer fixed point)
PPMI(a, b) = max(0, log2(n_ab · N / (n_a · n_b)))

Integer BM25 with k1 = 6/5 and b = 3/4 ranks the units most like one unit; in-repository PPMI may widen a query, as advice only.

dead(F) :- file(F), not reach(F).
strata : a head sits above every negated or aggregated body predicate; a negative edge inside an SCC is a program error
eval   : semi-naive per stratum over lazy bitmask indexes; the first derivation of a tuple is its provenance

Datalog evaluated semi-naively, one stratum at a time, over the index's own facts; every answer carries the derivation that produced it.

kind 0 : unreachable  = no path from the entry, one finding per maximal run of seqs
kind 1 : dead_store   = a write no path reads before the next write or the exit (backward liveness)

Reachability over each function's control-flow graph, and backward liveness over its variables.

align  : T1/T2 isomorphic, holes = differing leaves; T3 the tree-edit mapping narrowed top-down, relabels and unequal gaps are holes
params : one per distinct value vector; feasible iff every hole is an expression or a name, params ≤ 6 and savings > 0

Where the members of a clone group differ becomes a hole, and each distinct value vector a parameter: at most six, and only when a line is saved.

cuts   : per SCC, a subset programme when it has ≤ 14 directories (exact 1), else Eades–Lin–Smyth + redundancy pass (exact 0)
layers : level(d) = 0 when nothing leaves d, else 1 + max level of what d points at, the cut arcs removed
metrics: fanIn, fanOut, instability = ⌊1000 · out ÷ (in + out)⌋, −1 when nothing touches the directory

Directories ordered into layers once the cheapest arcs are cut out of their cycles, with each directory's instability in integer per-mille.