⊑ dupelint Notify me

Proven on CPython: full results

The actual output.

A single full-spectrum pass over CPython 3.12.3. Over-detect, then prove down to certainty. Nothing reaches a verdict without an unconditional proof.

CPython 3.12.3 target 63,186 functions 13,970 classes 1,924 module-level 29,485 block-eligible bodies 6,270 constants & data 1,996 files 1,846 lambdas 3,054 comprehensions 11,267 nested blocks 1,026 import blocks 835 default-arg sets 669 decorator stacks 140 type aliases
0
confirmed · proven, safe to merge automatically
32
proven duplicates · merge by hand
52,216
candidates → review · 2.23%
2,291,078
filtered by rule · a policy filter, not a proof · 97.77%

The net flagged 2,343,326 suspects. 2,291,078 (97.77%) were set aside by named policy filters — boilerplate, test code, idioms — counted, not proven different. Of the rest, 0 are confirmed by proof and safe to merge automatically, 32 are proven duplicates to merge by hand, and 52,216 (2.23%) go to review.

What math can prove, we prove — and only that. For the rest, a sound verdict would take a guess about runtime behavior, so we surface every one for review rather than guess. We never guess.

Engine v1.7.7 on all 63,186 functions of CPython 3.12.3: 0 automatic merges issued, and 32 proven duplicates to merge by hand, each one independently audited.

Why the automatic set is smaller than it was

An earlier build of this engine confirmed 104 automatic merges on this exact corpus. Every false-positive class found since was reproduced by execution and closed, so the current engine confirms an automatic merge only when it can prove the rewrite safe: 0 here. Where the duplicate is proven but the automatic rewrite is not safe, the pair is listed as a proven duplicate to merge by hand (32), with the exact reason. Everything else is a candidate for review — never shipped as a verdict.

Confirmed duplicates (0)

Proven-equivalent — safe to consolidate. Delete the duplicate, reuse the canonical one.

Proven duplicates — merge by hand (32)

Proven to compute the same thing (same code; every name, enclosing value, decorator and class context checked identical). The automatic delete-and-redirect is not safe — the reason is named per pair — so the merge is yours to make by hand.

Candidates (52,216)

Each was detected with full confidence — what sets it apart from the Confirmed set is only that whether the merge is behaviour-preserving cannot be settled by deterministic proof (it turns on a runtime value, a dynamic binding, or the shape of the right refactor). A sound prover never guesses there. So each is classified by precisely why proof stops short and routed to review — never shipped as a verdict.

3_gapped 46,426 4_semantic 3,548 1_exact 1,535 2_renamed 644 5_subsumption 63
Blocked by Count
gapped-not-auto-extractable30,975
gapped-trivial-helper15,389
semantic-execution-agree3,385
block-nested-scope547
duplicate-constant-data313
cross-class258
block-control-flow-escape247
block-binds-live-outputs239
duplicate-code-block166
duplicate-default-arguments77
nested-class72
duplicate-comprehension69
method-dispatch-unprovable58
semantic-assumed-int39
class-name-differs31
module-code-binds-used-names25
frame-name-reflection24
duplicate-lambda23
closure-cell22
frame-relocation22
signature-contract21
same-logic-across-constructs20
stie-frame-timing17
shared-data-block17

Full per-pair detail — exact locations plus the binding that blocks a mechanical merge — comes back in the scan result from the API. All advisory; none is ever shipped as a verdict.