LOCUS-Fines

A fine-grained fines layer for LOCUS-v1, the Local Ordinance Corpus for the United States. Every one of LOCUS-v1's 2,211,516 code sections gets one annotation row, aligned with the source corpus. Additional annotation provides structured fine information from relevant unstructured text.

Released under the same license as LOCUS-v1 (CC BY-NC 4.0).

Details

• Retrieval Oriented Every dollar amount is verified against the section's own text: it must appear there as digits or written out ("five hundred dollars", "a five-hundred-dollar fine"). An amount that can't be found is removed from that field (see Grounding below), so no unverifiable dollar figure is asserted as fact.
• Statutory text, not practice. This work captures what is written in the law, not about what is actually paid.
• An Addition to LOCUS For storage, the text is not included. Join back to LOCUS-v1 (recipe below) to attach the text.

How it was built

1. Scope. All LOCUS sections labeled function = "Enforcement", plus function = "Rules" sections whose text contains a dollar sign, "fine", "penalty/penalties", "misdemeanor", or "infraction" (631,483 sections).
2. Annotation. Each in-scope section was sent to gemini-3.5-flash-lite with a prompt that forbids inferring amounts.
3. Grounding. Every returned dollar amount was checked against the section's own text.
4. Full-corpus extension. The release covers the entire corpus for consistency and the majority of the rules were not relevant for this annotation. The annotation_source column records which path produced each row.

Code and prompt: see the project repository (link in the citation).

Grounding

After annotation, each dollar amount is verified against the section's own text (digits, comma/cents-insensitive, or the written-out form). When an amount cannot be found, only that field is set to null — every other annotation on the row is kept — and the removed field name is recorded in nulled_fields. This is deliberately per-field, not per-row: a single unverifiable number does not discard an otherwise-good annotation.

In this release, 465 rows had one or more amount fields nulled (533 fields total, ~0.07% of rows). The majority of the annotation seems to be accurate. Some numbers such as "a penalty of five percent", "not less than 30 days" (a suspension), or "forty-eight hours" (incarceration) were occasionally mis-flagged. Nulling the field removes those; grounded = false plus nulled_fields marks the rows for anyone who wants to audit them.
(Great follow-up research!)

One convention: a 0.0 amount always grounds without a literal "$0" in the text. It is how the model encodes "no monetary penalty for this tier" (e.g. "a warning for a first offense, then a $25 fine"), a defensible reading rather than a fabricated figure.

annotation_source — provenance of each row

value	rows	meaning
llm	632,005	in-scope section, annotated by the model (identical duplicate sections — including ones LOCUS labels under a different function — inherit one annotation)
rule_implicit_general	1,094,580	a Rules section with no penalty language of its own: conduct is regulated, so the code's general penalty applies implicitly (fine_relevant = true, amounts null)
rule_not_relevant	484,931	Context / Process sections (non-substantive; fine_relevant = false)

Consumers who want only model-read rows can filter annotation_source == "llm"; those who want a corpus-complete view use all rows.

Schema

column	type	description
state, source_jurisdiction_type, city, county	string	jurisdiction identity, verbatim from LOCUS-v1
function, header	string	section identity within the code, verbatim from LOCUS-v1
content_sha1	string	16-hex fingerprint of the section text (join key; see below)
fine_relevant	bool	the section states, references, or implies a monetary penalty
penalty_scope	enum/null	code_general (code-wide catch-all), chapter_general (chapter/article catch-all), specific (particular conduct); null when the section states no penalty of its own
penalty_stated	enum/null	amounts_here (penalty stated in this text), cross_reference (points elsewhere, e.g. "Penalty, see § 1-8"), implicit_general (conduct prohibited, no penalty mentioned)
fine_structure	enum/null	fixed (one flat amount) or fluid (maximum, range, discretion, or escalation)
fixed_amount	float/null	the flat amount when fine_structure = "fixed"
min_amount, max_amount	float/null	smallest / largest amount stated as a penalty ("not less than" / "not to exceed")
first_violation_amount, second_violation_amount, subsequent_violation_amount	float/null	amounts tied to offense counts
effective_min, effective_max	float/null	min / max across all six amount fields — the section's true penalty span (rolls tiered amounts into the range)
per_day_violation	bool	text explicitly makes each day a separate violation
jail_mentioned	bool	imprisonment stated as a penalty or alternative
penalty_nature	enum/null	criminal, civil, or both
extraction_flag	string/null	edge cases (fragment_incomplete, table_fragment, not_ordinance_text)
grounded	bool/null	verification: false when at least one amount field could not be found in the section's text and was nulled (see Grounding); null on rule-derived rows
nulled_fields	string/null	comma-separated names of the amount field(s) removed by grounding, or null if none
annotation_source	enum	see the provenance table above
llm_error	string/null	batch/parse failure, if any
model	string	the model that produced the row (gemini-3.5-flash-lite, or rule_based)

Invariant: penalty_scope is always null when penalty_stated = "implicit_general" — a section that states no penalty has no penalty scope.

Joining back to LOCUS-v1

The text is not duplicated here. Re-attach it by recomputing the same fingerprint on LOCUS-v1 and joining on the seven identity columns:

import hashlib
import pandas as pd
from datasets import load_dataset

locus = load_dataset("LocalLaws/LOCUS-v1", split="train").to_pandas()
fines = load_dataset("LocalLaws/LOCUS-Fines", split="train").to_pandas()

locus["content_sha1"] = [hashlib.sha1(c.encode()).hexdigest()[:16]
                         for c in locus["content"]]
keys = ["state", "source_jurisdiction_type", "city", "county",
        "function", "header", "content_sha1"]
merged = locus.merge(fines, on=keys, how="left")   # 1:1, no fan-out

The content_sha1 term makes the join exact even where different sections share a heading.

Limitations

• Model annotations reflect a single, cost-efficient model at temperature 0. Dollar amounts are verified against the source (see Grounding); the non-amount fields (penalty_scope, penalty_stated, fine_structure, penalty_nature, fine_relevant) are not independently verified and have not been human-reviewed at scale. Treat grounded = false / nulled_fields and non-null extraction_flag rows with extra caution.
• Grounding covers amount fields only. It catches unverifiable or wrong-unit dollar figures, but does not check the categorical judgments.
• Sections chunked across multiple LOCUS rows are annotated per row; a penalty schedule split across chunks may be partially captured in each.
• Rule-derived rows (rule_implicit_general, rule_not_relevant) carry no amounts by construction.
• Boilerplate ordinance language repeats across jurisdictions, so counts of "N sections do X" overstate independent policy choices.

Citation

Built on and intended as a companion to LOCUS-v1. Please cite the LOCUS corpus (see LocalLaws/LOCUS-v1) alongside this supplement.