Code and data for J. Jewitt, H. Li, G. K. Rajbahadur, B. Adams and A. E. Hassan (Queen's University), "Don't Trust the Label: License Laundering in AI Supply Chains," under review at IEEE Software. A link to the paper will be added on acceptance.
This is the replication package that the paper cites in AI Supply Chain Composition. It replaces
the July 2026 contents of this repository, which went with the submitted version; What changed in
the revision at the end lists the differences. Every number the paper prints is traced to a file
and line here, or to its cited source, in PAPER_NUMBERS.md. Figure 1 of the paper
is figure1.pdf.
analysis/ regenerates the chain results and Figure 1 from data.zip. revision/ regenerates the
factor tests from the saved Hugging Face and GitHub pulls, and the validity checks from data.zip. coding/ holds
the codebook and the record of the coding study behind License Categorization.
| Paper section | Code | Numbers and records |
|---|---|---|
| Abstract and opening paragraphs | analysis/named_examples.py (MiniLM, entry 69) |
PAPER_NUMBERS.md |
| AI Supply Chain Composition: Supply Chain Construction | analysis/prune_data.py (the two filters); the collection is the prior audit's code (Supply Chain Construction: how the chains were collected, below) |
data.zip; results.json entries 1 to 10 and 5a to 8b; the chain counts (160,369 and 103,821): logs/report_paper_numbers.out; the 615 and 597 strings: coding/strings/string_chain_2026-10-16.md |
| AI Supply Chain Composition: License Categorization | analysis/category_distribution.py (entries 11 to 19); coding/ (start at coding/README.md) |
the codebook: coding/codebook/codebook.md; the category mapping: data/matrix_v2.json, with the final labels in data/matrix_v2_provenance.csv; the agreement: coding/strings/string_chain_2026-10-16.md and coding/scoring/study_score.md; the plan fixed before the runs: coding/preregistration/analysis_plan.md |
| Unknown Laundering; Figure 1 (A) to (D) | analysis/rq1_false_clarity.py (entries 20 to 44), analysis/figure_data_dump.py, revision/concentration/concentration_units.py |
figure_data.md; 88.4%, 83.0% and 22.2%: logs/report_paper_numbers.out; ImageNet-1K: entry 41 |
| Category Laundering; Figure 1 (E) to (H) | analysis/rq2_selective_laundering.py (entries 45 to 66; StarCoder: entry 65), analysis/e2e_category_survival.py (entries 67 and 68), analysis/rq2_break_pairs_experiment.py (the matrices of E to G), analysis/category_laundering.py (entries 72 to 74, panel H) |
figure_data.md (E to G); revision/laundered_chains/ (panel H and the laundered shares) |
| Figure 1 | analysis/figure1.py |
figure1.pdf; every number it prints, panel by panel: figure1_data.json |
| Factors Associated with Laundering | revision/factors_unknown_status/ (what an Unknown dataset depends on); revision/factors_lacking_categories/ (what a downstream artifact that lacks a category depends on; factor_tests_2026-11-09.md tests all sixteen factors) |
revision/README.md, Where each claim comes from |
| Threats to Validity: Internal Validity | revision/scancode_check/ |
scancode_agreement_2026-10-15.md |
| Threats to Validity: Construct Validity | coding/development/dev_passes_on_565.py, coding/adjudication/, coding/sensitivity/ |
the two development passes: dev_passes_on_565.md; the 36 headline rates: coding/sensitivity/sensitivity_rates_2026-10-20.csv |
| Threats to Validity: External Validity | revision/factors_unknown_status/coverage.py |
the download quarters: coverage_2026-10-15.md |
| Implications | 102,522: logs/report_paper_numbers.out; its other numbers repeat earlier sections; PAPER_NUMBERS.md |
The paper points to this package in five places:
- AI Supply Chain Composition, for the collection details and the codebook:
Supply Chain Construction: how the chains were collected below, and
coding/codebook/codebook.md. - License Categorization, for the agreement computation fixed before the five runs (95.8%,
α 0.939):
coding/preregistration/analysis_plan.mdandcoding/scoring/study_score.md. - Factors Associated with Laundering, for all statistical tests:
revision/README.md. - Threats to Validity, Construct Validity, for how the coder resolved the disagreements:
coding/README.md, How the coder resolved the disagreements, andcoding/adjudication/; and for the 36 headline rates:coding/sensitivity/sensitivity_rates_2026-10-20.csv. - Implications, where the paper says our data and code can be adapted:
data.zipandanalysis/. The crawl and the ScanCode run are the prior audit's code.
unzip data.zip # creates data/ (~214 MB unpacked)
pip install -r requirements.txt
cd analysis
python3 prune_data.py # Supply Chain Construction: the two filters -> data/filtered_chains_clean.jsonl
python3 category_distribution.py # License Categorization: categories per string (entries 11 to 19)
python3 rq1_false_clarity.py # Unknown Laundering (entries 20 to 44)
python3 rq2_selective_laundering.py # the submitted version's category measures (entries 45 to 66); the paper cites entry 65
python3 e2e_category_survival.py # end-to-end survival, panel (G) (entries 67 and 68)
python3 named_examples.py # MiniLM, in the opening paragraphs (entry 69; 70 and 71 are not in the paper)
python3 figure_data_dump.py # -> ../figure_data.md
python3 rq2_break_pairs_experiment.py # checks the category matrices of panels (E) to (G); writes nothing
python3 category_laundering.py # Category Laundering as the paper defines it, panel (H) (entries 72 to 74)
python3 figure1.py # -> ../figure1.pdf (Figure 1 of the paper) and ../figure1_data.json
python3 report_paper_numbers.py # prints the first four tables under "Pipeline output"Run them in that order. The six analysis scripts and category_laundering.py write into
results.json; figure_data_dump.py and figure1.py read it. prune_data.py must run first: it
produces data/filtered_chains_clean.jsonl, which every other script reads, and it clears the
sections it writes, so the later scripts must be run again after it. category_laundering.py must
run before figure1.py, which checks its numbers against entries 72 and 73.
Runtime is about a minute end to end on an Apple M3; figure_data_dump.py and
report_paper_numbers.py take the longest.
figure1.py needs matplotlib 3.10 or later.
The factor tests and the string counts have their own steps: see revision/README.md and
coding/README.md.
LicenseLaundering/
├── LICENSE # Apache-2.0 (code)
├── LICENSE-DATA # CC BY 4.0 legal code (data)
├── LICENSE-THIRD-PARTY.md # what CC BY 4.0 covers here, third-party credits, how to cite
├── PAPER_NUMBERS.md # every number in the paper, with its file and line, or its cited source
├── data.zip # raw scope + license-category mapping; unzip in place
├── requirements.txt
├── analysis/
│ ├── prune_data.py # Supply Chain Construction: scoping and filtering
│ ├── category_distribution.py # License Categorization: license strings -> categories
│ ├── rq1_false_clarity.py # Unknown Laundering
│ ├── rq2_selective_laundering.py # the submitted version's category measures; the any-category-change count
│ ├── e2e_category_survival.py # end-to-end survival matrices
│ ├── named_examples.py # named examples
│ ├── figure_data_dump.py # writes figure_data.md, the numbers behind Figure 1
│ ├── rq2_break_pairs_experiment.py # category matrices of panels (E) to (G) and their checks
│ ├── category_laundering.py # Category Laundering as the paper defines it (entries 72 to 74)
│ ├── figure1.py # draws Figure 1 of the paper
│ ├── report_paper_numbers.py # prints the first four tables under "Pipeline output"
│ └── results_manager.py # shared results.json helper
├── results.json # values the paper cites (generated)
├── figure_data.md # the numbers behind Figure 1 as text (generated)
├── figure1.pdf # Figure 1 of the paper (generated)
├── figure1_data.json # every number Figure 1 prints, panel by panel, with its source (generated)
├── logs/report_paper_numbers.out # saved output of report_paper_numbers.py, cited by PAPER_NUMBERS.md
├── coding/ # License Categorization: the codebook and the coding study
└── revision/ # Factors Associated with Laundering and Threats to Validity
├── factors_unknown_status/ # what an Unknown dataset depends on; the download quarters
├── factors_lacking_categories/ # what a downstream artifact that lacks a category depends on; the sixteen tests
├── laundered_chains/ # Category Laundering per chain and per transition; panel (H)
├── scancode_check/ # Internal Validity: ScanCode license text against metadata
└── concentration/ # what the three top-10% figures of panel (D) count
results.json and figure_data.md are committed so the numbers can be checked without
unpacking the data or running anything.
The collection is the one of our prior audit (Jewitt et al., "Permissive-Washing in the Open AI
Supply Chain: A Large-Scale Audit of License Integrity", KDD '26, doi 10.1145/3770855.3818130,
arXiv:2602.08816; package at
https://github.com/SAILResearch/permissive-washing-in-the-open-ai-supply-chain).
data/filtered_complete_chains_cleaned.jsonl is its output. The steps, with its counts:
- Models. All model metadata from Hugging Face: 1,922,385 models as of August 8, 2025.
- Model lineage. Models with at least one like (148,729), plus their ancestors through
base_model, whatever their likes: 152,246 models. - Dataset lineage. A model has dataset lineage if its
datasetsfield lists a training dataset, or any ancestor's does. Incomplete dataset identifiers were resolved on Hugging Face (10,193 of 12,514 references): 39,942 models linked to 10,193 datasets. - Applications. The GitHub Code Search API, querying each model's full identifier and bisecting on file size to stay under the 1,000-result cap, then filtered to Python files: 721,816 files in 194,682 repositories. Each file was parsed into an abstract syntax tree and matched against 8,968 model-loading signatures: 167,959 applications with actual model use, 66,819 of them with at least one star. Models and datasets with no downstream application were then removed.
- Licenses. Dataset and model licenses come from Hugging Face metadata. Application licenses come from ScanCode Toolkit, run on the license, notice, copyright and README files of each repository.
Result: 294,012 chains over 3,198 datasets, 6,218 models and 26,302 applications, counted over each application's models and their ancestors. This paper then applies two filters (see Data).
PAPER_NUMBERS.md lists every number the paper prints, with its file and line. The tables below
are the pipeline's own summary. The first four are generated by
python3 analysis/report_paper_numbers.py --markdown against a clean unpack of data.zip; the fifth
comes from category_laundering.py. Rows marked (E), (F), (G) are cells of those panels of Figure 1.
Two different shares are 35.6%. "Applications ending Unknown" is 57,121 of the 160,369 chains with
an Unknown artifact; the paper's laundered share is 36,934 of the 103,821 fully-Known chains (last
table). The first "Known models → Unknown applications" row is also on the 160,369 chains, and so
is the first part of figure_data.md, so its Known totals (44,331; 132,352) differ from those of
panels (A) to (C) (148,152; 236,173).
The 12 license strings coded Exclude are spellings of the nine identifiers coded Exclude, with and
without their LicenseRef-scancode- prefix. The paper's 615 "distinct license strings after merging
spelling variants and splitting multi-license strings" are such identifiers
(coding/strings/string_chain_2026-10-16.md).
Scope (prune_data.py, category_distribution.py)
| Quantity | Value |
|---|---|
| Datasets in analysis scope | 3,198 |
| Models in analysis scope | 5,771 |
| Applications in analysis scope | 26,260 |
| Chains before license filtering | 264,431 |
| Chains excluded (a license string coded Exclude) | 241 |
| License strings coded Exclude (spellings of the nine identifiers) | 12 |
| Chains analysed | 264,190 |
Unknown laundering (Figure 1, panels A to D)
| Quantity | Value |
|---|---|
| Total D→M→A chains analysed | 264,190 |
| Chains through ≥1 Unknown artifact | 160,369 (60.7%) |
| Fully-Known chains | 103,821 (39.3%) |
| Unknown datasets → Known models | 102,522 of 116,038 (88.4%) |
| Unknown models → Known applications | 23,246 of 28,017 (83.0%) |
| Known models → Unknown applications (chains through an Unknown artifact) | 52,350 of 132,352 (39.6%) |
| Known models → Unknown applications (all chains) | 52,350 of 236,173 (22.2%) |
| Applications ending Unknown | 57,121 (35.6%) |
| Top 10% of Unknown datasets, dataset→model | 90.1% |
| Top 10% of Unknown models, model→application | 78.7% |
| Top 10% of Unknown datasets, end-to-end | 85.2% |
Category transitions (Figure 1, panels E to G) and any category change (entries 61 and 62)
| Quantity | Value |
|---|---|
| Dataset→Model retention (transition-level) | 72,019 of 106,649 (67.5%) |
| Model→Application retention (transition-level) | 90,507 of 103,835 (87.2%) |
| End-to-end Dataset→Application retention (transition-level) | 75,324 of 106,649 (70.6%) |
| Copyleft→Permissive (E) | 351 of 410 (85.6%) |
| ML License retained (E) | 185 of 357 (51.8%) |
| ML License→Permissive (F) | 2,111 of 3,773 (56.0%) |
| ML License retained (F) | 784 of 3,773 (20.8%) |
| Permissive end-to-end (G) | 71,634 of 75,087 (95.4%) |
| Sharealike end-to-end (G) | 2,256 of 19,584 (11.5%) |
| Fully-Known chains dropping ≥1 category | 40,068 of 103,821 (38.6%) |
| preserve all categories | 63,753 (61.4%) |
| drop at dataset→model only | 26,741 (25.8%) |
| drop at model→application only | 5,639 (5.4%) |
| drop at both hops | 7,688 (7.4%) |
Named examples (named_examples.py)
| Quantity | Value |
|---|---|
| MiniLM applications | 1,758 |
| MiniLM declared training datasets | 21, 9 with no licence, 3 Sharealike |
| wukong100m downstream models | 91, 0 carry Use-Restricted forward |
| Wikipedia chains | 5,851, 565 preserve both (9.7%) |
Category laundering as the paper defines it (category_laundering.py; results.json 72 to 74)
The laundering numbers of panels (E) to (H) use this definition, described in the next section.
category_laundering.py prints these values and stores them in results.json. The "dropping ≥1
category" rows above are the submitted version's any-category-change count, which equals laundered
plus Public Domain replaced only.
| Quantity | Value |
|---|---|
| Fully-Known chains | 103,821 |
| retained (no category lost) | 63,753 (61.4%) |
| laundered (a category other than Public Domain lost) | 36,934 (35.6%) |
| at dataset→model only | 23,614 |
| at model→application only | 5,941 |
| at both hops | 7,379 |
| Public Domain replaced only | 3,134 (3.0%) |
| Dataset→Model transitions: retained / laundered / Public Domain replaced | 72,019 (67.5%) / 31,194 (29.2%) / 3,436 (3.2%) of 106,649 |
| Model→Application transitions: retained / laundered / Public Domain replaced | 90,507 (87.2%) / 13,321 (12.8%) / 7 (0.0%) of 103,835 |
| End-to-end transitions: retained / laundered / Public Domain replaced | 75,324 (70.6%) / 28,111 (26.4%) / 3,214 (3.0%) of 106,649 |
An artifact is Known when it carries at least one license category other than Unknown, and Unknown otherwise.
Unknown laundering — an artifact is reused and the upstream artifact, the downstream one, or both have no declared license. It has three subtypes: Unknown→Known, Known→Unknown and Unknown→Unknown. Known→Known is not Unknown laundering. Every chain with an Unknown artifact contains it: 160,369 of the 264,190 chains. Panels (A) to (C) count all 264,190 chains.
Category laundering — measured over the 103,821 fully-Known chains, where all three artifacts
are Known. A category transition is retained when the upstream category is present in the
downstream artifact's category set. It is laundered when an upstream category other than Public
Domain is absent from that set. Public Domain replaced by anything is not laundering, and is
reported separately. A chain is laundered if any category lost at either hop is not Public Domain.
rq2_selective_laundering.py (entries 61 and 62) keeps the any-category-change count of the
submitted version; category_laundering.py (entries 72 to 74) applies the paper's definition and
checks that the two decompose exactly.
Two denominators appear in the results and are easy to conflate:
- Chains — one dataset→model→application path. 264,190 in scope.
- Category transitions — one per category per chain. Artifacts can carry several categories, and each is tracked independently, so the 103,821 fully-Known chains yield 106,649 dataset→model and 103,835 model→application category transitions.
The diagonals of panels (E) to (G) count transitions; panel (H) counts chains.
Off-diagonal cells (panels E to G). These are scaled, not direct counts. A lost transition adds one pair per category the downstream artifact carries (entry 68), and each row's pairs are scaled to the row's lost transitions by largest remainder. So a cell shows how the row's lost transitions split across the categories found downstream. Panel (E) has no lost transition at a multi-category model, so its cells, including the 85.6%, are counts. Panels (F) and (G) have such transitions. Of the 3,773 ML License transitions in panel (F), 784 are retained and 2,989 lost. 2,828 lose ML License at an application that declares Permissive (75.0% of the 3,773), 2,205 at one that declares only Permissive (58.4%), and the cell is 2,111 (56.0%).
Concentration (panel D). The three figures count different units. 90.1% (dataset→model) and 78.7%
(model→application) count Unknown→Known chains per Unknown artifact. 85.2% (end-to-end) counts
distinct Known applications per Unknown dataset (1,134 datasets, 52,446 dataset-application
pairs), as in the package of the submitted version. Counted in chains, like the other two,
end-to-end is 90.3%.
revision/concentration/concentration_units.py computes all four.
Names in the code and the records. The scripts, results.json and the dated reports keep some
earlier names.
| In the code or the records | In the paper |
|---|---|
false clarity, laundering (figure key) |
Unknown→Known |
Unknown laundering at dataset→model (reports in revision/factors_unknown_status/) |
Unknown→Known at dataset→model |
clarity erosion, inverse (figure key) |
Known→Unknown |
neutral (figure key) |
Unknown→Unknown |
retained (panels A to C figure key) |
Known→Known; in panels (E) to (G), retained means a category kept downstream |
| definitive | Known |
| obligation-bearing | Copyleft, Sharealike, ML License, Use-Restricted |
narrowed (the laundering definition), E_narrowed_laundering (section of results.json) |
category laundering as the paper defines it |
| any category change, dropping ≥1 category (entries 61 and 62) | the submitted version's measure: a chain loses any category, Public Domain included |
B_false_clarity (section of results.json, entries 20 to 44) |
Unknown Laundering |
C_selective_laundering (section of results.json, entries 45 to 68) |
the submitted version's category measures; the paper cites entry 65 and entries 67 and 68, and its laundering rates come from entries 72 to 74 |
"the paper's" 43.1%, 67.2%, 85.7% and 38.1%, "paper definition" (descriptions of results.json entries 32, 54, 55, 61 and 62, and some script comments) |
figures and definitions of the submitted version, not of the revised paper |
RQ1, RQ2 (in file names such as rq1_false_clarity.py, in figure1.py and in printed headings) |
Unknown Laundering (Figure 1, A to D), Category Laundering (E to H) |
uploader, namespace (revision/factors_unknown_status/) |
publisher |
Q1 lowest to Q4 highest (coverage_2026-10-15.md) |
download quarters |
| v2 | this version's data and labels |
| "Figure 2", "Figure 1(B)" (reports and scripts of 2026-10) | panels (E) to (H), and panel (D), of Figure 1 |
The paper's License Categorization subsection and the Construct Validity paragraph of Threats to
Validity rest on coding/: the codebook, the model runs, the agreement computation fixed before the runs, how the first author resolved the disagreements, the
two development passes, and the coder-sensitivity re-run with its list of 36 headline rates. Start
at coding/README.md. The package holds the final records of the coding; development records and
earlier versions are available from the authors on request.
The paper uses eight categories, assigned by the codebook in coding/codebook/codebook.md.
| In the paper | In the code | Examples |
|---|---|---|
| Permissive | PERMISSIVE |
MIT, Apache-2.0, BSD-3-Clause |
| Copyleft | COPYLEFT |
GPL, AGPL |
| Sharealike | SHARE_ALIKE |
CC BY-SA, LGPL, MPL |
| ML License | ML_LICENSE |
OpenRAIL, Llama Community License, Gemma terms |
| Use-Restricted | USE_RESTRICTED |
CC BY-NC, CC BY-ND, PolyForm Noncommercial, Hippocratic, Business Source License (sub-tags a, b, c, nc in the codebook) |
| Public Domain | PUBLIC_DOMAIN |
CC0, Unlicense |
| Unknown | UNKNOWN |
a missing or empty field, or a placeholder such as "other" or "unknown" |
| Exclude | none | a declared license whose grant depends on payment, an order, a subscription or a separate agreement (nine strings, for example databricks-db, gitlab-ee, nvidia-nccl-sla-2016) |
Exclude has no matrix entry: an artifact carrying such a string leaves the analysed set, which is
the second filter (241 chains; the 12 distinct strings are the nine with and without their
LicenseRef-scancode- prefix).
data.zip unpacks to data/ (~214 MB):
filtered_complete_chains_cleaned.jsonl— the collection described above: one JSON object per artifact, not per chain (35,718 rows). All haveid,type,licenses,likesandscancode; 24,412 also havecopyrightsandholders; models adddatasetsandbase_models, applications addmodels.prune_data.pyexpands these links into chains. Unchanged from the submitted version (MD5f756a2796f954893523c04855337cb47).matrix_v2.json— the license-string → category mapping of License Categorization: 632 entries, each a name, its aliases and a category. 600 entries are the coded strings (609 coded, minus the nine labelled Exclude); 32 are entries of the submitted mapping that were not among the coded strings, kept so that the lookup covers the same keys as before. Aliases come from the submitted mapping.matrix_v2_provenance.csv— one row per coded string (609):unit_id,string,final_label,final_sub_tag,matrix_category,label_source(frozenfor the 581 labels unchanged since the coding freeze of 2026-10-14;adjudicated (author),adjudicated (model)oradjudicated (third)for the 28 disagreements ruled on afterwards).
prune_data.py writes a further file, data/filtered_chains_clean.jsonl, which every analysis
script reads. It is generated, not shipped.
Two filters scope the chains. The first keeps only the chains in which the application invokes the model directly: it removes candidate chains whose model is a base model of the model the application invokes, and with them the models that serve only as base models, so every chain has exactly two hops (264,431 chains). The second removes chains with a string labelled Exclude (241 chains), leaving 264,190.
License fields are split into their SPDX parts and each part is looked up on its own; a
LicenseRef-scancode- prefix is stripped per part (the submitted version stripped it only at the
start of the whole field, which left 175 applications unrecognized, 173 of them carrying Llama or
RAIL terms inside compound strings).
The 14 skipped strings. The pipeline skips the 14 strings of NON_LICENSE_STRINGS that occur in
the data, as in the submitted version. Nine are exceptions, a contributor agreement or a disclaimer. Five are
licenses in LicenseDB: apafml, libpng-1.6.35, protobuf, secret-labs-2011 (Permissive) and
issl-2018 (Free Restricted). All five occur only on applications. The four Permissive strings
add no category to any artifact. issl-2018 would add Use-Restricted to 8 applications, which
touch 50 of the 103,821 fully-Known chains; in none of the 50 does the dataset or model carry
Use-Restricted, so no survival rate or laundered count changes. warranty-disclaimer stands alone
on four artifacts and is Unknown under the codebook as well.
- The pipeline is deterministic: repeated runs give the same values and the same figure. Compare
results.jsonas parsed JSON, since key order inside some entries varies, and PDFs by rendering, since they carry timestamps. results.jsonis keyed by entry number, asPAPER_NUMBERS.mdcites it: entries 1 to 19 scope and distributions (with 5a, 6a, 7a, 8a and 8b for the analysis-scope counts and the exclusion step), 20 to 44 Unknown laundering, 45 to 66 category laundering, 67 and 68 end-to-end survival, 69 to 71 named examples, 72 to 74 category laundering as the paper defines it, plusdm_quadrantsandma_quadrants. The scripts' printed output names entry 69 "Q69". Each entry carries adescription. Entries 61 and 62 keep the any-category-change definition of the submitted version; entry 72 records the identity that links the two.- The scripts self-check before they write or print:
rq2_break_pairs_experiment.py175 assertions,category_laundering.py49, andfigure1.py50 on panels (A) to (D) and 183 on panels (E) to (H). Each fails rather than emit output that disagrees with its own data. - Two estimators of "top 10% concentration" appear in the code. The figure interpolates the Lorenz
curve at exactly 10% (90.1% for dataset→model, 78.7% for model→application); entries 39 and 40 in
results.jsontake the topfloor(10%)artifacts, which lands 0.1 points lower (90.0% from 107 of 1,075 datasets; 78.6% from 81 of 817 models). The paper quotes the figure's. e2e_category_survival.pyprints some shares rounded twice: Use-Restricted end-to-end is 13.8% in its output (13.75 stored, then rounded), while Figure 1 (G) andfigure_data.mdround once from the counts (1,068 of 7,769, 13.7%).- The full run was checked on Python 3.12.9, numpy 2.2.3, matplotlib 3.10.1, pandas 2.2.3 and scipy 1.18.1.
revision/ holds the statistical tests behind Factors Associated with Laundering, the chain tables
behind panel (H) of Category Laundering, and the checks behind Threats to Validity:
factors_unknown_status/: what an Unknown dataset depends on (publisher, popularity, age and the other dataset factors), and the download quarters of External Validity;factors_lacking_categories/: what a downstream artifact that lacks a category depends on, with a test of each of the sixteen factors examined in the revision (added 2026-11-09);laundered_chains/: laundered chains and transitions, panel (H);scancode_check/: ScanCode license text against license metadata, Internal Validity;concentration/: what the three top-10% figures of panel (D) count.
See revision/README.md.
| What | License |
|---|---|
Code: analysis/, and the scripts in coding/ and revision/ |
Apache License 2.0 — see LICENSE |
Data: data.zip, results.json, figure_data.md, the *_data.json files, and the tables, labels, model outputs and pulls in coding/ and revision/ |
CC BY 4.0 — see LICENSE-DATA |
| What CC BY 4.0 covers and does not cover here, the credit for ScanCode LicenseDB, the quoted license passages, our copyright and how to cite | Notes, not a license — see LICENSE-THIRD-PARTY.md |
| Figures | Outputs of the Apache-2.0 code, regenerable from it |
The dataset records metadata about third-party Hugging Face and GitHub artifacts. It contains no source code, weights, or dataset content from those artifacts, and the CC BY grant covers our collection and curation rather than the underlying facts. See LICENSE-THIRD-PARTY.md.
CC BY does not cover the passages of third-party license texts quoted in the model outputs, the MIT
License in coding/prompts/example_request_U082.json, or the LicenseDB keys, names, categories and
SPDX identifiers in coding/. The LicenseDB keys, names, categories and SPDX identifiers come from
ScanCode LicenseDB (https://scancode-licensedb.aboutcode.org/), snapshot of 2026-10-12, Copyright
(c) nexB Inc. and others, licensed under CC BY 4.0, and are shipped unchanged: each equals its entry
in that snapshot.
The license texts the model coded are linked from coding/inputs/license_text_links.csv, not
shipped; coding/inputs/fetch_texts.py downloads them.
- Every license string observed on the collected artifacts was coded under a written codebook
(
coding/), except 12 of the 14 strings the pipeline skips. The submitted version mapped 189 entries and excluded the chains carrying any other string (32,161 chains, 12.2%). The revised run excludes 241 chains (0.09%), those carrying one of the nine strings labelled Exclude. - The category
CC_RESTRICTIVE(Creative Commons NC and ND variants) is replaced byUSE_RESTRICTED, which also covers field-of-use, named-use and single-commercial-mode restrictions, so the published and the revised figures for this category are not the same quantity. - Unknown laundering now covers three subtypes. Category laundering excludes Public Domain replaced.
- The paper's two figures are now one, Figure 1:
figure1.pdf, drawn byfigure1.py. The two figures of the submitted version,figure_1.pdfandfigure_2.pdf, are removed, and so is the code that drew them:sankey_rq1.pyis removed.figure1.pyandreport_paper_numbers.pynow hold their own copies of its three helpers, which read the chain file and test for Unknown (load_clean_data,get_categories,is_unknown), asfigure_data_dump.py,rq1_false_clarity.py,rq2_selective_laundering.pyandnamed_examples.pyalready do; so doesrevision/concentration/concentration_units.py.- The drawing code of
rq2_break_pairs_experiment.pyis removed. The script keeps the code that builds and checks the category matrices, whichfigure1.py,figure_data_dump.pyandreport_paper_numbers.pyimport, and the check of entries 61 and 62.
figure_data_dump.pyandreport_paper_numbers.pyname the panels of the new Figure 1 in their headings, and test each artifact for Unknown directly instead of first picking one of its categories at random (seed 42); no artifact carries Unknown together with another category, so the values are the same.figure_data_dump.pyalso rewords its note on off-diagonal cells, andfigure_data.mdno longer lists the Sankey's node and flow tables per category.prune_data.pychanges in three places: the matrix file name, the Use-Restricted grouping, and the per-part prefix fix (in the classifier and in the unrecognized-strings report). The other scripts of the submitted version, apart from those named above, change only in the category name (CC_RESTRICTIVE, nowUSE_RESTRICTED), in comments, and in the text of entry 17, which points to the category mapping.results_manager.pyis unchanged.- New:
category_laundering.py,figure1.py,PAPER_NUMBERS.md,logs/report_paper_numbers.out,figure1.pdf(Figure 1 of the revised paper),figure1_data.json, and thecoding/andrevision/folders. data/matrix.jsonis replaced bydata/matrix_v2.jsonandmatrix_v2_provenance.csv; the chain file is unchanged.matrix_v2.jsonno longer carries the per-license compatibility tables ofmatrix.json, because compatibility is outside the scope of the study.LICENSE-DATAnow holds only the CC BY 4.0 legal code. Its notes move to the newLICENSE-THIRD-PARTY.md, which extends them to the data incoding/andrevision/and the*_data.jsonfiles, and says that the scripts incoding/andrevision/are under the code license. It states what our CC BY 4.0 grant does not cover: the passages of third-party license texts quoted in the model outputs, and the ScanCode LicenseDB keys, names, categories and SPDX identifiers, which nexB Inc. and others license under CC BY 4.0 and which it credits to them. It also states that the only license texts shipped are the Apache License 2.0 inLICENSEand the MIT License in one example request..gitignorekeeps the license texts and the check table written bycoding/inputs/fetch_texts.pyout of commits.results.json(entries 72 to 74 added; the other entries regenerated) andfigure_data.mdregenerated.requirements.txt: plotly, kaleido and Pillow removed (no script imports them); scipy added; matplotlib raised to 3.10.
@article{jewitt2026licenselaundering,
title = {Don't Trust the Label: License Laundering in AI Supply Chains},
author = {Jewitt, James and Li, Hao and Rajbahadur, Gopi Krishnan and
Adams, Bram and Hassan, Ahmed E.},
journal = {IEEE Software},
year = {2026},
note = {Under review}
}