Skip to content

About

Repo For License Laundering Paper Scripts

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

License Laundering — Replication Package

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.

Where each part of the paper is

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.md and coding/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, and coding/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.zip and analysis/. The crawl and the ScanCode run are the prior audit's code.

Quick start

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.

Layout

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.

Supply Chain Construction: how the chains were collected

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:

  1. Models. All model metadata from Hugging Face: 1,922,385 models as of August 8, 2025.
  2. Model lineage. Models with at least one like (148,729), plus their ancestors through base_model, whatever their likes: 152,246 models.
  3. Dataset lineage. A model has dataset lineage if its datasets field 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.
  4. 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.
  5. 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).

Pipeline output (report_paper_numbers.py)

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

How the two laundering measures are defined

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

License Categorization (coding/)

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

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 have id, type, licenses, likes and scancode; 24,412 also have copyrights and holders; models add datasets and base_models, applications add models. prune_data.py expands these links into chains. Unchanged from the submitted version (MD5 f756a2796f954893523c04855337cb47).
  • 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 (frozen for the 581 labels unchanged since the coding freeze of 2026-10-14; adjudicated (author), adjudicated (model) or adjudicated (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.

Notes on reproducibility

  • The pipeline is deterministic: repeated runs give the same values and the same figure. Compare results.json as parsed JSON, since key order inside some entries varies, and PDFs by rendering, since they carry timestamps.
  • results.json is keyed by entry number, as PAPER_NUMBERS.md cites 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, plus dm_quadrants and ma_quadrants. The scripts' printed output names entry 69 "Q69". Each entry carries a description. 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.py 175 assertions, category_laundering.py 49, and figure1.py 50 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.json take the top floor(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.py prints some shares rounded twice: Use-Restricted end-to-end is 13.8% in its output (13.75 stored, then rounded), while Figure 1 (G) and figure_data.md round 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.

Factors Associated with Laundering and Threats to Validity (revision/)

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.

License

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.

What changed in the revision

  • 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 by USE_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 by figure1.py. The two figures of the submitted version, figure_1.pdf and figure_2.pdf, are removed, and so is the code that drew them:
    • sankey_rq1.py is removed. figure1.py and report_paper_numbers.py now hold their own copies of its three helpers, which read the chain file and test for Unknown (load_clean_data, get_categories, is_unknown), as figure_data_dump.py, rq1_false_clarity.py, rq2_selective_laundering.py and named_examples.py already do; so does revision/concentration/concentration_units.py.
    • The drawing code of rq2_break_pairs_experiment.py is removed. The script keeps the code that builds and checks the category matrices, which figure1.py, figure_data_dump.py and report_paper_numbers.py import, and the check of entries 61 and 62.
  • figure_data_dump.py and report_paper_numbers.py name 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.py also rewords its note on off-diagonal cells, and figure_data.md no longer lists the Sankey's node and flow tables per category.
  • prune_data.py changes 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, now USE_RESTRICTED), in comments, and in the text of entry 17, which points to the category mapping. results_manager.py is 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 the coding/ and revision/ folders.
  • data/matrix.json is replaced by data/matrix_v2.json and matrix_v2_provenance.csv; the chain file is unchanged. matrix_v2.json no longer carries the per-license compatibility tables of matrix.json, because compatibility is outside the scope of the study.
  • LICENSE-DATA now holds only the CC BY 4.0 legal code. Its notes move to the new LICENSE-THIRD-PARTY.md, which extends them to the data in coding/ and revision/ and the *_data.json files, and says that the scripts in coding/ and revision/ 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 in LICENSE and the MIT License in one example request.
  • .gitignore keeps the license texts and the check table written by coding/inputs/fetch_texts.py out of commits.
  • results.json (entries 72 to 74 added; the other entries regenerated) and figure_data.md regenerated.
  • requirements.txt: plotly, kaleido and Pillow removed (no script imports them); scipy added; matplotlib raised to 3.10.

Citation

@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}
}

About

Repo For License Laundering Paper Scripts

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages