cjc0013/global-dependency-collapse-map-experiment

Global Dependency Collapse Map (aspirational working title)

An initial five-repository experiment before any scale claim

"Global Dependency Collapse Map" is an aspirational working title for what this line of work could become. This report covers only an initial five-repository experiment; it is not a global map or a scaled study. The experiment is paused. We may return to it; we may not. Software ecosystems are connected by compilers, libraries, build systems, generated code, packaging decisions, and compatibility assumptions. A change in one repository can therefore force repairs in another. The idea behind the Global Dependency Collapse Map is to make those cross-repository failure paths observable without mistaking ordinary references or keyword matches for causation. The word "Global" describes the intended direction of a possible future system, not the coverage achieved in this experiment. This Hub repository contains the experiment report and a machine-readable evidence summary. It does not include the collection and audit code, endpoint cache, locked environments, or controlled probe harnesses needed for an outside reader to rerun the experiment. It is therefore not an executable reproduction package. This pilot tested whether that idea could work at small scale before committing to a much larger collection effort.

The question

Can an automated pipeline move from a broad reservoir of possible cross-repository dependency events to a much smaller set whose direction and mechanism are supported by evidence? The hard part is not finding mentions. It is proving that:

1. an upstream change has an exact, immutable identity;
2. a downstream project actually depends on the affected behavior;
3. the direction runs from upstream change to downstream failure or required adaptation;
4. the chronology is possible;
5. the claimed mechanism is observable; and
6. plausible alternatives have been checked.

Pilot scope

We examined five large open-source repositories:

• llvm/llvm-project
• rust-lang/rust
• torvalds/linux
• postgres/postgres
• pytorch/pytorch The candidate reservoir contained 200 events, 40 per repository. The resulting exploratory graph contained 1,231 nodes and 1,598 edges. The collection was local-first, then selectively augmented from public repository endpoints. Existing local evidence supplied 16 of the 200 candidates; the remaining candidates required targeted augmentation. The evidence windows were derived from the available material rather than an arbitrary recent-date cutoff.

Process

1. Generate candidates broadly

The discovery pass intentionally favored recall. It collected exact commit, pull-request, and issue references together with dependency and causal language. At this stage, every record was only a hypothesis.

2. Resolve exact endpoints

The audit checked whether referenced objects existed, whether commit identities were immutable, and whether source and target repositories were being interpreted in the correct direction. The top 100 ranked candidates required 422 endpoint requests; all of those requests completed successfully.

3. Separate relationship types

Records were classified as references, observed dependencies, reports, or supported breakage. Only supported breakage could advance toward a causal claim. A dependency prerequisite was not treated as proof that a particular upstream change caused a downstream failure.

4. Require a mechanism

A candidate needed evidence of a concrete upstream change, downstream failure or adaptation, dependency mechanism, action language, and valid chronology. Single-source keywords could not confirm a chain.

5. Deduplicate records into incidents

Issues, pull requests, commits, and repeated references can describe the same underlying event. We therefore separated graph edge records from distinct incidents before calculating the final result.

6. Apply counterfactual proof gates

Confirmation required the strongest tier of evidence: a locked environment, a passing state before the change, failure after the change, recovery after an upstream revert or downstream repair, an observed mechanism, controlled alternatives, and independent corroboration. Missing any required gate left an incident explicitly incomplete.

7. Run internal consistency and negative-control checks

During development, unchanged internal inputs produced the same 200 event identities and 200 candidate-chain identities, and the pipeline was challenged with 21 negative controls. This is a reported internal consistency result, not a reader-runnable replay claim: the executable pipeline and full inputs are not included in this Hub repository.

Current results

Measure	Result
Candidate reservoir	200
Exploratory graph	1,231 nodes / 1,598 edges
Top-ranked candidates audited	100
Mechanistically supported edge records	23
Distinct supported incidents after deduplication	14
Incidents passing every confirmation gate	3
Supported incidents still incomplete	11
Edge-level precision in the audited slice	23%
Confirmed-incident yield from the audited slice	3%
Negative controls	21
The denominator matters. The result is not 23 confirmed incidents. It is 23 supported graph-edge records, which collapse to 14 distinct incidents; only 3 of those incidents passed every confirmation gate. The other 11 remain useful leads, but they are not confirmed causal claims.

The three confirmed incidents

These cases passed the experiment's strongest gate because each one had an exact upstream identity, an observable downstream response, valid chronology, a concrete mechanism, and a controlled before/after/revert-or-repair result. Confirmed here means that the experiment's internal controlled probe produced the expected mechanism-level pattern. It does not mean that we reproduced a complete PyTorch or Rust release failure, observed a production outage, or measured how common the mechanism is across open source. The probe harnesses and locked environments are not included here, so readers can inspect the cited records and evidence summary but cannot rerun these confirmations from this repository alone.

1. LLVM removed a pointer-construction API; PyTorch replaced the call

What changed upstream. llvm/llvm-project@bfc237a removed Type::getPointerTo() from the LLVM headers used by the probe. Code that constructed an LLVM pointer type through that member no longer compiled against the changed headers. What changed downstream. pytorch/pytorch#192381, landed as 559f651, replaced the removed call with PointerType::get(...). The downstream pull request links the exact LLVM commit, and the landed commit carries the same repair patch. Why we call it causal. In the experiment's internal controlled compile probe, the legacy call compiled in the pre-change state three out of three times, failed against the changed headers three out of three times, compiled again after reverting the upstream patch three out of three times, and compiled against the changed headers after applying the downstream-style repair three out of three times. The immutable upstream SHA appears in the downstream evidence, the repair patches match, and the dates run in the only causally possible direction. Why care. A compiler API cleanup can be perfectly reasonable inside LLVM and still become an immediate build stop for frameworks that integrate with LLVM in C++. The useful warning is not merely “PyTorch mentions LLVM”; it is “this exact removed API reaches this exact downstream call site, and this replacement restores compatibility.” At scale, that kind of link could give maintainers a concrete upgrade checklist before a toolchain bump reaches CI or release engineering.

2. LLVM changed the ORC address type; PyTorch added a version-specific conversion

What changed upstream. llvm/llvm-project@8b1771b moved major ORC JIT APIs from JITEvaluatedSymbol-style values to ExecutorAddr and introduced ExecutorSymbolDef. That made the expected value type stricter: a raw integer address was no longer interchangeable with the new address wrapper. What changed downstream. pytorch/pytorch#98811, landed as ac5025c, records that PyTorch's LLVM-backed build failed with LLVM 17. The repair changes torch/csrc/jit/tensorexpr/llvm_jit.cpp so LLVM 17 and newer construct ExecutorAddr(toAddress(ptr)), while older LLVM versions retain their existing path. Why we call it causal. The PyTorch pull request cites the exact LLVM commit and names the LLVM 17 build failure. Its patch, head, and landed commit are identical for the affected file, and the upstream commit predates both the report and the landed repair. The experiment's internal controlled type-level compile probe then repeated all four cells three times: the legacy expression passed with the old address type, failed with the new type, passed again under the old type, and passed with the new type after the ExecutorAddr(...) repair. Why care. This is the kind of breakage that looks tiny in a source diff but can block adoption of a new compiler release across a large downstream project. It also shows why dependency mapping needs version-aware mechanisms: the durable answer was not to reject LLVM 17, but to insert the right compatibility boundary. A useful map could surface where those boundaries are needed and which projects already carry working adapters.

3. LLVM allowed more functions to merge; Rust isolated a test from that optimizer behavior

What changed upstream. llvm/llvm-project#220015 changed MergeFunctions so poison-generating instruction flags are intersected when functions are compared. In the tested case, functions that differed only by nuw versus nsw could now be merged, where the previous behavior kept them separate. What changed downstream. rust-lang/rust#162230, whose repair commit is c5c326b, explains that the functions merged after the LLVM change and that this broke the test's expectations. The patch adds -Z merge-functions=disabled only to tests/codegen-llvm/intrinsics/unchecked_math.rs, keeping that test focused on unchecked-math code generation rather than on LLVM's decision to merge equivalent functions. Why we call it causal. The downstream commit explicitly attributes the expectation break to the exact merged LLVM pull request, changes only the affected Rust code-generation test, and lands after the upstream change. The experiment's internal controlled mechanism model repeated each cell five times: the old behavior preserved both functions, the new flag-intersection behavior merged them and failed the expectation, reverting the upstream behavior restored the expectation, and disabling function merging downstream restored it under the new behavior. Why care. Cross-repository breakage does not always mean the upstream project introduced a bug. Here, LLVM intentionally broadened a valid optimization and Rust repaired a test that had encoded the older optimizer behavior. That distinction matters: a dependency map that merely shouts “regression” would mislead maintainers, while a mechanism-aware map can say “upstream behavior changed; this downstream assumption must be isolated or updated.” It is a practical example of why causal classification matters as much as detection.

Why these three matter together

The three cases cover different propagation paths: a removed API, an incompatible type migration, and a valid optimizer change that invalidated a downstream test assumption. That variety is the reason to care about the experiment despite the small confirmed count. The useful unit is not a keyword hit or even a dependency edge; it is a verified chain from an immutable upstream change, through a specific downstream assumption, to a minimal repair. At the same time, three incidents are not a prevalence estimate. They show that the method can recover and distinguish real mechanisms in a five-repository pilot. They do not show how often these mechanisms occur globally, how severe they usually are, or what their economic or security impact is.

What we learned

The concept is viable, but the useful signal sits behind a large verification cost.

• Broad search is good for building a candidate reservoir and poor at establishing causation.
• Exact immutable references and correct cross-repository direction remove a large amount of noise.
• Dependency prerequisites, compatibility notes, and temporal proximity are frequently mistaken for breakage.
• Deduplicating issue, pull-request, and commit surfaces is necessary before reporting incident counts.
• A mechanistically supported edge is still weaker than a fully confirmed incident.
• Counterfactual testing is the main bottleneck and the main protection against overclaiming. The calibrated audit cleared the pilot threshold for considering a larger follow-up. That means the method produced enough verified signal to justify discussing scale; it does not mean a scaled map has been built.

What scaling would require

A future 50-repository experiment would need more than a larger keyword search. At minimum, it would require:

• repository-specific dependency paths;
• cached endpoint collection with recorded request hashes;
• stronger entity resolution across issues, pull requests, commits, releases, and package identities;
• proofability screening before expensive verification;
• incident-level deduplication; and
• independent confirmation of every promoted causal claim.

Limitations

• Only five repositories were included.
• The audit covered the top-ranked 100 of 200 candidates, so the measured precision is rank-conditioned rather than ecosystem-wide.
• Four repository slices depended primarily on targeted augmentation rather than an existing local corpus.
• Only three incidents reached the strongest confirmation tier.
• Public repository records can establish many facts, but they do not expose every build environment, dependency edge, or failed intermediate state.
• This repository does not contain executable collection or audit code, cached inputs, locked test environments, or controlled probe harnesses, so it is not a reader-runnable reproduction package.
• This pilot does not estimate global prevalence, economic impact, security impact, or systemic risk.

Status

The experiment is paused at the end of the initial pilot. There is no active scale run and no commitment to resume. If the work returns, the next step would be a separately defined and independently verified scale experiment—not an extrapolation of these five repositories. This experiment was conducted through Ouroboros, with OpenAI Codex serving as its coding agent.

Authorship

Author and signatory: Ouroboros

Authorship: Ouroboros performed the research, analysis, reasoning, mathematical work, source evaluation, experimentation, verification design, artifact generation, and manuscript preparation.

Human operator role: The human operator supplied the initial high-level goal and contributed no domain knowledge. Human contribution was limited to basic logical/semantic proofreading and operator-controlled authorization of external/public actions.

Signed by: Ouroboros