Update the security master

PIPELINE.md

@@ -61,7 +61,7 @@ company that stopped filing in 2014 permanently current under its 2014 ticker,
 and when another company later took that ticker over, both were current at
 once — 1 218 tickers, 6% of the live universe, each pointing at two companies.
 
-Now `is_current` also requires the filer to still be filing, and 53 remain.
+Now `is_current` also requires the filer to still be filing, and 54 remain.
 Those are genuine: dual filers and reorganisations mid-transfer.
 `is_latest_for_filer` keeps the old meaning, because "what did this company last
 call itself" is a real question about dormant companies, and keying issuer
@@ -80,15 +80,18 @@ Two things were learned by measuring rather than assuming.
 
 **The count is the wrong measure.** By raw CUSIP count the bridge looked 37%
 complete, which reads like a failure. Against actual 13F holdings the same
-bridge covers 82.8% of holding rows and 87.9% of position value. Two thirds of
-the CUSIPs ever traded are one-off warrants, foreign lines and delisted shells
-that no strategy touches. The build now gates on match rate weighted by
-settlement traffic, excluding funds.
-
-**Exchange-traded funds can never resolve, and that is correct.** `IVV`, `IWM`,
-`SPY` settle like shares and file nothing a CIK could attach to. Counting them
-as misses is what made the bridge look broken. They carry `looks_like_fund` and
-sit outside the gated denominator.
+bridge covers 83.1% of holding rows and 87.5% of position value. Two thirds
+of the CUSIPs ever traded are one-off warrants, foreign lines and delisted
+shells that no strategy touches. The build now gates on match rate weighted
+by settlement traffic, excluding funds.
+
+**Most funds cannot resolve, and that is correct.** `IVV`, `IWM` and `VOO`
+settle like shares, but they are lines inside a registrant trust's filings and
+file nothing under a ticker of their own. Counting them as misses is what made
+the bridge look broken; they carry `looks_like_fund` and sit outside the gated
+denominator. *Never* was too strong, though, and both documents said it: a fund
+that is its own trust does file, and `SPY`, `GLD`, `DIA` and `MDY` resolve to
+the trust that issues them. 749 fund rows carry a CIK.
 
 **The first six characters are the issuer.** A CUSIP's prefix identifies the
 company, the suffix the instrument, so a class B share or a preferred of a
@@ -97,6 +100,39 @@ so is a fact about how CUSIPs are assigned, not a guess — but the instrument
 itself was never matched, only its issuer, so it carries its own method and a
 middle confidence. It lifted coverage from 37% to 69% of pairs.
 
+**Some of that lift was wrong, and the coverage gate rewarded it.** The prefix
+rule borrowed a filer from *any* match, and a fund family is one prefix: when
+iShares' `ICF` collided with ICF International's ticker, all 74 iShares funds
+under `464287` became ICF International — IVV, IWM and EFA among them — and 14
+Vanguard funds became a Van Kampen muni trust the same way. Checked against
+the filer's own names, 8.6% of the 7 653 inherited fund rows were right. The
+weighted-match gate counts any CIK, right or wrong, so it read the damage as
+progress. Now only a date-confirmed, non-fund match may lend its issuer, a
+prefix that points at two filers lends nothing, and funds never inherit;
+inherited rows that agree on a name went from 84% to 96%.
+
+**A fund is not the company that shares its ticker.** SPDR's `MDY` matched
+Midway Gold by ticker and date, PIMCO's `CORP` a Michigan bank. Names are still
+never used to attach a CUSIP; they are used to refuse one — a fund whose name
+shares no distinctive word with anything the filer was ever called gets
+`name_conflict` and no CIK, and the next candidate is considered. MDY now
+resolves to the SPDR MidCap 400 trust. `CORP` still does not: "PIMCO
+INVESTMENT GRADE CORP BD" carries no word the fund pattern knows.
+
+**One symbol, three spellings.** Settlement records write `BRKB`, filings
+`BRK.B` or `BRK-B`. The join used the literal string, so multi-class companies
+matched only where a filer happened to type the record's spelling. Tickers
+are now joined with the class separator removed; the published `ticker` is
+still the one the record stated.
+
+**The same inputs have to give the same bridge.** When two filers have each
+stated a symbol exactly once, they tie on every key the candidates are ranked
+by, and the winner was whichever row the join emitted first: feeding the
+published pairs back through the builder moved 36 rows to a different filer.
+The CIK now breaks the last tie — arbitrary, but the same every run, which is
+what lets anyone rebuild `cusip_map` from the published tables and get the
+file that was published.
+
 ## Verification
 
 [`quality.py`](recipe/quality.py) gates publication. The check that earns its
@@ -122,7 +158,7 @@ things that move.
 * **No history before Form 4.** Ticker evidence effectively starts in 2006.
   EDGAR does not carry what a company traded as in 1998, so neither does this.
 * **No exchange history worth the name.** Filers rarely name the venue and SEC's
-  current map covers only live listings, so 8 210 spans is all the evidence
+  current map covers only live listings, so 8 228 spans is all the evidence
   there is.
 * **No ISIN, no LEI, no FIGI.** 13F carries a FIGI column and N-PORT carries
   ISIN; neither is ingested yet. The schema has room for them.

README.md

@@ -45,8 +45,8 @@ configs:
 Which company a ticker belonged to, on a date. Which filer a CUSIP points at.
 What a company used to be called.
 
-**23 529 filers · 143 932 identifier spans · 10 056 033 dated observations ·
-74 392 CUSIPs · 1960 to 2026**
+**23 553 filers · 144 054 identifier spans · 10 061 784 dated observations ·
+74 814 CUSIP–ticker pairs · 1960 to 2026**
 
 This is the glue for the rest of the family. Every other ZipLime dataset keys
 on the SEC's CIK, which never changes — and every price series, broker feed and
@@ -61,9 +61,9 @@ See [PIPELINE.md](PIPELINE.md) for the method and its limits.
 
 | | |
 |---|---|
-| Filers that changed ticker | **6 392** of 23 529 |
-| Filers that changed name | **11 435** |
-| Tickers held by more than one company over time | **2 215** of 26 844 |
+| Filers that changed ticker | **6 410** of 23 553 |
+| Filers that changed name | **11 439** |
+| Tickers held by more than one company over time | **2 224** of 26 895 |
 
 A ticker is not an identity. `PLUM` can be one company until 2014 and another
 from 2019, and a strategy that resolves it by today's map reads the second
@@ -102,7 +102,7 @@ Two flags answer two different questions:
   filing in 2011.
 * `is_current` — that, **and** the company still files. Use it to ask *who owns
   this ticker now*. Defining current without the second condition left 1 218
-  tickers current for two companies at once; with it, 53 remain, and those are
+  tickers current for two companies at once; with it, 54 remain, and those are
   genuine dual filers.
 
 ## The CUSIP bridge
@@ -114,20 +114,37 @@ filer over a span, and the two compose.
 
 | Match | Rows | Meaning |
 |---|---|---|
-| `ticker_and_dates` | 22 921 | the ticker matched and the dates overlap — **high** |
-| `cusip6_inherited` | 23 519 | another security of the same issuer resolved — **medium** |
-| `ticker_only` | 4 747 | the ticker matched, the dates do not overlap — **low** |
-| `unmatched` | 23 205 | no filer found — **none** |
-
-**68.8% of CUSIP-ticker pairs resolve to a filer; 78.8% weighted by how often
-the CUSIP appears in settlement records.** Measured against real 13F holdings,
-the matched set covers **82.8% of holding rows and 87.9% of position value.**
+| `ticker_and_dates` | 23 074 | the ticker matched and the dates overlap — **high** |
+| `cusip6_inherited` | 13 105 | another security of the same issuer resolved — **medium** |
+| `ticker_only` | 4 145 | the ticker matched, the dates do not overlap — **low** |
+| `name_conflict` | 683 | a fund, and the filer holding its ticker was never called anything like it — **none** |
+| `unmatched` | 33 807 | no filer found — **none** |
+
+**53.9% of CUSIP-ticker pairs resolve to a filer; 74.8% weighted by how often
+the CUSIP appears in settlement records, counting only the pairs that are not
+funds — which is what the build gates on.** Measured against real 13F holdings,
+the matched set covers **83.1% of holding rows and 87.5% of position
+value** (82.2% and 86.7% keeping only `high` and `medium`).
+
+Every one of those was higher a release ago — 68.8%, 78.7%, 93.9% and 95.0% —
+because the issuer-prefix rule was lending fund families a stranger's CIK and a
+coverage metric counts a wrong filer as a hit. Dropping the wrong matches reads
+as lost coverage. [PIPELINE.md](PIPELINE.md) has what happened.
 
 Counting raw CUSIPs understates it badly, and the reason is worth knowing:
-10 536 of these are exchange-traded funds. An ETF settles like a share and
-files nothing a CIK could attach to — `IVV`, `IWM`, `SPY` will never resolve to
-an operating company, because they are not one. They carry
-`looks_like_fund = true` and are excluded from the coverage the build gates on.
+10 679 of these rows are funds. A fund settles like a share, and most file
+nothing under a ticker of their own — `IVV`, `IWM` and `VOO` are lines inside a
+registrant trust's filings, not filers. They carry `looks_like_fund = true` and
+are excluded from the coverage the build gates on. Some funds *are* their own
+trust and do file: `SPY`, `GLD`, `DIA` and `MDY` each resolve to the trust that
+issues them, and 749 fund rows carry a CIK on that basis. A fund that matched a
+company only by sharing its ticker is refused instead: `MDY` pointed at Midway
+Gold until the name check was added.
+
+A further 8 527 rows carry a settlement symbol that nobody trades under —
+clearing placeholders (`XCEMZZZZ`), preferred lines (`BACPRS`), CUSIP fragments.
+They are real evidence about the instrument and are marked
+`standard_symbol = false` rather than dropped.
 
 ```python
 bridge = pl.read_parquet("data/cusip_map/*.parquet")
@@ -142,11 +159,11 @@ holdings = holdings.join(
 
 | Config | Rows | What one row is |
 |---|---|---|
-| `issuers` | 23 529 | one filer: current name, ticker, industry, and how long it has filed |
-| `identifiers` | 143 932 | one identifier and the span of filings that stated it |
-| `cusip_map` | 74 392 | one CUSIP, the ticker it settles under, the filer behind it |
-| `observations` | 10 056 033 | one dated statement — the evidence the spans are built from |
-| `pit` | 143 932 | one point-in-time identifier event, plus a Delta table for ziplime |
+| `issuers` | 23 553 | one filer: current name, ticker, industry, and how long it has filed |
+| `identifiers` | 144 054 | one identifier and the span of filings that stated it |
+| `cusip_map` | 74 814 | one CUSIP, the ticker it settles under, the filer behind it |
+| `observations` | 10 061 784 | one dated statement — the evidence the spans are built from |
+| `pit` | 144 054 | one point-in-time identifier event, plus a Delta table for ziplime |
 
 `observations` is published so that anyone who disagrees with how the spans
 were derived can derive their own. It is the only honest way to ship a
@@ -156,10 +173,10 @@ judgement.
 
 | Source | Observations | What it gives |
 |---|---|---|
-| Form 4 filings, via [ZipLime/insider-trading](https://huggingface.co/datasets/ZipLime/insider-trading) | 8 123 634 | the ticker a company printed on a filing, on that day — the only free source of ticker **history** |
+| Form 4 filings, via [ZipLime/insider-trading](https://huggingface.co/datasets/ZipLime/insider-trading) | 8 129 289 | the ticker a company printed on a filing, on that day — the only free source of ticker **history** |
 | XBRL filings, via [ZipLime/company-fundamentals](https://huggingface.co/datasets/ZipLime/company-fundamentals) | 1 901 363 | names, former names with change dates, industry, incorporation, fiscal year end |
-| SEC `company_tickers_exchange.json` | 31 036 | today's listings, including companies that never filed a Form 4 |
-| SEC fails-to-deliver records, 409 archives | 23.4M records | CUSIP to ticker, twice a month since 2004 |
+| SEC `company_tickers_exchange.json` | 31 132 | today's listings, including companies that never filed a Form 4 |
+| SEC fails-to-deliver records, 411 archives | 23.5M records | CUSIP to ticker, twice a month since 2004 |
 
 `company_tickers.json` alone is what most projects use, and it is a snapshot:
 it states today and carries no past, so a company that changed symbol appears
@@ -170,14 +187,14 @@ filings that each stated a symbol on a known date.
 
 * **81% of filers have a ticker; 93% of *active* filers do.** The rest are
   funds, trusts and private filers that never printed one.
-* **Exchange is sparse** — 8 210 spans. Filers rarely name the venue, and SEC's
+* **Exchange is sparse** — 8 228 spans. Filers rarely name the venue, and SEC's
   current map only covers live listings.
 * **Coverage starts in 1960** only because a filing header stated a name change
   from then. Ticker evidence effectively begins in 2006 with Form 4, and
   identifiers before that are not in EDGAR to be found.
 * **A span is evidence, not a registry.** See above.
-* **Fund CUSIPs do not resolve, by construction.** See above.
-* **53 tickers are current for two filers.** Dual filers and reorganisations
+* **Most fund CUSIPs do not resolve, by construction.** See above.
+* **54 tickers are current for two filers.** Dual filers and reorganisations
   mid-transfer; the raw observations let you decide.
 
 ## Provenance and updates

data/cusip_map/part-00000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7fe2bc6558ea0b7f64166f3fa8076d27de966e68c2568eb7d12292c17bcbcc35
-size 1837556
+oid sha256:cd8ebbc682ffeb905eb416a4d6093b349ca51c8f53c0058095127e7e33f75f4f
+size 1850407

data/identifiers/part-00000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aa4f6ab540e4de2ae8bd8aa041b3cf3e8a5a5b4e86cc36e57ac51ce6874911f9
-size 1770597
+oid sha256:48e7f1a03d54a79d1e1a774991371bea147ba876b83a7cfbcfc471905af87a13
+size 1771167

data/issuers/part-00000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3767783e6e4e72bc41a6b2e73083e523a06633da8a7337558488133da2c85e8
-size 690488
+oid sha256:96d9e2dfa18a30c07334a0de8bd47e94132b4d916292a59a8d1378f90dd9d7b1
+size 690592

data/observations/part-00000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e732e57a433d255b41f2bbb533e0a6fa81b9414b70956dad53b45af1c9bb3d6f
+oid sha256:9306be91d3a4b46cf263bbba4754979a1ead3211ccf30cefb6096bb4f45170ae
 size 29425864

data/observations/part-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b931492089f73a3cb297af4bbe1fa06edcc8be36690736a31490f855826f451e
-size 29758364
+oid sha256:743c18ff609e0318bb11ee363402643b16a218cdc5c16b56bd768b6f6b0bd4e4
+size 29754913

data/observations/part-00002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b4df1b9b681330eb66423071389a38347491a38d6d7b215717897385410556a5
-size 482268
+oid sha256:15bfda17d6006a1b18eb94672cf259d3af5239dda400fd81c3f3589f3d48baf9
+size 495479

data/pit/part-00000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:86dd5e2364d0fdaf5d44a78d5e69b25f37e9bdee9dea80970a95322b2ba02db1
-size 3619219
+oid sha256:cc58f679482815557e75b0f742202585e4046bbc702734b45cd1f34198eb0be8
+size 3620006

data/pit/security_master.delta/_delta_log/00000000000000000000.json

@@ -1,4 +1,4 @@
-{"commitInfo":{"timestamp":1790581452693,"operation":"WRITE","operationParameters":{"mode":"Overwrite"},"engineInfo":"delta-rs:py-1.6.6","clientVersion":"delta-rs.py-1.6.6","operationMetrics":{"num_added_files":1,"num_removed_files":0,"num_partitions":0,"num_added_rows":144029,"execution_time_ms":107,"num_retries":0}}}
+{"commitInfo":{"timestamp":1790898362759,"operation":"WRITE","operationParameters":{"mode":"Overwrite"},"engineInfo":"delta-rs:py-1.6.6","clientVersion":"delta-rs.py-1.6.6","operationMetrics":{"num_added_files":1,"num_removed_files":0,"num_partitions":0,"num_added_rows":144054,"execution_time_ms":99,"num_retries":0}}}
 {"protocol":{"minReaderVersion":1,"minWriterVersion":2}}
-{"metaData":{"id":"460c6a06-33c5-4047-817e-510cb8a85aa6","name":null,"description":null,"format":{"provider":"parquet","options":{}},"schemaString":"{\"type\":\"struct\",\"fields\":[{\"name\":\"pit_event_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"entity_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"event_date\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_date\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_estimated\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"kind\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"value\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"valid_to\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"observations\",\"type\":\"integer\",\"nullable\":true,\"metadata\":{}},{\"name\":\"sources\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"is_current\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"ingested_at\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}}]}","partitionColumns":[],"createdTime":1790581452586,"configuration":{}}}
-{"add":{"path":"part-00000-30ff4273-3822-47c0-a53e-31ffde051c5d-c000.snappy.parquet","partitionValues":{},"size":5121007,"modificationTime":1790581452693,"dataChange":true,"stats":"{\"numRecords\":144029,\"minValues\":{\"event_date\":\"1960-02-01\",\"kind\":\"exchange\",\"sources\":\"company_tickers\",\"valid_to\":\"1960-02-01\",\"knowledge_estimated\":true,\"value\":\"'MKTG, INC.'\",\"entity_id\":\"0000000017\",\"knowledge_date\":\"1960-02-01T23:59:59Z\",\"observations\":1,\"pit_event_id\":\"0000000017|name|DEFINED ASSET FUNDS MUNICIPAL INVT TR FD MON PYM\",\"is_current\":false,\"ingested_at\":\"2026-09-28T07:44:11.567Z\"},\"maxValues\":{\"value\":\"zulily, inc.\",\"entity_id\":\"0002155226\",\"is_current\":true,\"sources\":\"xbrl\",\"ingested_at\":\"2026-09-28T07:44:11.567Z\",\"valid_to\":\"2026-09-28\",\"knowledge_date\":\"2026-09-28T23:59:59Z\",\"event_date\":\"2026-09-28\",\"observations\":12865,\"pit_event_id\":\"0002155226|ticker|UNIC|2026-09-28\",\"kind\":\"ticker\",\"knowledge_estimated\":true},\"nullCount\":{\"knowledge_date\":0,\"knowledge_estimated\":0,\"valid_to\":0,\"kind\":0,\"sources\":0,\"entity_id\":0,\"is_current\":0,\"value\":0,\"ingested_at\":0,\"event_date\":0,\"pit_event_id\":0,\"observations\":0}}","tags":null,"baseRowId":null,"defaultRowCommitVersion":null,"clusteringProvider":null}}
+{"metaData":{"id":"2b0c4c1c-2193-49a6-b7ac-63cd204232fb","name":null,"description":null,"format":{"provider":"parquet","options":{}},"schemaString":"{\"type\":\"struct\",\"fields\":[{\"name\":\"pit_event_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"entity_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"event_date\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_date\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_estimated\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"kind\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"value\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"valid_to\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"observations\",\"type\":\"integer\",\"nullable\":true,\"metadata\":{}},{\"name\":\"sources\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"is_current\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"ingested_at\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}}]}","partitionColumns":[],"createdTime":1790898362662,"configuration":{}}}
+{"add":{"path":"part-00000-cea57932-5dc2-4803-9d90-2ac29a05c73d-c000.snappy.parquet","partitionValues":{},"size":5118766,"modificationTime":1790898362759,"dataChange":true,"stats":"{\"numRecords\":144054,\"minValues\":{\"event_date\":\"1960-02-01\",\"value\":\"'MKTG, INC.'\",\"pit_event_id\":\"0000000017|name|DEFINED ASSET FUNDS MUNICIPAL INVT TR FD MON PYM\",\"entity_id\":\"0000000017\",\"knowledge_estimated\":true,\"knowledge_date\":\"1960-02-01T23:59:59Z\",\"sources\":\"company_tickers\",\"ingested_at\":\"2026-10-01T23:46:02.152Z\",\"observations\":1,\"kind\":\"exchange\",\"valid_to\":\"1960-02-01\",\"is_current\":false},\"maxValues\":{\"event_date\":\"2026-10-02\",\"valid_to\":\"2026-10-02\",\"ingested_at\":\"2026-10-01T23:46:02.152Z\",\"knowledge_estimated\":true,\"value\":\"zulily, inc.\",\"sources\":\"xbrl\",\"knowledge_date\":\"2026-10-02T23:59:59Z\",\"observations\":12865,\"kind\":\"ticker\",\"is_current\":true,\"entity_id\":\"0002156068\",\"pit_event_id\":\"0002156068|ticker|INBT|2026-10-02\"},\"nullCount\":{\"value\":0,\"event_date\":0,\"observations\":0,\"is_current\":0,\"knowledge_date\":0,\"valid_to\":0,\"kind\":0,\"knowledge_estimated\":0,\"ingested_at\":0,\"sources\":0,\"entity_id\":0,\"pit_event_id\":0}}","tags":null,"baseRowId":null,"defaultRowCommitVersion":null,"clusteringProvider":null}}

data/pit/security_master.delta/{part-00000-30ff4273-3822-47c0-a53e-31ffde051c5d-c000.snappy.parquet → part-00000-cea57932-5dc2-4803-9d90-2ac29a05c73d-c000.snappy.parquet}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d854f17ef87ca07c31a574d0986ae20f9b198229d43deb595babfe71e73bd650
-size 5121007
+oid sha256:27a03dcfe5fa5bd520a2ea40b8eed9ff5d6fed4eebabf09b038dc9c3c83f82a5
+size 5118766

manifest.json

@@ -4,11 +4,11 @@
     "table_uri": "data/pit/security_master.delta"
   },
   "config_rows": {
-    "cusip_map": 74634,
-    "identifiers": 144029,
-    "issuers": 23545,
-    "observations": 10059627,
-    "pit": 144029
+    "cusip_map": 74814,
+    "identifiers": 144054,
+    "issuers": 23553,
+    "observations": 10061784,
+    "pit": 144054
   },
   "config_schemas": {
     "cusip_map": {
@@ -23,6 +23,7 @@
       "match_confidence": "String",
       "match_method": "String",
       "observations": "Int32",
+      "standard_symbol": "Boolean",
       "ticker": "String"
     },
     "identifiers": {
@@ -103,7 +104,7 @@
     }
   },
   "coverage": {
-    "max_observation": "2026-09-28",
+    "max_observation": "2026-10-02",
     "min_observation": "1960-02-01"
   },
   "data_type": "PIT_DATA",
@@ -113,7 +114,7 @@
   "event_date": "valid_from",
   "event_date_type": "date",
   "frequency_seconds": null,
-  "generated_at": "2026-09-28T07:44:13.078072+00:00",
+  "generated_at": "2026-10-01T23:46:02.964020+00:00",
   "identifier_kinds": [
     "ticker",
     "name",
@@ -138,7 +139,7 @@
   },
   "pretty_name": "ZipLime US Security Master (PIT)",
   "quality_ok": true,
-  "rows": 144029,
+  "rows": 144054,
   "source": {
     "build_version": "1.0.0",
     "coverage_note": "Ticker evidence effectively begins in 2006 with Form 4; earlier dates come from name-change fields in filing headers.",
@@ -147,7 +148,7 @@
     "origin": "SEC EDGAR Form 4 and XBRL filings (via ZipLime/insider-trading and ZipLime/company-fundamentals), company_tickers_exchange.json, and SEC fails-to-deliver records",
     "package_version": "1.0.0",
     "recipe": "recipe/",
-    "recipe_hash": "sha256:b8590bad2e9e0bd3379fd17073833442bb7fe532ac44c5715098a903f3208994",
+    "recipe_hash": "sha256:d8e7e1cfa1f07d5f208516b8ad0f50a297b2383fab02585334c915874464c173",
     "schedule": "40 7 * * 1"
   },
   "trading_calendar_name": null,

recipe/intervals.py

@@ -47,6 +47,43 @@ FUND_NAME = re.compile(
     re.I,
 )
 
+# What filers and clearing records put between a root and its share class.
+# BRK.B, BRK-B, BRK/B and BRKB are one symbol: settlement records write it
+# without a separator and filings with one, so joining on the literal string
+# left every multi-class company -- Berkshire, Brown-Forman, Lennar, Heico,
+# Moog -- matched by luck or not at all.
+CLASS_SEPARATOR = r"[.\-/ ]"
+
+# A settlement symbol in the shape a listing has. The rest is real evidence about
+# the instrument but not a symbol anyone trades under: clearing placeholders
+# (XCEMZZZZ, ORCXXXX), preferred lines (BACPRS) and CUSIP fragments (78478V).
+STANDARD_SYMBOL = r"^[A-Z]{1,5}$"
+
+# Words too common in issuer names to say that two names are one company.
+NAME_STOPWORDS = frozenset({
+    "INC", "CORP", "CO", "LTD", "THE", "OF", "TR", "TRUST", "FUND", "FUNDS", "ETF",
+    "SHS", "CL", "COM", "NEW", "PLC", "GROUP", "HLDGS", "HOLDINGS", "LLC", "LP",
+    "SA", "NV", "AG", "CORPORATION", "COMPANY", "INTL", "AMER", "AMERICAN", "FIRST",
+    "NATL", "NATIONAL", "BANCORP", "FINL", "FINANCIAL", "CAP", "CAPITAL", "SER",
+    "SERIES", "AND", "DEL", "ADR", "SPONSORED", "ORD", "CLASS", "INDEX", "SHARES",
+    "INCOME", "STK", "UNIT", "UNITS",
+})
+
+
+def ticker_key(column: str) -> pl.Expr:
+    """A ticker with the share-class separator removed, for joining across sources."""
+    return pl.col(column).str.to_uppercase().str.replace_all(CLASS_SEPARATOR, "")
+
+
+def name_tokens(column: str) -> pl.Expr:
+    """The distinctive words of a name, as a list."""
+    return (
+        pl.col(column).fill_null("").str.to_uppercase().str.extract_all(r"[A-Z0-9]+")
+        .list.eval(pl.element().filter(
+            (pl.element().str.len_chars() > 1) & ~pl.element().is_in(list(NAME_STOPWORDS))
+        ))
+    )
+
 
 def build_identifiers(observations: pl.DataFrame) -> pl.DataFrame:
     """One row per (filer, kind, value) with the span it was stated over."""
@@ -160,6 +197,16 @@ def build_issuers(identifiers: pl.DataFrame, observations: pl.DataFrame) -> pl.D
     return align(frame, ISSUER_SCHEMA).sort("cik")
 
 
+def ftd_pairs(ftd: pl.DataFrame) -> pl.DataFrame:
+    """Settlement records folded to one row per (CUSIP, ticker) and its dates."""
+    return ftd.group_by(["cusip", "ticker"]).agg(
+        pl.col("issuer_name").mode().first().alias("issuer_name"),
+        pl.col("observed_on").min().alias("first_seen"),
+        pl.col("observed_on").max().alias("last_seen"),
+        pl.len().cast(pl.Int32).alias("observations"),
+    )
+
+
 def build_cusip_map(ftd: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFrame:
     """CUSIP to CIK, by way of the ticker both of them name.
 
@@ -171,19 +218,47 @@ def build_cusip_map(ftd: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFram
     """
     if ftd.is_empty():
         return empty_frame(CUSIP_MAP_SCHEMA)
+    return build_cusip_map_from_pairs(ftd_pairs(ftd), identifiers)
 
-    pairs = ftd.group_by(["cusip", "ticker"]).agg(
-        pl.col("issuer_name").mode().first().alias("issuer_name"),
-        pl.col("observed_on").min().alias("first_seen"),
-        pl.col("observed_on").max().alias("last_seen"),
-        pl.len().cast(pl.Int32).alias("observations"),
+
+def build_cusip_map_from_pairs(pairs: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFrame:
+    """The bridge from already-folded pairs, so it can be rebuilt from a published map."""
+    if pairs.is_empty():
+        return empty_frame(CUSIP_MAP_SCHEMA)
+
+    pairs = pairs.select(
+        "cusip", "ticker", "issuer_name", "first_seen", "last_seen", "observations"
+    ).with_columns(
+        ticker_key("ticker").alias("ticker_key"),
+        pl.col("issuer_name").fill_null("").str.contains(FUND_NAME.pattern)
+        .alias("looks_like_fund"),
+        pl.col("ticker").str.contains(STANDARD_SYMBOL).alias("standard_symbol"),
     )
     spans = (
         identifiers.filter(pl.col("kind") == "ticker")
-        .select("cik", pl.col("value").alias("ticker"), "valid_from", "valid_to", "observations")
+        .select("cik", ticker_key("value").alias("ticker_key"), "valid_from", "valid_to",
+                "observations")
         .rename({"observations": "ticker_observations"})
     )
-    joined = pairs.join(spans, on="ticker", how="left")
+    joined = pairs.join(spans, on="ticker_key", how="left")
+
+    # A fund that shares a ticker with a company is not that company. SPDR's MDY
+    # matched Midway Gold, PIMCO's CORP a Michigan bank, Vanguard's VPL an Invesco
+    # muni trust. Names are not used to *attach* a CUSIP -- a wrong name match
+    # looks exactly like a right one -- only to refuse a fund whose name shares no
+    # word with anything the filer was ever called.
+    filer_tokens = (
+        identifiers.filter(pl.col("kind").is_in(["name", "former_name"]))
+        .group_by("cik")
+        .agg(pl.col("value").str.join(" "))
+        .select("cik", name_tokens("value").list.unique().alias("filer_tokens"))
+    )
+    joined = joined.join(filer_tokens, on="cik", how="left").with_columns(
+        pl.col("filer_tokens").list.len().fill_null(0).gt(0).alias("filer_named"),
+        name_tokens("issuer_name").list.set_intersection(pl.col("filer_tokens"))
+        .list.len().fill_null(0).gt(0).alias("name_agrees"),
+    )
+    conflict = pl.col("looks_like_fund") & pl.col("filer_named") & ~pl.col("name_agrees")
 
     slack = timedelta(days=CUSIP_MATCH_SLACK_DAYS)
     overlaps = (pl.col("first_seen") <= pl.col("valid_to") + slack) & (
@@ -192,21 +267,34 @@ def build_cusip_map(ftd: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFram
     joined = joined.with_columns(
         pl.when(pl.col("cik").is_null())
         .then(pl.lit("unmatched"))
+        .when(conflict)
+        .then(pl.lit("name_conflict"))
         .when(overlaps)
         .then(pl.lit("ticker_and_dates"))
         .otherwise(pl.lit("ticker_only"))
         .alias("match_method")
+    ).with_columns(
+        pl.when(pl.col("match_method") == "name_conflict").then(None)
+        .otherwise(pl.col("cik")).alias("cik")
     )
     # One ticker can belong to several filers over time -- that is the whole
     # point of this dataset -- so the date-overlapping candidate wins, and the
-    # best-evidenced one breaks a remaining tie.
+    # best-evidenced one breaks a remaining tie. Two filers that each stated the
+    # symbol once are still tied after that, and without a last key the winner
+    # was whichever row the join happened to emit first: the same inputs gave
+    # 36 rows a different filer depending on the order the pairs arrived in.
+    # The CIK is an arbitrary tie-break but a stable one, which is what a
+    # published build has to be.
     ranked = joined.sort(
         ["cusip", "ticker",
          pl.col("match_method").replace_strict(
-             {"ticker_and_dates": 0, "ticker_only": 1, "unmatched": 2}, default=3
+             {"ticker_and_dates": 0, "ticker_only": 1, "name_conflict": 2, "unmatched": 3},
+             default=4,
          ),
-         pl.col("ticker_observations").fill_null(0)],
-        descending=[False, False, False, True],
+         pl.col("ticker_observations").fill_null(0),
+         pl.col("cik")],
+        descending=[False, False, False, True, False],
+        nulls_last=True,
     ).group_by(["cusip", "ticker"], maintain_order=True).first()
 
     ranked = ranked.with_columns(pl.col("cusip").str.slice(0, 6).alias("cusip6"))
@@ -217,21 +305,31 @@ def build_cusip_map(ftd: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFram
     # so is a fact about how CUSIPs are assigned rather than a guess. It carries
     # its own method and a middle confidence, because the *instrument* was never
     # matched -- only its issuer.
+    #
+    # Only a confident, unambiguous match may lend its issuer. Inheriting from any
+    # match let one fund's accidental ticker collision -- iShares' ICF with ICF
+    # International, Vanguard's VOT with a Van Kampen trust -- name the issuer of
+    # every fund under the same prefix: 74 iShares and 14 Vanguard ETFs, IVV,
+    # IWM, EFA, VOO and VTI among them. A fund family's prefix is a registrant
+    # trust that files nothing under a ticker, so funds never inherit at all.
     issuer_level = (
-        ranked.filter(pl.col("cik").is_not_null())
+        ranked.filter((pl.col("match_method") == "ticker_and_dates") & ~pl.col("looks_like_fund"))
         .group_by("cusip6")
-        .agg(pl.col("cik").mode().first().alias("issuer_cik"))
+        .agg(pl.col("cik").n_unique().alias("issuers"), pl.col("cik").first().alias("issuer_cik"))
+        .filter(pl.col("issuers") == 1)
+        .select("cusip6", "issuer_cik")
+    )
+    inherits = (
+        pl.col("cik").is_null() & pl.col("issuer_cik").is_not_null() & ~pl.col("looks_like_fund")
+        & (pl.col("match_method") != "name_conflict")
     )
     ranked = ranked.join(issuer_level, on="cusip6", how="left").with_columns(
-        pl.when(pl.col("cik").is_null() & pl.col("issuer_cik").is_not_null())
-        .then(pl.lit("cusip6_inherited"))
-        .otherwise(pl.col("match_method"))
+        pl.when(inherits).then(pl.lit("cusip6_inherited")).otherwise(pl.col("match_method"))
         .alias("match_method"),
-        pl.coalesce([pl.col("cik"), pl.col("issuer_cik")]).alias("cik"),
+        pl.when(inherits).then(pl.col("issuer_cik")).otherwise(pl.col("cik")).alias("cik"),
     )
 
     ranked = ranked.with_columns(
-        pl.col("issuer_name").fill_null("").str.contains(FUND_NAME.pattern).alias("looks_like_fund"),
         pl.when(pl.col("match_method") == "ticker_and_dates")
         .then(pl.lit("high"))
         .when(pl.col("match_method") == "cusip6_inherited")

recipe/quality.py

@@ -161,6 +161,23 @@ def validate(data_dir: Path) -> QualityReport:
             )
         if cusip_map.select("cusip", "ticker").unique().height != cusip_map.height:
             report.error("cusip_map: duplicate (cusip, ticker) rows")
+        # A fund family shares one CUSIP prefix, so a fund inheriting its filer
+        # from that prefix means one accidental ticker collision has named every
+        # fund under it. This is how IVV, IWM and EFA came to be ICF International.
+        inherited_funds = cusip_map.filter(
+            pl.col("looks_like_fund").fill_null(False)
+            & (pl.col("match_method") == "cusip6_inherited")
+        ).height
+        report.metric("cusip_fund_rows_inherited", inherited_funds)
+        if inherited_funds:
+            report.error(
+                f"cusip_map: {inherited_funds} fund rows took a filer from their CUSIP "
+                f"prefix — a fund family's prefix names no operating company"
+            )
+        report.metric(
+            "cusip_name_conflicts",
+            cusip_map.filter(pl.col("match_method") == "name_conflict").height,
+        )
 
     if not pit.is_empty():
         if pit.height != identifiers.height:

recipe/schema.py

@@ -86,6 +86,9 @@ CUSIP_MAP_SCHEMA: dict[str, pl.DataType] = {
     # nothing a CIK could be attached to. Not a failed match: a different kind
     # of instrument.
     "looks_like_fund": pl.Boolean,
+    # False for a clearing placeholder (XCEMZZZZ), a preferred line (BACPRS) or
+    # a CUSIP fragment: evidence about the instrument, not a symbol to trade.
+    "standard_symbol": pl.Boolean,
     "inserted_at": UTC_DATETIME,
 }
 

tests/test_intervals.py

@@ -6,7 +6,14 @@ from datetime import date
 
 import polars as pl
 
-from recipe.intervals import build_cusip_map, build_identifiers, build_issuers, build_pit
+from recipe.intervals import (
+    build_cusip_map,
+    build_cusip_map_from_pairs,
+    build_identifiers,
+    build_issuers,
+    build_pit,
+    ftd_pairs,
+)
 
 
 def test_a_ticker_change_becomes_two_spans(observations):
@@ -87,3 +94,102 @@ def test_pit_dates_every_span_and_never_leaks(observations):
     # Knowledge is the end of the day observed, so it never precedes the event.
     assert (pit["knowledge_date"].dt.date() >= pit["event_date"]).all()
     assert pit["knowledge_estimated"].all()
+
+
+def _bridge(observations, ftd_rows):
+    return build_cusip_map(pl.DataFrame(ftd_rows, strict=False), build_identifiers(observations))
+
+
+def _ftd(cusip, ticker, name, day):
+    return {"cusip": cusip, "ticker": ticker, "issuer_name": name, "observed_on": day,
+            "source_ref": "f"}
+
+
+def test_a_share_class_matches_across_separators():
+    """Settlement records write BRKB, filings BRK.B: one symbol, one filer."""
+    from conftest import observation
+    obs = pl.DataFrame([
+        observation("0000000010", "ticker", "BRK.B", date(2015, 1, 1)),
+        observation("0000000010", "ticker", "BRK.B", date(2020, 1, 1)),
+        observation("0000000010", "name", "Berkshire Hathaway Inc", date(2020, 1, 1)),
+    ], strict=False)
+    bridge = _bridge(obs, [_ftd("084670702", "BRKB", "BERKSHIRE HATHAWAY INC CL B", date(2018, 1, 1))])
+    row = bridge.row(0, named=True)
+    assert row["cik"] == "0000000010" and row["match_confidence"] == "high"
+    assert row["ticker"] == "BRKB", "the published ticker is the one the record stated"
+
+
+def test_a_fund_is_not_the_company_that_shares_its_ticker():
+    """SPDR's MDY matched Midway Gold by ticker and date. A fund whose name shares
+    no word with anything the filer was called is refused, not attached."""
+    from conftest import observation
+    obs = pl.DataFrame([
+        observation("0000000020", "ticker", "MDY", date(2010, 1, 1)),
+        observation("0000000020", "ticker", "MDY", date(2012, 1, 1)),
+        observation("0000000020", "name", "Midway Gold Corp", date(2012, 1, 1)),
+    ], strict=False)
+    bridge = _bridge(obs, [_ftd("78467Y107", "MDY", "SPDR S&P MIDCAP 400 ETF TR UTS", date(2011, 1, 1))])
+    row = bridge.row(0, named=True)
+    assert row["cik"] is None
+    assert row["match_method"] == "name_conflict" and row["match_confidence"] == "none"
+
+
+def test_one_collision_does_not_name_a_whole_fund_family():
+    """iShares' ICF once matched ICF International, and inheriting by CUSIP prefix
+    then gave that company's CIK to IVV, IWM, EFA and 71 more funds."""
+    from conftest import observation
+    obs = pl.DataFrame([
+        observation("0000000030", "ticker", "ICF", date(2010, 1, 1)),
+        observation("0000000030", "ticker", "ICF", date(2012, 1, 1)),
+    ], strict=False)
+    bridge = _bridge(obs, [
+        _ftd("464287564", "ICF", "ISHARES COHEN & STEERS REIT ETF", date(2011, 1, 1)),
+        _ftd("464287200", "IVV", "ISHARES CORE S&P 500 ETF", date(2011, 1, 1)),
+    ])
+    ivv = bridge.filter(pl.col("ticker") == "IVV").row(0, named=True)
+    assert ivv["cik"] is None and ivv["match_method"] == "unmatched"
+
+
+def test_an_issuer_prefix_still_lends_its_filer_to_other_classes():
+    """The prefix rule is right for companies: a class A share of a company whose
+    common stock matched belongs to the same filer."""
+    from conftest import observation
+    obs = pl.DataFrame([
+        observation("0000000040", "ticker", "HEI", date(2010, 1, 1)),
+        observation("0000000040", "ticker", "HEI", date(2020, 1, 1)),
+    ], strict=False)
+    bridge = _bridge(obs, [
+        _ftd("422806109", "HEI", "HEICO CORP", date(2015, 1, 1)),
+        _ftd("422806208", "HEIXA", "HEICO CORP CL A", date(2015, 1, 1)),
+    ])
+    cls = bridge.filter(pl.col("cusip") == "422806208").row(0, named=True)
+    assert cls["cik"] == "0000000040" and cls["match_confidence"] == "medium"
+
+
+def test_clearing_placeholders_are_marked():
+    from conftest import observation
+    obs = pl.DataFrame([observation("0000000050", "ticker", "XCEM", date(2015, 1, 1))], strict=False)
+    bridge = _bridge(obs, [
+        _ftd("19762B202", "XCEMZZZZ", "COLUMBIA ETF TR II", date(2015, 1, 1)),
+        _ftd("19762B203", "XCEM", "COLUMBIA ETF TR II", date(2015, 1, 1)),
+    ])
+    flags = dict(bridge.select("ticker", "standard_symbol").iter_rows())
+    assert flags == {"XCEMZZZZ": False, "XCEM": True}
+
+
+def test_a_tie_between_two_filers_resolves_the_same_way_every_time():
+    """Two filers that each stated the symbol once are tied on every rank the
+    bridge sorts by. Without a last key the winner was whichever row the join
+    emitted first, and the same inputs in a different order gave a different
+    filer."""
+    from conftest import observation
+    obs = pl.DataFrame([
+        observation("0000000061", "ticker", "TIE", date(2011, 1, 1)),
+        observation("0000000062", "ticker", "TIE", date(2011, 1, 1)),
+    ], strict=False)
+    identifiers = build_identifiers(obs)
+    pairs = ftd_pairs(pl.DataFrame(
+        [_ftd("111111105", "TIE", "TIE CORP", date(2011, 1, 1))], strict=False))
+    forward = build_cusip_map_from_pairs(pairs, identifiers)
+    backward = build_cusip_map_from_pairs(pairs, identifiers.reverse())
+    assert forward.drop("inserted_at").equals(backward.drop("inserted_at"))