bac reconstructs Clojure from observed behaviour, in Python, without reading Clojure's implementation source. The deliverable is a paper rather than a language: a rung that stalls counts as a result provided the stall is written down.

Two oracles answer different questions, and keeping them apart is most of the method.

The second is the interesting one. Clojure boots from AOT-compiled classes, so the stripped jar still runs: (doc map) returns a docstring, (source map) returns Source not found. A zip operation enforces the clean-room boundary, which is cheaper and harder to violate than a rule about what you may read.

The kernel is what the Python host must expose before a core.clj analogue can define the remainder. The count is a claim, so admission is adversarial: could this be written in Clojure using only what is already in the kernel? If yes, it stays out.

+ is in and inc is out, because (def inc (fn* [n] (+ n 1))) needs nothing from the host. prn is in because printing is I/O. count and first are in because they read the host's representation of a collection.

Ten special forms complete it: quote if do def let* fn* loop* recur throw try.

There is no macro system, so defn, let, cond, when, and, or and -> do not exist. All seven are macros in Clojure — though let is a trap for this framing, since its var carries :special-form true and clojure.org documents it under Special Forms, even while it expands to the let* special form.

A loop* with no recur binds locals and stands in for let. That holds only under the stated qualifier: with a recur present the two diverge, because loop* steals the recur target and the let* version compiles where the loop* version does not.

The claim under test is that what separates a reconstruction from ordinary list programming is a library, not the bridge to the host. core/prelude.clj defines 34 functions using only the 30 primitives and the 10 special forms, and the kernel did not change while it was written.

;; each name means what clojure.core means by it
(def map
  (fn* [f xs]
    (loop* [in (seq xs) out (list)]
      (if (= in nil)
          (reverse out)
          (recur (next* in) (cons (f (first in)) out))))))

P-99 calls 15 of the 34, directly or transitively. It never reaches the remaining 19 — a fact that turns out to set the ceiling on what mutation can detect.

P-99 is Werner Hett's Ninety-Nine Prolog Problems, written for a Prolog course with no knowledge of this project. That provenance is the whole reason to use it.

An earlier rung built its corpus alongside the implementation. It reported 28 agreements out of 28, then detected 6 of 10 planted defects. One author writing both the implementation and its tests applies the same assumptions twice, and the agreement rate says nothing about either.

The grading is deliberately asymmetric. bac loads the prelude and then the solutions; the oracle loads only the solutions, on top of the real clojure.core. So the oracle grades prelude and solutions together, and a defect in our filter surfaces as a divergence in every solution that calls it. Loading the prelude into both sides would compare the solutions against themselves.

No translation step exists. The same source text runs on both, because the solutions stay inside the subset the two languages share.

39 expressions over 35 solutions, all returning what the sealed jar returns.

(count (combinations 3 (range 1 13)))     220
(prime-factors 315)                       (3 3 5 7)
(prime-factors-mult 315)                  ((3 2) (5 1) (7 1))
(encode-modified [:a :a :a :a :b :c :c])  ((4 :a) :b (2 :c))
(goldbach 28)                             (5 23)
(goldbach-list 9 20)                      ((3 7) (5 7) (3 11) (3 13) (5 13) (3 17))

Three exclusions, each following from the problem rather than from bac. P23–P25 select at random, so two correct implementations disagree on every run and a value oracle reports a divergence where no defect exists. P27 returns groupings whose order the problem leaves unspecified, and the oracle provides no canonical form.

The third exclusion is stated wrongly at source. The writeup gives P54 and above as needing map and set literals, which the reader does not parse. Checked against the problems: P-99 contains no associative or set literal anywhere. P54 onward are binary trees written as Prolog terms t(X,L,R) with nil, or as plain lists (X L R) in the Lisp variant, and the graph section explicitly simulates sets with sorted lists — "the lists are kept sorted, they are really sets, without duplicated elements". A reconstruction needs cons, car, cdr, nil and symbol equality, nothing more. If those sections are genuinely out of reach, the reason is nested tagged structures, not literals.

It was not green when written. Four defects and one priced deviation.

39 of 39 establishes nothing until the corpus is shown capable of failing. Fourteen defects were planted in the prelude, one at a time. The prelude is the right target: a defect in filter reaches thirty problems, one in slice reaches one.

Ten plants produced a failing run, but three of those failed because the mutated prelude did not terminate and the timeout ended it — no values were compared. So the corpus detected 7 of 14, and the honest headline is that number rather than the ten.

The four escapes are not mysterious. They modify inc, last, every? and some, and P-99 calls none of them. They live in the 19 definitions the corpus never reaches. Coverage, not sensitivity, is the binding constraint.

The library hypothesis held. Thirty primitives sufficed to define map, filter, reduce, range, concat, take and drop in the language, and the list and arithmetic sections run on those definitions with no kernel change.

Three limits remain, and the bridge is none of them.

• No map or set literals. {:a 1} is a reader error. Idiomatic Clojure uses maps throughout and P-99's tree and graph sections require them. The largest gap.
• No macro system. Mostly syntactic, and measurable in one place: some calls its predicate twice on a match, because calling it once needs a local binding in the if test position and loop* cannot bind there.
• Non-tail recursion stops at 141 frames, each bac frame costing about seven Python frames against CPython's default limit of 1000 — adjustable with setrecursionlimit, not a hard bound. loop*=/=recur has no such limit; a run of 1,000,000 iterations completed. The JVM figure of roughly 10,000 frames measured as 11,578–12,340 on a default main thread, and it moves with stack size: 8,406 on a 512 KB thread, 172,246 on an 8 MB one. A quantitative difference between hosts, and one that depends on how you ask.

• Type Systems for Software Developers: One Tool, Four Ways — the same question about what a discipline can express, asked of four languages rather than one harness
• Shipping the Model — why a model that cannot disagree with its implementation is uninformative, which is the self-written-corpus problem in another domain
• P-99, Werner Hett