add_2025_09_release (#12)

- initial commit (224d4f423e74f706654d213972fd89c222b5e89f)
- Initial (51fb9a995c51ac6f6324f74fbdc42a978d69b2e5)
- Add input form (7b84eb312154d8c4928616425934bc56fe2cfc63)
- Update README.md (edf0abf2e7346c98a1b566db389c8dd0683d8d35)
- Update README.md (4e2a6180d4ed81727c1525c71f270b28b40a4b4b)
- Update README.md (ef113c655091b73b3191af668ff73f33c4814208)
- Update README.md (853733840b608b94ebb3635625f1a069ebe83cb8)
- Update README.md (8307fb2366b2d104a13f027773129721287269a1)
- Add 2025-03-27 report files (1de953254efe37784dc68d915b5fa4981d766c71)
- upload cluster level dataset (71736ca939dccd17d699850042def2577ec872a8)
- updated data release readme to include cluster level data description (124ebb7ae83d03c1a39e714fb6844d5e880321e2)
- move cluster level data up (ad8570912849c2758f89b45a72b51051a63039db)
- re-upload initial release (a510f6293979bccfa4622ef56228366774bd75db)
- Clean up repo (355a7f23a5ad7837ebdec77a13d61667535acb0d)
- add Readme (6aafd934b295f1fec496218ef93bc2aa5894e318)
- updated links (780d72708df84795d1111dad85d6d02b948741e4)
- update yaml (b3980d41243240deee12941eac0e4d1e2fff52b9)
- add license, test readme change (359da41f78f3bf8a098a64a4b5184ae65955173d)
- update readme (357435fd8d14e50bf50c18e3d4f4ec7a0f30645f)
- Update README.md (03691a743a2136a2b51c544eabafba3c4d1820db)
- Update README.md (d5fde0fec45b85922913afa547b28d1e65333f5d)
- Update README.md (7e0d553749111ce3e7904dc30b125d0c6b880d36)
- Update README.md (948d8f3c90ae3bffa105c1d750682d43e26ea1f7)
- Add September 2025 report replication files (4baa2dff76a8cdf0194419e87825647a45e18f1f)
- Update LFS patterns to include subdirectories (06970d96c1d2d2ac82d3240b6d16e7517efd6402)
- Merge remote-tracking branch 'origin/main' into pr/12 (fe6a1e6ba0953c9829380d66db7b2e831e4d2a2e)


Co-authored-by: Alex Tamkin <[email protected]>
Co-authored-by: kunalhanda <[email protected]>
Co-authored-by: Miles McCain <[email protected]>
Co-authored-by: Michael Stern <[email protected]>

.gitattributes

@@ -57,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+release_2025_09_15/**/*.csv filter=lfs diff=lfs merge=lfs -text
+release_2025_09_15/**/*.xlsx filter=lfs diff=lfs merge=lfs -text
+release_2025_09_15/**/*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.DS_Store

README.md

@@ -9,10 +9,14 @@ tags:
 viewer: true
 license: mit
 configs:
-- config_name: default
+- config_name: release_2025_09_15
   data_files:
-  - split: train
-    path: "release_2025_03_27/automation_vs_augmentation_by_task.csv"
+  - split: raw_claude_ai
+    path: "release_2025_09_15/data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv"
+  - split: raw_1p_api
+    path: "release_2025_09_15/data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv"
+  - split: enriched_claude_ai
+    path: "release_2025_09_15/data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv"
 ---
 
 # The Anthropic Economic Index
@@ -25,13 +29,17 @@ The Anthropic Economic Index provides insights into how AI is being incorporated
 
 This repository contains multiple data releases, each with its own documentation:
 
-- **[2025-02-10 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_02_10)**: Initial release with O*NET task mappings, automation vs. augmentation data, and more
+- **[2025-09-15 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_09_15)**: Updated analysis with geographic and first-party API data using Sonnet 4
 - **[2025-03-27 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_03_27)**: Updated analysis with Claude 3.7 Sonnet data and cluster-level insights
+- **[2025-02-10 Release](https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_02_10)**: Initial release with O*NET task mappings, automation vs. augmentation data, and more
+
 
 ## Resources
 
 - [Index Home Page](https://www.anthropic.com/economic-index)
-- [Research Paper](https://assets.anthropic.com/m/2e23255f1e84ca97/original/Economic_Tasks_AI_Paper.pdf)
+- [3rd report](https://www.anthropic.com/research/anthropic-economic-index-september-2025-report)
+- [2nd report](https://www.anthropic.com/news/anthropic-economic-index-insights-from-claude-sonnet-3-7)
+- [1st report](https://www.anthropic.com/news/the-anthropic-economic-index)
 
 
 ## License
@@ -40,10 +48,24 @@ Data released under CC-BY, code released under MIT License
 
 ## Contact
 
-For inquiries, contact [email protected] or [email protected]. We invite researchers to provide input on potential future data releases using [this form](https://docs.google.com/forms/d/e/1FAIpQLSfDEdY-mT5lcXPaDSv-0Ci1rSXGlbIJierxkUbNB7_07-kddw/viewform?usp=dialog).
+For inquiries, contact [email protected]. We invite researchers to provide input on potential future data releases using [this form](https://docs.google.com/forms/d/e/1FAIpQLSfDEdY-mT5lcXPaDSv-0Ci1rSXGlbIJierxkUbNB7_07-kddw/viewform?usp=dialog).
 
 ## Citation
 
+### Third release
+
+```
+@online{appelmccrorytamkin2025geoapi,
+        author = {Ruth Appel and Peter McCrory and Alex Tamkin and Michael Stern and Miles McCain and Tyler Neylon],
+        title = {Anthropic Economic Index Report: Uneven Geographic and Enterprise AI Adoption},
+        date = {2025-09-15},
+        year = {2025},
+        url = {www.anthropic.com/research/anthropic-economic-index-september-2025-report},
+}
+```
+
+### Second release
+
 ```
 @misc{handa2025economictasksperformedai,
       title={Which Economic Tasks are Performed with AI? Evidence from Millions of Claude Conversations}, 

release_2025_09_15/README.md

@@ -0,0 +1,72 @@
+# Anthropic Economic Index September 2025 Report Replication
+
+## Folder Structure
+
+```
+.
+├── code/                  # Analysis scripts
+├── data/
+│   ├── input/             # Raw data files (from external sources or prior releases)
+│   ├── intermediate/      # Processed data files
+│   └── output/            # Final outputs (plots, tables, etc.)
+├── data_documentation.md  # Documentation of all data sources and datasets
+└── README.md
+```
+
+## Data Processing Pipeline
+
+**Note:** Since all preprocessed data files are provided, you can skip directly to the Analysis section (Section 2) if you want to replicate the results without re-running the preprocessing steps. Please refer to `data_documentation.md` for details on the different data used.
+
+Run the following scripts in order from the `code/` directory:
+
+### 1. Data Preprocessing
+
+1. **`preprocess_iso_codes.py`**
+   - Processes ISO country codes
+   - Creates standardized country code mappings
+
+2. **`preprocess_population.py`**
+   - Processes country-level population data
+   - Processes US state-level population data
+   - Outputs working age population statistics
+
+3. **`preprocess_gdp.py`**
+   - Downloads and processes IMF country GDP data
+   - Processes BEA US state GDP data
+   - Creates standardized GDP datasets
+
+4. **`preprocess_onet.py`**
+   - Processes O*NET occupation and task data
+   - Creates SOC occupation mappings
+
+5. **`aei_report_v3_preprocessing_1p_api.ipynb`**
+   - Jupyter notebook for preprocessing API and Claude.ai usage data
+   - Prepares data for analysis
+
+### 2. Analysis
+
+#### Analysis Scripts
+
+1. **`aei_report_v3_change_over_time_claude_ai.py`**
+   - Analyzes automation trends across report versions (V1, V2, V3)
+   - Generates comparison figures showing evolution of automation estimates
+
+2. **`aei_report_v3_analysis_claude_ai.ipynb`**
+   - Analysis notebook for Claude.ai usage patterns
+   - Generates figures specific to Claude.ai usage
+   - Uses functions from `aei_analysis_functions_claude_ai.py`
+
+3. **`aei_report_v3_analysis_1p_api.ipynb`**
+   - Main analysis notebook for API usage patterns
+   - Generates figures for occupational usage, collaboration patterns, and regression analyses
+   - Uses functions from `aei_analysis_functions_1p_api.py`
+
+#### Supporting Function Files
+
+- **`aei_analysis_functions_claude_ai.py`**
+  - Core analysis functions for Claude.ai data
+  - Platform-specific analysis and visualization functions
+
+- **`aei_analysis_functions_1p_api.py`**
+  - Core analysis functions for API data
+  - Includes regression models, plotting functions, and data transformations

release_2025_09_15/code/aei_analysis_functions_1p_api.py

@@ -0,0 +1,2339 @@
+# AEI 1P API Analysis Functions
+# This module contains the core analysis functions for the AEI report API chapter
+
+from pathlib import Path
+from textwrap import wrap
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import statsmodels.api as sm
+from plotly.subplots import make_subplots
+
+# Define the tier colors
+CUSTOM_COLORS_LIST = ["#E6DBD0", "#E5C5AB", "#E4AF86", "#E39961", "#D97757"]
+
+# Define the color cycle for charts
+COLOR_CYCLE = [
+    "#D97757",
+    "#656565",
+    "#40668C",
+    "#E39961",
+    "#E4AF86",
+    "#C65A3F",
+    "#8778AB",
+    "#E5C5AB",
+    "#B04F35",
+]
+
+
+def setup_plot_style():
+    """Configure matplotlib for publication-quality figures."""
+    plt.style.use("default")
+    plt.rcParams.update(
+        {
+            "figure.dpi": 100,
+            "savefig.dpi": 300,
+            "font.size": 10,
+            "axes.labelsize": 11,
+            "axes.titlesize": 12,
+            "xtick.labelsize": 9,
+            "ytick.labelsize": 9,
+            "legend.fontsize": 9,
+            "figure.facecolor": "white",
+            "axes.facecolor": "white",
+            "savefig.facecolor": "white",
+            "axes.edgecolor": "#333333",
+            "axes.linewidth": 0.8,
+            "axes.grid": True,
+            "grid.alpha": 0.3,
+            "grid.linestyle": "-",
+            "grid.linewidth": 0.5,
+            "axes.axisbelow": True,
+            "text.usetex": False,
+            "mathtext.default": "regular",
+            "axes.titlecolor": "#B86046",
+            "figure.titlesize": 16,
+        }
+    )
+
+
+# Initialize style
+setup_plot_style()
+
+
+def load_preprocessed_data(input_file):
+    """
+    Load preprocessed API data from CSV or Parquet file.
+
+    Args:
+        input_file: Path to preprocessed data file
+
+    Returns:
+        DataFrame with preprocessed API data
+    """
+    input_path = Path(input_file)
+
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+
+    df = pd.read_csv(input_path)
+    return df
+
+
+def create_top_requests_bar_chart(df, output_dir):
+    """
+    Create bar chart showing top 15 request categories (level 2) by count share.
+
+    Args:
+        df: Preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Get request data at level 2 (global only) using percentages
+    request_data = df[
+        (df["facet"] == "request")
+        & (df["geo_id"] == "GLOBAL")
+        & (df["level"] == 2)
+        & (df["variable"] == "request_pct")
+    ].copy()
+
+    # Filter out not_classified (but don't renormalize)
+    request_data = request_data[request_data["cluster_name"] != "not_classified"]
+
+    # Use the percentage values directly (already calculated in preprocessing)
+    request_data["request_pct"] = request_data["value"]
+
+    # Get top 15 requests by percentage share
+    top_requests = request_data.nlargest(15, "request_pct").sort_values(
+        "request_pct", ascending=True
+    )
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(14, 10))
+
+    # Create horizontal bar chart with tier color gradient
+    y_pos = np.arange(len(top_requests))
+
+    # Use tier colors based on ranking (top categories get darker colors)
+    colors = []
+    for i in range(len(top_requests)):
+        # Map position to tier color (top bars = darker, bottom bars = lighter)
+        # Since bars are sorted ascending, higher index = higher value = darker color
+        rank_position = i / (len(top_requests) - 1)
+        tier_index = int(rank_position * (len(CUSTOM_COLORS_LIST) - 1))
+        colors.append(CUSTOM_COLORS_LIST[tier_index])
+
+    ax.barh(
+        y_pos,
+        top_requests["request_pct"],
+        color=colors,
+        alpha=0.9,
+        edgecolor="#333333",
+        linewidth=0.5,
+    )
+
+    # Add value labels on bars
+    for i, (idx, row) in enumerate(top_requests.iterrows()):
+        ax.text(
+            row["request_pct"] + 0.1,
+            i,
+            f"{row['request_pct']:.1f}%",
+            va="center",
+            fontsize=11,
+            fontweight="bold",
+        )
+
+    # Clean up request names for y-axis labels
+    labels = []
+    for name in top_requests["cluster_name"]:
+        # Truncate long names and add line breaks
+        if len(name) > 60:
+            # Find good break point around middle
+            mid = len(name) // 2
+            break_point = name.find(" ", mid)
+            if break_point == -1:  # No space found, just break at middle
+                break_point = mid
+            clean_name = name[:break_point] + "\n" + name[break_point:].strip()
+        else:
+            clean_name = name
+        labels.append(clean_name)
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(labels, fontsize=10)
+
+    # Formatting
+    ax.set_xlabel("Percentage of total request count", fontsize=14)
+    ax.set_title(
+        "Top use cases among 1P API transcripts by usage share \n (broad grouping, bottom-up classification)",
+        fontsize=14,
+        fontweight="bold",
+        pad=20,
+    )
+
+    # Add grid
+    ax.grid(True, alpha=0.3, axis="x")
+    ax.set_axisbelow(True)
+
+    # Remove top and right spines
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    # Increase tick label font size
+    ax.tick_params(axis="x", which="major", labelsize=12)
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "top_requests_level2_bar_chart.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def load_onet_mappings():
+    """
+    Load ONET task statements and SOC structure for occupational category mapping.
+
+    Returns:
+        Tuple of (task_statements_df, soc_structure_df)
+    """
+    # Load from local files
+    task_path = Path("../data/intermediate/onet_task_statements.csv")
+    soc_path = Path("../data/intermediate/soc_structure.csv")
+
+    # Load CSV files directly
+    task_statements = pd.read_csv(task_path)
+    soc_structure = pd.read_csv(soc_path)
+
+    return task_statements, soc_structure
+
+
+def map_to_occupational_categories(df, task_statements, soc_structure):
+    """
+    Map ONET task data to major occupational categories.
+
+    Args:
+        df: Preprocessed data DataFrame
+        task_statements: ONET task statements DataFrame
+        soc_structure: SOC structure DataFrame
+
+    Returns:
+        DataFrame with occupational category mappings
+    """
+    # Filter for ONET task data
+    onet_data = df[df["facet"] == "onet_task"].copy()
+
+    # Handle not_classified and none tasks first
+    not_classified_mask = onet_data["cluster_name"].isin(["not_classified", "none"])
+    not_classified_data = onet_data[not_classified_mask].copy()
+    not_classified_data["soc_major"] = "99"
+    not_classified_data["occupational_category"] = "Not Classified"
+
+    # Process regular tasks
+    regular_data = onet_data[~not_classified_mask].copy()
+
+    # Standardize task descriptions for matching
+    # Create standardized task mapping from ONET statements
+    task_statements["task_standardized"] = (
+        task_statements["Task"].str.strip().str.lower()
+    )
+    regular_data["cluster_name_standardized"] = (
+        regular_data["cluster_name"].str.strip().str.lower()
+    )
+
+    # Create mapping from standardized task to major groups (allowing multiple)
+    task_to_major_groups = {}
+    for _, row in task_statements.iterrows():
+        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
+            std_task = row["task_standardized"]
+            major_group = str(int(row["soc_major_group"]))
+            if std_task not in task_to_major_groups:
+                task_to_major_groups[std_task] = []
+            if major_group not in task_to_major_groups[std_task]:
+                task_to_major_groups[std_task].append(major_group)
+
+    # Expand rows for tasks that belong to multiple groups
+    expanded_rows = []
+    for _, row in regular_data.iterrows():
+        std_task = row["cluster_name_standardized"]
+        if std_task in task_to_major_groups:
+            groups = task_to_major_groups[std_task]
+            # Assign full value to each group (creates duplicates)
+            for group in groups:
+                new_row = row.copy()
+                new_row["soc_major"] = group
+                new_row["value"] = row["value"]  # Keep full value for each group
+                expanded_rows.append(new_row)
+
+    # Create new dataframe from expanded rows
+    if expanded_rows:
+        regular_data = pd.DataFrame(expanded_rows)
+    else:
+        regular_data["soc_major"] = None
+
+    # Get major occupational groups from SOC structure
+    # Filter for rows where 'Major Group' is not null (these are the major groups)
+    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
+
+    # Extract major group code and title
+    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
+    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
+
+    # Create a clean mapping from major group code to title
+    major_group_mapping = (
+        major_groups[["soc_major", "title"]]
+        .drop_duplicates()
+        .set_index("soc_major")["title"]
+        .to_dict()
+    )
+
+    # Map major group codes to titles for regular data
+    regular_data["occupational_category"] = regular_data["soc_major"].map(
+        major_group_mapping
+    )
+
+    # Keep only successfully mapped regular data
+    regular_mapped = regular_data[regular_data["occupational_category"].notna()].copy()
+
+    # Combine regular mapped data with not_classified data
+    onet_mapped = pd.concat([regular_mapped, not_classified_data], ignore_index=True)
+
+    # Renormalize percentages to sum to 100 since we may have created duplicates
+    total = onet_mapped["value"].sum()
+
+    onet_mapped["value"] = (onet_mapped["value"] / total) * 100
+
+    return onet_mapped
+
+
+def create_platform_occupational_comparison(api_df, cai_df, output_dir):
+    """
+    Create horizontal bar chart comparing occupational categories between Claude.ai and 1P API.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Load ONET mappings for occupational categories
+    task_statements, soc_structure = load_onet_mappings()
+
+    # Process both datasets to get occupational categories
+    def get_occupational_data(df, platform_name):
+        # Get ONET task percentage data (global level only)
+        onet_data = df[
+            (df["facet"] == "onet_task")
+            & (df["geo_id"] == "GLOBAL")
+            & (df["variable"] == "onet_task_pct")
+        ].copy()
+
+        # Map to occupational categories using existing function
+        onet_mapped = map_to_occupational_categories(
+            onet_data, task_statements, soc_structure
+        )
+
+        # Sum percentages by occupational category
+        category_percentages = (
+            onet_mapped.groupby("occupational_category")["value"].sum().reset_index()
+        )
+
+        # Exclude "Not Classified" category from visualization
+        category_percentages = category_percentages[
+            category_percentages["occupational_category"] != "Not Classified"
+        ]
+
+        category_percentages.columns = ["category", f"{platform_name.lower()}_pct"]
+
+        return category_percentages
+
+    # Get data for both platforms
+    api_categories = get_occupational_data(api_df, "API")
+    claude_categories = get_occupational_data(cai_df, "Claude")
+
+    # Merge the datasets
+    category_comparison = pd.merge(
+        claude_categories, api_categories, on="category", how="outer"
+    ).fillna(0)
+
+    # Filter to substantial categories (>0.5% in either platform)
+    category_comparison = category_comparison[
+        (category_comparison["claude_pct"] > 0.5)
+        | (category_comparison["api_pct"] > 0.5)
+    ].copy()
+
+    # Calculate difference and total
+    category_comparison["difference"] = (
+        category_comparison["api_pct"] - category_comparison["claude_pct"]
+    )
+    category_comparison["total_pct"] = (
+        category_comparison["claude_pct"] + category_comparison["api_pct"]
+    )
+
+    # Get top 8 categories by total usage
+    top_categories = category_comparison.nlargest(8, "total_pct").sort_values(
+        "total_pct", ascending=True
+    )
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(12, 8))
+
+    y_pos = np.arange(len(top_categories))
+    bar_height = 0.35
+
+    # Create side-by-side bars
+    ax.barh(
+        y_pos - bar_height / 2,
+        top_categories["claude_pct"],
+        bar_height,
+        label="Claude.ai",
+        color=COLOR_CYCLE[2],
+        alpha=0.8,
+    )
+    ax.barh(
+        y_pos + bar_height / 2,
+        top_categories["api_pct"],
+        bar_height,
+        label="1P API",
+        color=COLOR_CYCLE[0],
+        alpha=0.8,
+    )
+
+    # Add value labels with difference percentages
+    for i, (idx, row) in enumerate(top_categories.iterrows()):
+        # Claude.ai label
+        if row["claude_pct"] > 0.1:
+            ax.text(
+                row["claude_pct"] + 0.2,
+                i - bar_height / 2,
+                f"{row['claude_pct']:.0f}%",
+                va="center",
+                fontsize=9,
+            )
+
+        # 1P API label with difference
+        if row["api_pct"] > 0.1:
+            ax.text(
+                row["api_pct"] + 0.2,
+                i + bar_height / 2,
+                f"{row['api_pct']:.0f}%",
+                va="center",
+                fontsize=9,
+                color=COLOR_CYCLE[0] if row["difference"] > 0 else COLOR_CYCLE[2],
+            )
+
+    # Clean up category labels
+    labels = []
+    for cat in top_categories["category"]:
+        # Remove "Occupations" suffix and wrap long names
+        clean_cat = cat.replace(" Occupations", "").replace(", and ", " & ")
+        wrapped = "\n".join(wrap(clean_cat, 40))
+        labels.append(wrapped)
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(labels, fontsize=10)
+
+    ax.set_xlabel("Percentage of usage", fontsize=12)
+    ax.set_title(
+        "Usage shares across top occupational categories: Claude.ai vs 1P API",
+        fontsize=14,
+        fontweight="bold",
+        pad=20,
+    )
+    ax.legend(loc="lower right", fontsize=11)
+    ax.grid(True, alpha=0.3, axis="x")
+    ax.set_axisbelow(True)
+
+    # Remove top and right spines
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "platform_occupational_comparison.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def create_platform_lorenz_curves(api_df, cai_df, output_dir):
+    """
+    Create Lorenz curves showing task usage concentration by platform.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+
+    def gini_coefficient(values):
+        """Calculate Gini coefficient for a series of values."""
+        sorted_values = np.sort(values)
+        n = len(sorted_values)
+        cumulative = np.cumsum(sorted_values)
+        gini = (2 * np.sum(np.arange(1, n + 1) * sorted_values)) / (
+            n * cumulative[-1]
+        ) - (n + 1) / n
+        return gini
+
+    def get_task_usage_data(df, platform_name):
+        # Get ONET task percentage data (global level only)
+        onet_data = df[
+            (df["facet"] == "onet_task")
+            & (df["geo_id"] == "GLOBAL")
+            & (df["variable"] == "onet_task_pct")
+        ].copy()
+
+        # Filter out none and not_classified
+        onet_data = onet_data[
+            ~onet_data["cluster_name"].isin(["none", "not_classified"])
+        ]
+
+        # Use the percentage values directly
+        onet_data["percentage"] = onet_data["value"]
+
+        return onet_data[["cluster_name", "percentage"]].copy()
+
+    api_tasks = get_task_usage_data(api_df, "1P API")
+    claude_tasks = get_task_usage_data(cai_df, "Claude.ai")
+
+    # Sort by percentage for each platform
+    api_tasks = api_tasks.sort_values("percentage")
+    claude_tasks = claude_tasks.sort_values("percentage")
+
+    # Calculate cumulative percentages of usage
+    api_cumulative = np.cumsum(api_tasks["percentage"])
+    claude_cumulative = np.cumsum(claude_tasks["percentage"])
+
+    # Calculate cumulative percentage of tasks
+    api_task_cumulative = np.arange(1, len(api_tasks) + 1) / len(api_tasks) * 100
+    claude_task_cumulative = (
+        np.arange(1, len(claude_tasks) + 1) / len(claude_tasks) * 100
+    )
+
+    # Interpolate to ensure curves reach 100%
+    # Add final points to reach (100, 100)
+    api_cumulative = np.append(api_cumulative, 100)
+    claude_cumulative = np.append(claude_cumulative, 100)
+    api_task_cumulative = np.append(api_task_cumulative, 100)
+    claude_task_cumulative = np.append(claude_task_cumulative, 100)
+
+    # Calculate Gini coefficients
+    api_gini = gini_coefficient(api_tasks["percentage"].values)
+    claude_gini = gini_coefficient(claude_tasks["percentage"].values)
+
+    # Create panel figure
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+
+    # LEFT PANEL: Lorenz Curves
+    # Plot Lorenz curves
+    ax1.plot(
+        api_task_cumulative,
+        api_cumulative,
+        color=COLOR_CYCLE[1],
+        linewidth=2.5,
+        label=f"1P API (Gini = {api_gini:.3f})",
+    )
+
+    ax1.plot(
+        claude_task_cumulative,
+        claude_cumulative,
+        color=COLOR_CYCLE[0],
+        linewidth=2.5,
+        label=f"Claude.ai (Gini = {claude_gini:.3f})",
+    )
+
+    # Add perfect equality line (diagonal)
+    ax1.plot(
+        [0, 100],
+        [0, 100],
+        "k--",
+        linewidth=1.5,
+        alpha=0.7,
+        label="Perfect Equality",
+    )
+
+    # Calculate 80th percentile values
+    api_80th_usage = np.interp(80, api_task_cumulative, api_cumulative)
+    claude_80th_usage = np.interp(80, claude_task_cumulative, claude_cumulative)
+
+    # Add markers at 80th percentile
+    ax1.scatter(
+        80,
+        api_80th_usage,
+        alpha=0.5,
+        s=100,
+        color=COLOR_CYCLE[1],
+        edgecolors="white",
+        linewidth=1,
+        zorder=5,
+    )
+    ax1.scatter(
+        80,
+        claude_80th_usage,
+        alpha=0.5,
+        s=100,
+        color=COLOR_CYCLE[0],
+        edgecolors="white",
+        linewidth=1,
+        zorder=5,
+    )
+
+    # Add annotations
+    ax1.text(
+        82,
+        api_80th_usage - 2,
+        f"{api_80th_usage:.1f}% of usage",
+        ha="left",
+        va="center",
+        fontsize=10,
+        color=COLOR_CYCLE[1],
+    )
+
+    ax1.text(
+        78.5,
+        claude_80th_usage + 1,
+        f"{claude_80th_usage:.1f}% of usage",
+        ha="right",
+        va="center",
+        fontsize=10,
+        color=COLOR_CYCLE[0],
+    )
+
+    # Add text box
+    ax1.text(
+        0.05,
+        0.95,
+        f"The bottom 80% of tasks account for:\n• 1P API: {api_80th_usage:.1f}% of usage\n• Claude.ai: {claude_80th_usage:.1f}% of usage",
+        transform=ax1.transAxes,
+        va="top",
+        ha="left",
+        bbox=dict(
+            boxstyle="round,pad=0.3",
+            facecolor="white",
+            alpha=0.8,
+            edgecolor="black",
+            linewidth=1,
+        ),
+        fontsize=10,
+    )
+
+    # Styling for Lorenz curves
+    ax1.set_xlabel("Cumulative percentage of tasks", fontsize=12)
+    ax1.set_ylabel("Cumulative percentage of usage", fontsize=12)
+    ax1.set_title("Lorenz curves", fontsize=14, fontweight="bold", pad=20)
+    ax1.set_xlim(0, 100)
+    ax1.set_ylim(0, 100)
+    ax1.grid(True, alpha=0.3, linestyle="--")
+    ax1.set_axisbelow(True)
+    ax1.legend(loc=(0.05, 0.65), fontsize=11, frameon=True, facecolor="white")
+    ax1.spines["top"].set_visible(False)
+    ax1.spines["right"].set_visible(False)
+
+    # RIGHT PANEL: Zipf's Law Analysis
+    min_share = 0.1
+
+    # Filter for minimum share
+    api_filtered = api_tasks[api_tasks["percentage"] > min_share]["percentage"].copy()
+    claude_filtered = claude_tasks[claude_tasks["percentage"] > min_share][
+        "percentage"
+    ].copy()
+
+    # Calculate ranks and log transforms
+    ln_rank_api = np.log(api_filtered.rank(ascending=False))
+    ln_share_api = np.log(api_filtered)
+
+    ln_rank_claude = np.log(claude_filtered.rank(ascending=False))
+    ln_share_claude = np.log(claude_filtered)
+
+    # Fit regressions
+    api_model = sm.OLS(ln_rank_api, sm.add_constant(ln_share_api)).fit()
+    api_slope = api_model.params.iloc[1]
+    api_intercept = api_model.params.iloc[0]
+
+    claude_model = sm.OLS(ln_rank_claude, sm.add_constant(ln_share_claude)).fit()
+    claude_slope = claude_model.params.iloc[1]
+    claude_intercept = claude_model.params.iloc[0]
+
+    # Plot scatter points
+    ax2.scatter(
+        ln_share_api,
+        ln_rank_api,
+        alpha=0.5,
+        s=100,
+        color=COLOR_CYCLE[1],
+        label=f"1P API: y = {api_slope:.2f}x + {api_intercept:.2f}",
+    )
+
+    ax2.scatter(
+        ln_share_claude,
+        ln_rank_claude,
+        alpha=0.5,
+        s=100,
+        color=COLOR_CYCLE[0],
+        label=f"Claude.ai: y = {claude_slope:.2f}x + {claude_intercept:.2f}",
+    )
+
+    # Add Zipf's law reference line (slope = -1)
+    x_range = np.linspace(
+        min(ln_share_api.min(), ln_share_claude.min()),
+        max(ln_share_api.max(), ln_share_claude.max()),
+        100,
+    )
+    avg_intercept = (api_intercept + claude_intercept) / 2
+    y_line = -1 * x_range + avg_intercept
+
+    ax2.plot(
+        x_range,
+        y_line,
+        color="black",
+        linestyle="--",
+        linewidth=2,
+        label=f"Zipf's Law: y = -1.00x + {avg_intercept:.2f}",
+        zorder=0,
+    )
+
+    # Styling for Zipf's law plot
+    ax2.set_xlabel("ln(Share of usage)", fontsize=12)
+    ax2.set_ylabel("ln(Rank by usage)", fontsize=12)
+    ax2.set_title(
+        "Task rank versus usage share", fontsize=14, fontweight="bold", pad=20
+    )
+    ax2.grid(True, alpha=0.3, linestyle="--")
+    ax2.set_axisbelow(True)
+    ax2.legend(fontsize=11)
+    ax2.spines["top"].set_visible(False)
+    ax2.spines["right"].set_visible(False)
+
+    # Overall title
+    fig.suptitle(
+        "Lorenz curves and power law analysis across tasks: 1P API vs Claude.ai",
+        fontsize=16,
+        fontweight="bold",
+        y=0.95,
+        color="#B86046",
+    )
+
+    plt.tight_layout()
+    plt.subplots_adjust(top=0.85)  # More room for suptitle
+
+    # Save plot
+    output_path = Path(output_dir) / "platform_lorenz_zipf_panel.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def create_collaboration_alluvial(api_df, cai_df, output_dir):
+    """
+    Create alluvial diagram showing collaboration pattern flows between platforms.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+
+    def get_collaboration_data(df, platform_name):
+        # Get collaboration facet data (global level only)
+        collab_data = df[
+            (df["facet"] == "collaboration")
+            & (df["geo_id"] == "GLOBAL")
+            & (df["variable"] == "collaboration_pct")
+        ].copy()
+
+        # Use cluster_name directly as the collaboration pattern
+        collab_data["pattern"] = collab_data["cluster_name"]
+
+        # Filter out not_classified
+        collab_data = collab_data[collab_data["pattern"] != "not_classified"]
+
+        # Use the percentage values directly
+        result = collab_data[["pattern", "value"]].copy()
+        result.columns = ["pattern", "percentage"]
+        result["platform"] = platform_name
+
+        return result
+
+    api_collab = get_collaboration_data(api_df, "1P API")
+    claude_collab = get_collaboration_data(cai_df, "Claude.ai")
+
+    # Combine collaboration data
+    collab_df = pd.concat([claude_collab, api_collab], ignore_index=True)
+
+    # Define categories
+    augmentation_types = ["learning", "task iteration", "validation"]
+    automation_types = ["directive", "feedback loop"]
+
+    # Colors matching the original
+    pattern_colors = {
+        "validation": "#2c3e67",
+        "task iteration": "#4f76c7",
+        "learning": "#79a7e0",
+        "feedback loop": "#614980",
+        "directive": "#8e6bb1",
+    }
+
+    # Extract flows
+    flows_claude = {}
+    flows_api = {}
+
+    for pattern in augmentation_types + automation_types:
+        claude_mask = (collab_df["pattern"] == pattern) & (
+            collab_df["platform"] == "Claude.ai"
+        )
+        if claude_mask.any():
+            flows_claude[pattern] = collab_df.loc[claude_mask, "percentage"].values[0]
+
+        api_mask = (collab_df["pattern"] == pattern) & (
+            collab_df["platform"] == "1P API"
+        )
+        if api_mask.any():
+            flows_api[pattern] = collab_df.loc[api_mask, "percentage"].values[0]
+
+    # Create figure with subplots
+    fig = make_subplots(
+        rows=2,
+        cols=1,
+        row_heights=[0.5, 0.5],
+        vertical_spacing=0.15,
+        subplot_titles=("<b>Augmentation Patterns</b>", "<b>Automation Patterns</b>"),
+    )
+
+    # Update subplot title colors and font
+    for annotation in fig.layout.annotations:
+        annotation.update(font=dict(color="#B86046", size=14, family="Styrene B LC"))
+
+    def create_alluvial_traces(patterns, row):
+        """Create traces for alluvial diagram"""
+        # Sort by size on Claude.ai side
+        patterns_sorted = sorted(
+            [p for p in patterns if p in flows_claude],
+            key=lambda p: flows_claude.get(p, 0),
+            reverse=True,
+        )
+
+        # Calculate total heights first to determine centering
+        total_claude = sum(
+            flows_claude.get(p, 0) for p in patterns if p in flows_claude
+        )
+        total_api = sum(flows_api.get(p, 0) for p in patterns if p in flows_api)
+        gap_count = max(
+            len([p for p in patterns if p in flows_claude and flows_claude[p] > 0]) - 1,
+            0,
+        )
+        gap_count_api = max(
+            len([p for p in patterns if p in flows_api and flows_api[p] > 0]) - 1, 0
+        )
+
+        total_height_claude = total_claude + (gap_count * 2)
+        total_height_api = total_api + (gap_count_api * 2)
+
+        # Calculate offset to center the smaller side
+        offset_claude = 0
+        offset_api = 0
+        if total_height_claude < total_height_api:
+            offset_claude = (total_height_api - total_height_claude) / 2
+        else:
+            offset_api = (total_height_claude - total_height_api) / 2
+
+        # Calculate positions for Claude.ai (left side)
+        y_pos_claude = offset_claude
+        claude_positions = {}
+        for pattern in patterns_sorted:
+            if pattern in flows_claude and flows_claude[pattern] > 0:
+                height = flows_claude[pattern]
+                claude_positions[pattern] = {
+                    "bottom": y_pos_claude,
+                    "top": y_pos_claude + height,
+                    "center": y_pos_claude + height / 2,
+                }
+                y_pos_claude += height + 2  # Add gap
+
+        # Calculate positions for 1P API (right side)
+        patterns_sorted_api = sorted(
+            [p for p in patterns if p in flows_api],
+            key=lambda p: flows_api.get(p, 0),
+            reverse=True,
+        )
+        y_pos_api = offset_api
+        api_positions = {}
+        for pattern in patterns_sorted_api:
+            if pattern in flows_api and flows_api[pattern] > 0:
+                height = flows_api[pattern]
+                api_positions[pattern] = {
+                    "bottom": y_pos_api,
+                    "top": y_pos_api + height,
+                    "center": y_pos_api + height / 2,
+                }
+                y_pos_api += height + 2  # Add gap
+
+        # Create shapes for flows
+        shapes = []
+        for pattern in patterns:
+            if pattern in claude_positions and pattern in api_positions:
+                # Create a quadrilateral connecting the two sides
+                x_left = 0.2
+                x_right = 0.8
+
+                claude_bottom = claude_positions[pattern]["bottom"]
+                claude_top = claude_positions[pattern]["top"]
+                api_bottom = api_positions[pattern]["bottom"]
+                api_top = api_positions[pattern]["top"]
+
+                # Create path for the flow
+                path = f"M {x_left} {claude_bottom} L {x_left} {claude_top} L {x_right} {api_top} L {x_right} {api_bottom} Z"
+
+                hex_color = pattern_colors[pattern]
+                r = int(hex_color[1:3], 16)
+                g = int(hex_color[3:5], 16)
+                b = int(hex_color[5:7], 16)
+
+                shapes.append(
+                    dict(
+                        type="path",
+                        path=path,
+                        fillcolor=f"rgba({r},{g},{b},0.5)",
+                        line=dict(color=f"rgba({r},{g},{b},1)", width=1),
+                    )
+                )
+
+        # Create text annotations
+        annotations = []
+
+        # Claude.ai labels
+        for pattern in patterns_sorted:
+            if pattern in claude_positions:
+                annotations.append(
+                    dict(
+                        x=x_left - 0.02,
+                        y=claude_positions[pattern]["center"],
+                        text=f"{pattern.replace('_', ' ').title()}<br>{flows_claude[pattern]:.1f}%",
+                        showarrow=False,
+                        xanchor="right",
+                        yanchor="middle",
+                        font=dict(size=10),
+                    )
+                )
+
+        # 1P API labels
+        for pattern in patterns_sorted_api:
+            if pattern in api_positions:
+                annotations.append(
+                    dict(
+                        x=x_right + 0.02,
+                        y=api_positions[pattern]["center"],
+                        text=f"{pattern.replace('_', ' ').title()}<br>{flows_api[pattern]:.1f}%",
+                        showarrow=False,
+                        xanchor="left",
+                        yanchor="middle",
+                        font=dict(size=10),
+                    )
+                )
+
+        # Platform labels
+        annotations.extend(
+            [
+                dict(
+                    x=x_left,
+                    y=max(y_pos_claude, y_pos_api) + 5,
+                    text="Claude.ai",
+                    showarrow=False,
+                    xanchor="center",
+                    font=dict(size=14, color="black"),
+                ),
+                dict(
+                    x=x_right,
+                    y=max(y_pos_claude, y_pos_api) + 5,
+                    text="1P API",
+                    showarrow=False,
+                    xanchor="center",
+                    font=dict(size=14, color="black"),
+                ),
+            ]
+        )
+
+        return shapes, annotations, max(y_pos_claude, y_pos_api)
+
+    # Create augmentation diagram
+    aug_shapes, aug_annotations, aug_height = create_alluvial_traces(
+        augmentation_types, 1
+    )
+
+    # Create automation diagram
+    auto_shapes, auto_annotations, auto_height = create_alluvial_traces(
+        automation_types, 2
+    )
+
+    # Add invisible traces to create subplots
+    fig.add_trace(
+        go.Scatter(x=[0], y=[0], mode="markers", marker=dict(size=0)), row=1, col=1
+    )
+    fig.add_trace(
+        go.Scatter(x=[0], y=[0], mode="markers", marker=dict(size=0)), row=2, col=1
+    )
+
+    # Update layout with shapes and annotations
+    fig.update_layout(
+        title=dict(
+            text="<b>Collaboration Modes: Claude.ai Conversations vs 1P API Transcripts</b>",
+            font=dict(size=16, family="Styrene B LC", color="#B86046"),
+            x=0.5,
+            xanchor="center",
+        ),
+        height=800,
+        width=1200,
+        paper_bgcolor="white",
+        plot_bgcolor="white",
+        showlegend=False,
+    )
+
+    # Ensure white background for both subplots
+    fig.update_xaxes(showgrid=False, zeroline=False, showticklabels=False, row=1, col=1)
+    fig.update_xaxes(showgrid=False, zeroline=False, showticklabels=False, row=2, col=1)
+    fig.update_yaxes(showgrid=False, zeroline=False, showticklabels=False, row=1, col=1)
+    fig.update_yaxes(showgrid=False, zeroline=False, showticklabels=False, row=2, col=1)
+
+    # Add shapes and annotations to each subplot
+    for shape in aug_shapes:
+        fig.add_shape(shape, row=1, col=1)
+    for shape in auto_shapes:
+        fig.add_shape(shape, row=2, col=1)
+
+    for ann in aug_annotations:
+        fig.add_annotation(ann, row=1, col=1)
+    for ann in auto_annotations:
+        fig.add_annotation(ann, row=2, col=1)
+
+    # Set axis ranges and ensure white background
+    fig.update_xaxes(
+        range=[0, 1],
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        row=1,
+        col=1,
+    )
+    fig.update_xaxes(
+        range=[0, 1],
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        row=2,
+        col=1,
+    )
+
+    fig.update_yaxes(
+        range=[0, aug_height + 10],
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        row=1,
+        col=1,
+    )
+    fig.update_yaxes(
+        range=[0, auto_height + 10],
+        showgrid=False,
+        zeroline=False,
+        showticklabels=False,
+        row=2,
+        col=1,
+    )
+
+    # Save plot
+    output_path = Path(output_dir) / "collaboration_alluvial.png"
+    fig.write_image(str(output_path), width=1200, height=800, scale=2)
+    fig.show()
+    return str(output_path)
+
+
+def get_collaboration_shares(df):
+    """
+    Extract collaboration mode shares for each ONET task from intersection data.
+
+    Args:
+        df: Preprocessed data DataFrame
+
+    Returns:
+        dict: {task_name: {mode: percentage}}
+    """
+    # Filter to GLOBAL data only and use pre-calculated percentages
+    collab_data = df[
+        (df["geo_id"] == "GLOBAL")
+        & (df["facet"] == "onet_task::collaboration")
+        & (df["variable"] == "onet_task_collaboration_pct")
+    ].copy()
+
+    # Split the cluster_name into task and collaboration mode
+    collab_data[["task", "mode"]] = collab_data["cluster_name"].str.rsplit(
+        "::", n=1, expand=True
+    )
+
+    # Filter out 'none' and 'not_classified' modes
+    collab_data = collab_data[~collab_data["mode"].isin(["none", "not_classified"])]
+
+    # Use pre-calculated percentages directly
+    collaboration_modes = [
+        "directive",
+        "feedback loop",
+        "learning",
+        "task iteration",
+        "validation",
+    ]
+    result = {}
+
+    for _, row in collab_data.iterrows():
+        task = row["task"]
+        mode = row["mode"]
+
+        if mode in collaboration_modes:
+            if task not in result:
+                result[task] = {}
+            result[task][mode] = float(row["value"])
+
+    return result
+
+
+def create_automation_augmentation_panel(api_df, cai_df, output_dir):
+    """
+    Create combined panel figure showing automation vs augmentation for both platforms.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Create figure with subplots
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+
+    def create_automation_augmentation_subplot(df, ax, title, platform_name):
+        """Helper function to create one automation vs augmentation subplot"""
+        # Get collaboration shares for each task
+        collab_shares = get_collaboration_shares(df)
+
+        # Get task usage counts for bubble sizing
+        df_global = df[df["geo_id"] == "GLOBAL"]
+        task_counts = (
+            df_global[
+                (df_global["facet"] == "onet_task")
+                & (df_global["variable"] == "onet_task_count")
+                & (~df_global["cluster_name"].isin(["none", "not_classified"]))
+            ]
+            .set_index("cluster_name")["value"]
+            .to_dict()
+        )
+
+        # Prepare data for plotting
+        tasks = []
+        automation_scores = []
+        augmentation_scores = []
+        bubble_sizes = []
+
+        for task_name, shares in collab_shares.items():
+            if task_name in task_counts:
+                # Calculate automation score (directive + feedback loop)
+                automation = shares.get("directive", 0) + shares.get("feedback loop", 0)
+
+                # Calculate augmentation score (learning + task iteration + validation)
+                augmentation = (
+                    shares.get("learning", 0)
+                    + shares.get("task iteration", 0)
+                    + shares.get("validation", 0)
+                )
+
+                # Only include tasks with some collaboration data
+                if automation + augmentation > 0:
+                    tasks.append(task_name)
+                    automation_scores.append(automation)
+                    augmentation_scores.append(augmentation)
+                    bubble_sizes.append(task_counts[task_name])
+
+        # Convert to numpy arrays for plotting
+        automation_scores = np.array(automation_scores)
+        augmentation_scores = np.array(augmentation_scores)
+        bubble_sizes = np.array(bubble_sizes)
+
+        # Scale bubble sizes
+        bubble_sizes_scaled = (bubble_sizes / bubble_sizes.max()) * 800 + 40
+
+        # Color points based on whether automation or augmentation dominates
+        colors = []
+        for auto, aug in zip(automation_scores, augmentation_scores, strict=True):
+            if auto > aug:
+                colors.append("#8e6bb1")  # Automation dominant
+            else:
+                colors.append("#4f76c7")  # Augmentation dominant
+
+        # Create scatter plot
+        ax.scatter(
+            automation_scores,
+            augmentation_scores,
+            s=bubble_sizes_scaled,
+            c=colors,
+            alpha=0.7,
+            edgecolors="black",
+            linewidth=0.5,
+        )
+
+        # Add diagonal line (automation = augmentation)
+        max_val = max(automation_scores.max(), augmentation_scores.max())
+        ax.plot([0, max_val], [0, max_val], "--", color="gray", alpha=0.5, linewidth=2)
+
+        # Labels and formatting (increased font sizes)
+        ax.set_xlabel("Automation Share (%)", fontsize=14)
+        ax.set_ylabel(
+            "Augmentation Score (%)",
+            fontsize=14,
+        )
+        ax.set_title(title, fontsize=14, fontweight="bold", pad=15)
+
+        # Calculate percentages for legend
+        automation_dominant_count = sum(
+            1
+            for auto, aug in zip(automation_scores, augmentation_scores, strict=True)
+            if auto > aug
+        )
+        augmentation_dominant_count = len(automation_scores) - automation_dominant_count
+        total_tasks = len(automation_scores)
+
+        automation_pct = (automation_dominant_count / total_tasks) * 100
+        augmentation_pct = (augmentation_dominant_count / total_tasks) * 100
+
+        # Add legend with percentages centered at top
+        automation_patch = plt.scatter(
+            [],
+            [],
+            c="#8e6bb1",
+            alpha=0.7,
+            s=100,
+            label=f"Automation dominant ({automation_pct:.1f}% of Tasks)",
+        )
+        augmentation_patch = plt.scatter(
+            [],
+            [],
+            c="#4f76c7",
+            alpha=0.7,
+            s=100,
+            label=f"Augmentation dominant ({augmentation_pct:.1f}% of Tasks)",
+        )
+        ax.legend(
+            handles=[automation_patch, augmentation_patch],
+            loc="upper center",
+            bbox_to_anchor=(0.5, 0.95),
+            fontsize=12,
+            frameon=True,
+            facecolor="white",
+        )
+
+        # Grid and styling
+        ax.grid(True, alpha=0.3)
+        ax.set_axisbelow(True)
+        ax.tick_params(axis="both", which="major", labelsize=12)
+
+        return len(tasks), automation_pct, augmentation_pct
+
+    # Create API subplot
+    create_automation_augmentation_subplot(api_df, ax1, "1P API", "1P API")
+
+    # Create Claude.ai subplot
+    create_automation_augmentation_subplot(cai_df, ax2, "Claude.ai", "Claude.ai")
+
+    # Add overall title
+    fig.suptitle(
+        "Automation and augmentation dominance across tasks: Claude.ai vs. 1P API",
+        fontsize=16,
+        fontweight="bold",
+        y=0.95,
+        color="#B86046",
+    )
+
+    plt.tight_layout()
+    plt.subplots_adjust(top=0.85)  # More room for suptitle
+
+    # Save plot
+    output_path = Path(output_dir) / "automation_vs_augmentation_panel.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def extract_token_metrics_from_intersections(df):
+    """
+    Extract token metrics from preprocessed intersection data.
+
+    Args:
+        df: Preprocessed dataframe with intersection facets
+
+    Returns:
+        DataFrame with token metrics for analysis
+    """
+    # Extract data using new variable names from mean value intersections
+    cost_data = df[
+        (df.facet == "onet_task::cost") & (df.variable == "cost_index")
+    ].copy()
+    cost_data["base_task"] = cost_data["cluster_name"].str.replace("::index", "")
+    onet_cost = cost_data.set_index("base_task")["value"].copy()
+
+    prompt_data = df[
+        (df.facet == "onet_task::prompt_tokens")
+        & (df.variable == "prompt_tokens_index")
+    ].copy()
+    prompt_data["base_task"] = prompt_data["cluster_name"].str.replace("::index", "")
+    onet_prompt = prompt_data.set_index("base_task")["value"].copy()
+
+    completion_data = df[
+        (df.facet == "onet_task::completion_tokens")
+        & (df.variable == "completion_tokens_index")
+    ].copy()
+    completion_data["base_task"] = completion_data["cluster_name"].str.replace(
+        "::index", ""
+    )
+    onet_completion = completion_data.set_index("base_task")["value"].copy()
+
+    # Get API call counts for bubble sizing and WLS weights
+    api_records_data = df[
+        (df.facet == "onet_task::prompt_tokens")
+        & (df.variable == "prompt_tokens_count")
+    ].copy()
+    api_records_data["base_task"] = api_records_data["cluster_name"].str.replace(
+        "::count", ""
+    )
+    onet_api_records = api_records_data.set_index("base_task")["value"].copy()
+
+    # Create metrics DataFrame - values are already re-indexed during preprocessing
+    metrics = pd.DataFrame(
+        {
+            "cluster_name": onet_cost.index,
+            "cost_per_record": onet_cost,  # Already indexed (1.0 = average)
+            "avg_prompt_tokens": onet_prompt.reindex(
+                onet_cost.index
+            ),  # Already indexed
+            "avg_completion_tokens": onet_completion.reindex(
+                onet_cost.index
+            ),  # Already indexed
+        }
+    )
+
+    # Get task usage percentages
+    usage_pct_data = df[
+        (df.facet == "onet_task") & (df.variable == "onet_task_pct")
+    ].copy()
+    usage_pct_data["base_task"] = usage_pct_data["cluster_name"]
+    onet_usage_pct = usage_pct_data.set_index("base_task")["value"].copy()
+
+    # Add API records and usage percentages
+    metrics["api_records"] = onet_api_records.reindex(onet_cost.index)
+    metrics["usage_pct"] = onet_usage_pct.reindex(onet_cost.index)
+
+    # Calculate derived metrics
+    metrics["output_input_ratio"] = (
+        metrics["avg_completion_tokens"] / metrics["avg_prompt_tokens"]
+    )
+    metrics["total_tokens"] = (
+        metrics["avg_prompt_tokens"] + metrics["avg_completion_tokens"]
+    )
+
+    return metrics
+
+
+def add_occupational_categories_to_metrics(
+    task_metrics, task_statements, soc_structure
+):
+    """
+    Add occupational categories to task metrics based on ONET mappings.
+
+    Args:
+        task_metrics: DataFrame with task metrics
+        task_statements: ONET task statements DataFrame
+        soc_structure: SOC structure DataFrame
+
+    Returns:
+        DataFrame with occupational categories added
+    """
+    # Standardize task descriptions for matching
+    task_statements["task_standardized"] = (
+        task_statements["Task"].str.strip().str.lower()
+    )
+    task_metrics["cluster_name_standardized"] = (
+        task_metrics["cluster_name"].str.strip().str.lower()
+    )
+
+    # Create mapping from standardized task to major group
+    task_to_major_group = {}
+    for _, row in task_statements.iterrows():
+        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
+            std_task = row["task_standardized"]
+            major_group = str(int(row["soc_major_group"]))
+            task_to_major_group[std_task] = major_group
+
+    # Map cluster names to major groups
+    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
+        task_to_major_group
+    )
+
+    # Get major occupational groups from SOC structure
+    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
+    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
+    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
+
+    # Create a clean mapping from major group code to title
+    major_group_mapping = (
+        major_groups[["soc_major", "title"]]
+        .drop_duplicates()
+        .set_index("soc_major")["title"]
+        .to_dict()
+    )
+
+    # Map major group codes to titles
+    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
+        major_group_mapping
+    )
+
+    # Remove unmapped/not classified tasks from analysis
+    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
+
+    # Find top 6 categories by usage share (API calls) and group others as "All Other"
+    category_usage = (
+        task_metrics.groupby("occupational_category")["api_records"]
+        .sum()
+        .sort_values(ascending=False)
+    )
+    top_6_categories = list(category_usage.head(6).index)
+
+    # Group smaller categories as "All Other"
+    task_metrics["occupational_category"] = task_metrics["occupational_category"].apply(
+        lambda x: x if x in top_6_categories else "All Other"
+    )
+
+    return task_metrics
+
+
+def create_token_output_bar_chart(df, output_dir):
+    """
+    Create bar chart showing average output (completion) tokens by occupational category.
+
+    Args:
+        df: Preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Load ONET mappings for occupational categories
+    task_statements, soc_structure = load_onet_mappings()
+
+    # Use preprocessed intersection data
+    task_metrics = extract_token_metrics_from_intersections(df)
+
+    # Add occupational categories
+    task_metrics = add_occupational_categories_to_metrics(
+        task_metrics, task_statements, soc_structure
+    )
+
+    # Calculate average output tokens by occupational category
+    category_stats = (
+        task_metrics.groupby("occupational_category")
+        .agg(
+            {
+                "avg_completion_tokens": "mean",  # Average across tasks
+                "api_records": "sum",  # Total API calls for ranking
+            }
+        )
+        .reset_index()
+    )
+
+    # Find top 6 categories by total API calls
+    top_6_categories = category_stats.nlargest(6, "api_records")[
+        "occupational_category"
+    ].tolist()
+
+    # Group smaller categories as "All Other"
+    def categorize(cat):
+        return cat if cat in top_6_categories else "All Other"
+
+    task_metrics["category_group"] = task_metrics["occupational_category"].apply(
+        categorize
+    )
+
+    # Recalculate stats with grouped categories
+    final_stats = (
+        task_metrics.groupby("category_group")
+        .agg(
+            {
+                "avg_completion_tokens": "mean",  # Average output tokens across tasks
+                "api_records": "sum",  # Total usage for reference
+            }
+        )
+        .reset_index()
+    )
+
+    # Sort by output tokens (descending)
+    final_stats = final_stats.sort_values("avg_completion_tokens", ascending=True)
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(12, 8))
+
+    # Create horizontal bar chart
+    y_pos = np.arange(len(final_stats))
+    colors = [COLOR_CYCLE[i % len(COLOR_CYCLE)] for i in range(len(final_stats))]
+
+    ax.barh(
+        y_pos,
+        final_stats["avg_completion_tokens"],
+        color=colors,
+        alpha=0.8,
+        edgecolor="#333333",
+        linewidth=0.5,
+    )
+
+    # Add value labels
+    for i, (idx, row) in enumerate(final_stats.iterrows()):
+        ax.text(
+            row["avg_completion_tokens"] + 0.02,
+            i,
+            f"{row['avg_completion_tokens']:.2f}",
+            va="center",
+            fontsize=11,
+            fontweight="bold",
+        )
+
+    # Clean up category labels
+    labels = []
+    for cat in final_stats["category_group"]:
+        clean_cat = cat.replace(" Occupations", "").replace(", and ", " & ")
+        labels.append(clean_cat)
+
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(labels, fontsize=10)
+
+    # Formatting
+    ax.set_xlabel(
+        "Average output token index for observed tasks in a given category",
+        fontsize=12,
+    )
+    ax.set_title(
+        "Average output token index across leading occupational categories",
+        fontsize=14,
+        fontweight="bold",
+        pad=20,
+    )
+
+    # Grid and styling
+    ax.grid(True, alpha=0.3, axis="x")
+    ax.set_axisbelow(True)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.tick_params(axis="x", which="major", labelsize=11)
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "token_output_bar_chart.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def create_completion_vs_input_tokens_scatter(df, output_dir):
+    """
+    Create scatter plot of ln(completion tokens) vs ln(input tokens) by occupational category.
+
+    Args:
+        df: Preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Use preprocessed intersection data
+    task_metrics = extract_token_metrics_from_intersections(df)
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(12, 8))
+
+    # Transform to natural log
+    ln_input = np.log(task_metrics["avg_prompt_tokens"])
+    ln_output = np.log(task_metrics["avg_completion_tokens"])
+
+    # Load ONET mappings for occupational categories
+    task_statements, soc_structure = load_onet_mappings()
+
+    # Add occupational categories
+    # Standardize task descriptions for matching
+    task_statements["task_standardized"] = (
+        task_statements["Task"].str.strip().str.lower()
+    )
+    task_metrics["cluster_name_standardized"] = (
+        task_metrics.index.str.strip().str.lower()
+    )
+
+    # Create mapping from standardized task to major group
+    task_to_major_group = {}
+    for _, row in task_statements.iterrows():
+        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
+            std_task = row["task_standardized"]
+            major_group = str(int(row["soc_major_group"]))[:2]
+            task_to_major_group[std_task] = major_group
+
+    # Map cluster names to major groups
+    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
+        task_to_major_group
+    )
+
+    # Get major occupational groups from SOC structure
+    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
+    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
+    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
+
+    # Create mapping from major group code to title
+    major_group_mapping = (
+        major_groups[["soc_major", "title"]]
+        .drop_duplicates()
+        .set_index("soc_major")["title"]
+        .to_dict()
+    )
+
+    # Map major group codes to titles
+    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
+        major_group_mapping
+    )
+
+    # Remove unmapped tasks
+    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
+
+    # Find top 6 categories by total API calls and group others as "All Other"
+    category_usage = (
+        task_metrics.groupby("occupational_category")["api_records"]
+        .sum()
+        .sort_values(ascending=False)
+    )
+    top_6_categories = list(category_usage.head(6).index)
+
+    # Group smaller categories as "All Other"
+    task_metrics["occupational_category"] = task_metrics["occupational_category"].apply(
+        lambda x: x if x in top_6_categories else "All Other"
+    )
+
+    # Transform to natural log
+    ln_input = np.log(task_metrics["avg_prompt_tokens"])
+    ln_output = np.log(task_metrics["avg_completion_tokens"])
+
+    # Create scatter plot with same color scheme as bar chart
+    # Use exact same logic as token output bar chart for consistent colors
+    category_stats = (
+        task_metrics.groupby("occupational_category")
+        .agg(
+            {
+                "avg_completion_tokens": "mean",
+                "api_records": "sum",
+            }
+        )
+        .reset_index()
+    )
+
+    # Find top 6 categories by total API calls
+    top_6_categories = category_stats.nlargest(6, "api_records")[
+        "occupational_category"
+    ].tolist()
+
+    # Group smaller categories as "All Other"
+    def categorize(cat):
+        return cat if cat in top_6_categories else "All Other"
+
+    task_metrics["category_group"] = task_metrics["occupational_category"].apply(
+        categorize
+    )
+
+    # Recalculate final stats with grouped categories
+    final_stats = (
+        task_metrics.groupby("category_group")
+        .agg({"avg_completion_tokens": "mean"})
+        .reset_index()
+        .sort_values("avg_completion_tokens", ascending=True)
+    )
+
+    # Use exact same color assignment as bar chart
+    categories_ordered = final_stats["category_group"].tolist()
+    category_colors = {}
+    for i, category in enumerate(categories_ordered):
+        category_colors[category] = COLOR_CYCLE[i % len(COLOR_CYCLE)]
+
+    for category in categories_ordered:
+        category_data = task_metrics[task_metrics["category_group"] == category]
+        if not category_data.empty:
+            ln_input_cat = np.log(category_data["avg_prompt_tokens"])
+            ln_output_cat = np.log(category_data["avg_completion_tokens"])
+            bubble_sizes_cat = np.sqrt(category_data["api_records"]) * 2
+
+            # Clean up category name for legend
+            clean_name = category.replace(" Occupations", "").replace(", and ", " & ")
+
+            ax.scatter(
+                ln_input_cat,
+                ln_output_cat,
+                s=bubble_sizes_cat,
+                alpha=0.8,
+                c=category_colors[category],
+                edgecolors="black",
+                linewidth=0.2,
+            )
+
+    # Create uniform legend entries
+    legend_elements = []
+    for category in categories_ordered:
+        clean_name = category.replace(" Occupations", "").replace(", and ", " & ")
+        # Get count for this category
+        category_count = len(task_metrics[task_metrics["category_group"] == category])
+        legend_elements.append(
+            plt.scatter(
+                [],
+                [],
+                s=100,
+                alpha=0.8,
+                c=category_colors[category],
+                edgecolors="black",
+                linewidth=0.2,
+                label=f"{clean_name} (N={category_count})",
+            )
+        )
+
+    # Add legend for occupational categories with uniform sizes
+    ax.legend(
+        bbox_to_anchor=(1.05, 1), loc="upper left", frameon=True, facecolor="white"
+    )
+
+    # Add line of best fit
+    model = sm.OLS(ln_output, sm.add_constant(ln_input)).fit()
+    slope = model.params.iloc[1]
+    intercept = model.params.iloc[0]
+    r_squared = model.rsquared
+
+    line_x = np.linspace(ln_input.min(), ln_input.max(), 100)
+    line_y = slope * line_x + intercept
+    ax.plot(
+        line_x,
+        line_y,
+        "k--",
+        alpha=0.7,
+        linewidth=2,
+        label=f"Best fit (R² = {r_squared:.3f}, $\\beta$ = {slope:.3f})",
+    )
+    ax.legend()
+
+    # Customize plot
+    ax.set_xlabel("ln(Input Token Index)", fontsize=12)
+    ax.set_ylabel("ln(Output Token Index)", fontsize=12)
+    ax.set_title(
+        "Output Token Index vs Input Token Index across tasks",
+        fontsize=14,
+        fontweight="bold",
+        pad=20,
+    )
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "completion_vs_input_tokens_scatter.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def create_occupational_usage_cost_scatter(df, output_dir):
+    """
+    Create aggregated scatter plot of usage share vs average cost per API call by occupational category.
+
+    Args:
+        df: Preprocessed data DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Load ONET mappings for occupational categories
+    task_statements, soc_structure = load_onet_mappings()
+
+    # Use preprocessed intersection data
+    task_metrics = extract_token_metrics_from_intersections(df)
+
+    # Add occupational categories without grouping into "All Other"
+    # Standardize task descriptions for matching
+    task_statements["task_standardized"] = (
+        task_statements["Task"].str.strip().str.lower()
+    )
+    task_metrics["cluster_name_standardized"] = (
+        task_metrics["cluster_name"].str.strip().str.lower()
+    )
+
+    # Create mapping from standardized task to major group
+    task_to_major_group = {}
+    for _, row in task_statements.iterrows():
+        if pd.notna(row["Task"]) and pd.notna(row["soc_major_group"]):
+            std_task = row["task_standardized"]
+            major_group = str(int(row["soc_major_group"]))
+            task_to_major_group[std_task] = major_group
+
+    # Map cluster names to major groups
+    task_metrics["soc_major"] = task_metrics["cluster_name_standardized"].map(
+        task_to_major_group
+    )
+
+    # Get major occupational groups from SOC structure
+    major_groups = soc_structure[soc_structure["Major Group"].notna()].copy()
+    major_groups["soc_major"] = major_groups["Major Group"].astype(str).str[:2]
+    major_groups["title"] = major_groups["SOC or O*NET-SOC 2019 Title"]
+
+    # Create a clean mapping from major group code to title
+    major_group_mapping = (
+        major_groups[["soc_major", "title"]]
+        .drop_duplicates()
+        .set_index("soc_major")["title"]
+        .to_dict()
+    )
+
+    # Map major group codes to titles
+    task_metrics["occupational_category"] = task_metrics["soc_major"].map(
+        major_group_mapping
+    )
+
+    # Remove unmapped/not classified tasks from analysis
+    task_metrics = task_metrics[task_metrics["occupational_category"].notna()].copy()
+
+    # Aggregate by occupational category using pre-calculated percentages
+    category_aggregates = (
+        task_metrics.groupby("occupational_category")
+        .agg(
+            {
+                "usage_pct": "sum",  # Sum of pre-calculated task percentages within category
+                "cost_per_record": "mean",  # Average cost per API call for this category
+            }
+        )
+        .reset_index()
+    )
+
+    # Usage share is already calculated from preprocessing
+    category_aggregates["usage_share"] = category_aggregates["usage_pct"]
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(12, 8))
+
+    # Transform variables to natural log
+    ln_cost = np.log(category_aggregates["cost_per_record"])
+    ln_usage = np.log(category_aggregates["usage_share"])
+
+    # Get colors for each category - use same logic as token output bar chart
+    # Sort by a metric to ensure consistent ordering (using usage_share descending)
+    category_aggregates_sorted = category_aggregates.sort_values(
+        "usage_share", ascending=False
+    )
+
+    category_colors = {}
+    for i, category in enumerate(category_aggregates_sorted["occupational_category"]):
+        category_colors[category] = COLOR_CYCLE[i % len(COLOR_CYCLE)]
+
+    # Create invisible scatter plot to maintain axis limits
+    ax.scatter(
+        ln_cost,
+        ln_usage,
+        s=0,  # Invisible markers
+        alpha=0,
+    )
+
+    # Add line of best fit
+    model = sm.OLS(ln_usage, sm.add_constant(ln_cost)).fit()
+    slope = model.params.iloc[1]
+    intercept = model.params.iloc[0]
+    r_squared = model.rsquared
+
+    # Generate line points
+    x_line = np.linspace(ln_cost.min(), ln_cost.max(), 50)
+    y_line = slope * x_line + intercept
+
+    # Plot the line of best fit
+    ax.plot(
+        x_line,
+        y_line,
+        "--",
+        color="black",
+        linewidth=2,
+        alpha=0.8,
+        label=f"Best fit (R² = {r_squared:.3f}, $\\beta$ = {slope:.3f})",
+    )
+
+    # Add legend
+    legend = ax.legend(loc="best", frameon=True, facecolor="white")
+    legend.get_frame().set_alpha(0.9)
+
+    # Add category labels centered at data points with text wrapping
+    for i, row in category_aggregates.iterrows():
+        # Clean up and wrap category names
+        clean_name = (
+            row["occupational_category"]
+            .replace(" Occupations", "")
+            .replace(", and ", " & ")
+        )
+        # Wrap long category names to multiple lines
+        wrapped_name = "\n".join(wrap(clean_name, 20))
+
+        ax.text(
+            ln_cost.iloc[i],
+            ln_usage.iloc[i],
+            wrapped_name,
+            ha="center",
+            va="center",
+            fontsize=8,
+            alpha=0.9,
+        )
+
+    # Set labels and title
+    ax.set_xlabel("ln(Average API Cost Index across tasks)", fontsize=12)
+    ax.set_ylabel("ln(Usage share (%))", fontsize=12)
+    ax.set_title(
+        "Usage share and average API cost index by occupational category",
+        fontsize=14,
+        fontweight="bold",
+        pad=20,
+    )
+
+    # Add grid
+    ax.grid(True, alpha=0.3)
+
+    # Adjust layout and save
+    plt.tight_layout()
+
+    output_path = Path(output_dir) / "occupational_usage_cost_scatter.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)
+
+
+def get_merged_api_claude_task_data(api_df, cai_df):
+    """
+    Create merged dataset with API cost/usage data and Claude.ai collaboration modes.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+
+    Returns:
+        DataFrame with API cost data + Claude.ai collaboration patterns for common tasks
+    """
+    # Extract API token metrics
+    api_metrics = extract_token_metrics_from_intersections(api_df)
+
+    # Get Claude.ai collaboration shares
+    claude_collab_shares = get_collaboration_shares(cai_df)
+
+    # Find common tasks between both platforms
+    api_tasks = set(api_metrics.index)
+    claude_tasks = set(claude_collab_shares.keys())
+    common_tasks = api_tasks.intersection(claude_tasks)
+
+    # Create merged dataset
+    merged_data = []
+
+    for task_name in common_tasks:
+        # Get API metrics for this task
+        api_row = api_metrics.loc[task_name]
+
+        # Get Claude.ai collaboration for this task
+        claude_collab = claude_collab_shares[task_name]
+
+        # Create merged row
+        merged_row = {
+            "cluster_name": task_name,
+            "cost_per_record": api_row["cost_per_record"],
+            "avg_prompt_tokens": api_row["avg_prompt_tokens"],
+            "avg_completion_tokens": api_row["avg_completion_tokens"],
+            "api_records": api_row["api_records"],
+            "output_input_ratio": api_row["output_input_ratio"],
+            "total_tokens": api_row["total_tokens"],
+            # Claude.ai collaboration modes
+            "collab_directive": claude_collab.get("directive", 0),
+            "collab_feedback_loop": claude_collab.get("feedback loop", 0),
+            "collab_learning": claude_collab.get("learning", 0),
+            "collab_task_iteration": claude_collab.get("task iteration", 0),
+            "collab_validation": claude_collab.get("validation", 0),
+        }
+        merged_data.append(merged_row)
+
+    merged_df = pd.DataFrame(merged_data)
+    merged_df.set_index("cluster_name", inplace=True)
+
+    return merged_df
+
+
+def reg_build_df(api_df, cai_df):
+    """
+    Build complete regression dataset for partial regression and full regression analysis.
+    Each row is an ONET task with all variables needed for figures and regression.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+
+    Returns:
+        DataFrame with complete regression dataset
+    """
+    # Load ONET mappings
+    task_statements, soc_structure = load_onet_mappings()
+
+    # Use merged dataset with API metrics + Claude.ai collaboration
+    task_metrics = get_merged_api_claude_task_data(api_df, cai_df)
+
+    # Add occupational categories (includes "All Other" grouping)
+    task_metrics_with_names = task_metrics.reset_index()
+    task_metrics_with_names = add_occupational_categories_to_metrics(
+        task_metrics_with_names, task_statements, soc_structure
+    )
+    task_metrics = task_metrics_with_names.set_index("cluster_name")
+
+    # Add collaboration missing dummies
+    collaboration_modes = [
+        "directive",
+        "feedback_loop",
+        "learning",
+        "task_iteration",
+        "validation",
+    ]
+
+    for mode in collaboration_modes:
+        collab_col = f"collab_{mode}"
+        missing_col = f"collab_{mode}_missing"
+        if collab_col in task_metrics.columns:
+            task_metrics[missing_col] = (task_metrics[collab_col] == 0).astype(int)
+        else:
+            task_metrics[missing_col] = 1
+
+    # Calculate usage variables
+    total_api_records = task_metrics["api_records"].sum()
+    task_metrics["usage_share"] = (
+        task_metrics["api_records"] / total_api_records
+    ) * 100
+    task_metrics["ln_usage_share"] = np.log(task_metrics["usage_share"])
+    task_metrics["ln_cost_per_task"] = np.log(task_metrics["cost_per_record"])
+
+    # Use all data
+    valid_data = task_metrics
+
+    # Create occupational category dummies while preserving original column
+    valid_data = pd.get_dummies(
+        valid_data, columns=["occupational_category"], prefix="occ"
+    )
+
+    # Restore the original occupational_category column for grouping operations
+    # Extract category name from the dummy columns that are 1
+    occ_cols = [col for col in valid_data.columns if col.startswith("occ_")]
+    valid_data["occupational_category"] = ""
+    for col in occ_cols:
+        category_name = col.replace("occ_", "")
+        mask = valid_data[col] == 1
+        valid_data.loc[mask, "occupational_category"] = category_name
+
+    return valid_data
+
+
+def create_partial_regression_plot(api_df, cai_df, output_dir):
+    """
+    Create partial regression scatter plot of usage share vs cost, controlling for occupational categories.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save the figure
+
+    Returns:
+        Tuple of (output_path, regression_results_dict)
+    """
+    # Use centralized data preparation (includes occupational dummies)
+    valid_metrics = reg_build_df(api_df, cai_df)
+
+    # Extract occupational dummies and collaboration variables
+    occ_cols = [col for col in valid_metrics.columns if col.startswith("occ_")]
+    collab_vars = [
+        "collab_directive",
+        "collab_feedback_loop",
+        "collab_learning",
+        "collab_task_iteration",
+        "collab_validation",
+    ]
+    collab_missing_vars = [
+        "collab_directive_missing",
+        "collab_feedback_loop_missing",
+        "collab_learning_missing",
+        "collab_task_iteration_missing",
+        "collab_validation_missing",
+    ]
+
+    # Control variables (all occupational dummies + collaboration modes)
+    control_vars = valid_metrics[occ_cols + collab_vars + collab_missing_vars].astype(
+        float
+    )
+
+    # Ensure dependent variables are float
+    y_usage = valid_metrics["ln_usage_share"].astype(float)
+    y_cost = valid_metrics["ln_cost_per_task"].astype(float)
+
+    # Step 1: Regress ln(usage_share) on controls (no constant)
+    usage_model = sm.OLS(y_usage, control_vars).fit()
+    usage_residuals = usage_model.resid
+
+    # Step 2: Regress ln(cost) on controls (no constant)
+    cost_model = sm.OLS(y_cost, control_vars).fit()
+    cost_residuals = cost_model.resid
+
+    # Find top 6 categories by usage share for coloring
+    category_usage = (
+        valid_metrics.groupby("occupational_category")["api_records"]
+        .sum()
+        .sort_values(ascending=False)
+    )
+    top_6_categories = list(category_usage.head(6).index)
+
+    # Create category grouping for coloring
+    valid_metrics["category_group"] = valid_metrics["occupational_category"].apply(
+        lambda x: x if x in top_6_categories else "All Other"
+    )
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(14, 10))
+
+    # Create color mapping for top 6 + "All Other"
+    unique_groups = valid_metrics["category_group"].unique()
+    group_colors = {}
+    color_idx = 0
+
+    # Assign colors to top 6 categories first
+    for cat in top_6_categories:
+        if cat in unique_groups:
+            group_colors[cat] = COLOR_CYCLE[color_idx % len(COLOR_CYCLE)]
+            color_idx += 1
+
+    # Assign color to "All Other"
+    if "All Other" in unique_groups:
+        group_colors["All Other"] = "#999999"  # Gray for all other
+
+    # Create single scatter plot (no color by group)
+    ax.scatter(
+        cost_residuals,
+        usage_residuals,
+        s=100,
+        alpha=0.8,
+        color=COLOR_CYCLE[0],
+        edgecolors="black",
+        linewidth=0.2,
+    )
+
+    # Add overall trend line for residuals
+    model = sm.OLS(usage_residuals, sm.add_constant(cost_residuals)).fit()
+    slope = model.params.iloc[1]
+    intercept = model.params.iloc[0]
+    r_squared = model.rsquared
+
+    line_x = np.linspace(cost_residuals.min(), cost_residuals.max(), 100)
+    line_y = slope * line_x + intercept
+    ax.plot(
+        line_x,
+        line_y,
+        "k--",
+        alpha=0.8,
+        linewidth=2,
+        label=f"Partial relationship (R² = {r_squared:.3f})",
+    )
+
+    # Customize plot
+    ax.set_xlabel("Residual ln(API Cost Index)")
+    ax.set_ylabel("Residual ln(Usage share (%))")
+    ax.set_title(
+        "Task usage share vs API Cost Index \n(partial regression after controlling for task characteristics)",
+        fontsize=16,
+        fontweight="bold",
+        pad=20,
+    )
+    ax.grid(True, alpha=0.3)
+
+    # Simple legend with just the trend line
+    ax.legend(loc="best", frameon=True, facecolor="white", framealpha=0.9, fontsize=11)
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "partial_regression_plot.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+
+    # Save regression results
+    regression_results = {
+        "partial_correlation": np.sqrt(r_squared),
+        "partial_r_squared": r_squared,
+        "slope": slope,
+        "intercept": intercept,
+        "n_observations": len(valid_metrics),
+        "usage_model_summary": str(usage_model.summary()),
+        "cost_model_summary": str(cost_model.summary()),
+    }
+
+    # Print regression results instead of saving to file
+    print("Partial Regression Analysis Results")
+    print("=" * 50)
+    print(f"Partial correlation: {np.sqrt(r_squared):.4f}")
+    print(f"Partial R-squared: {r_squared:.4f}")
+    print(f"Slope: {slope:.4f}")
+    print(f"Intercept: {intercept:.4f}")
+    print(f"Number of observations: {len(valid_metrics)}")
+    print("\nUsage Model Summary:")
+    print("-" * 30)
+    print(usage_model.summary())
+    print("\nCost Model Summary:")
+    print("-" * 30)
+    print(cost_model.summary())
+
+    return str(output_path), regression_results
+
+
+def perform_usage_share_regression_unweighted(api_df, cai_df, output_dir):
+    """
+    Perform unweighted usage share regression analysis using Claude.ai collaboration modes.
+
+    Args:
+        api_df: API preprocessed data DataFrame
+        cai_df: Claude.ai preprocessed data DataFrame
+        output_dir: Directory to save regression results
+
+    Returns:
+        OLS model results
+    """
+    # Use centralized data preparation (includes all dummies)
+    valid_data = reg_build_df(api_df, cai_df)
+
+    # Extract all regression variables
+    X_cols = ["ln_cost_per_task"]
+    X_cols.extend(
+        [
+            f"collab_{mode}"
+            for mode in [
+                "directive",
+                "feedback_loop",
+                "learning",
+                "task_iteration",
+                "validation",
+            ]
+        ]
+    )
+    X_cols.extend(
+        [
+            f"collab_{mode}_missing"
+            for mode in [
+                "directive",
+                "feedback_loop",
+                "learning",
+                "task_iteration",
+                "validation",
+            ]
+        ]
+    )
+    X_cols.extend([col for col in valid_data.columns if col.startswith("occ_")])
+
+    # Ensure all columns are numeric
+    X = valid_data[X_cols].astype(float)
+    y = valid_data["ln_usage_share"].astype(float)
+
+    # Run unweighted OLS without constant (to include all occupational dummies)
+    model = sm.OLS(y, X).fit()
+
+    # Get heteroskedasticity-robust standard errors (HC1)
+    model_robust = model.get_robustcov_results(cov_type="HC1")
+
+    return model_robust
+
+
+def create_btos_ai_adoption_chart(btos_df, ref_dates_df, output_dir):
+    """
+    Create BTOS AI adoption time series chart.
+
+    Args:
+        btos_df: BTOS response estimates DataFrame
+        ref_dates_df: Collection and reference dates DataFrame
+        output_dir: Directory to save the figure
+    """
+    # Filter for Question ID 7, Answer ID 1 (Yes response to AI usage)
+    btos_filtered = btos_df[(btos_df["Question ID"] == 7) & (btos_df["Answer ID"] == 1)]
+
+    # Get date columns (string columns that look like YYYYWW)
+    date_columns = [
+        col for col in btos_df.columns[4:] if str(col).isdigit() and len(str(col)) == 6
+    ]
+
+    # Extract time series
+    btos_ts = btos_filtered[date_columns].T
+    btos_ts.columns = ["percentage"]
+
+    # Map to reference end dates
+    ref_dates_df["Ref End"] = pd.to_datetime(ref_dates_df["Ref End"])
+    btos_ts = btos_ts.reset_index()
+    btos_ts["smpdt"] = btos_ts["index"].astype(int)
+    btos_ts = btos_ts.merge(
+        ref_dates_df[["Smpdt", "Ref End"]],
+        left_on="smpdt",
+        right_on="Smpdt",
+        how="left",
+    )
+    btos_ts = btos_ts.set_index("Ref End")[["percentage"]]
+
+    # Convert percentage strings to numeric
+    btos_ts["percentage"] = btos_ts["percentage"].str.rstrip("%").astype(float)
+    btos_ts = btos_ts.sort_index().dropna()
+
+    # Calculate 3-period moving average
+    btos_ts["moving_avg"] = btos_ts["percentage"].rolling(window=3).mean()
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(14, 8))
+
+    # Plot main line
+    ax.plot(
+        btos_ts.index,
+        btos_ts["percentage"],
+        linewidth=3,
+        marker="o",
+        markersize=6,
+        label="AI Adoption Rate Among US Businesses",
+        zorder=3,
+    )
+
+    # Plot moving average
+    ax.plot(
+        btos_ts.index,
+        btos_ts["moving_avg"],
+        linewidth=2,
+        linestyle="--",
+        alpha=0.8,
+        label="3-Period Moving Average",
+        zorder=2,
+    )
+
+    # Styling
+    ax.set_xlabel("Date", fontsize=14)
+    ax.set_ylabel("AI adoption rate (%)", fontsize=14)
+    ax.set_title(
+        "Census reported AI adoption rates among US businesses from the Business Trends and Outlook Survey",
+        fontsize=16,
+        fontweight="bold",
+        pad=20,
+    )
+
+    # Format y-axis as percentage
+    ax.set_ylim(0, max(btos_ts["percentage"]) * 1.1)
+
+    # Rotate x-axis labels
+    ax.tick_params(axis="x", rotation=45)
+
+    # Grid and styling
+    ax.grid(True, alpha=0.3, linestyle="--")
+    ax.set_axisbelow(True)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    # Legend
+    ax.legend(loc="upper left", fontsize=11, frameon=True, facecolor="white")
+
+    plt.tight_layout()
+
+    # Save plot
+    output_path = Path(output_dir) / "btos_ai_adoption_chart.png"
+    plt.savefig(output_path, dpi=300, bbox_inches="tight")
+    plt.show()
+    return str(output_path)

release_2025_09_15/code/aei_analysis_functions_claude_ai.py

@@ -0,0 +1,2926 @@
+#!/usr/bin/env python3
+"""
+Analysis functions for AEI Report v3 Claude.ai chapter
+"""
+
+import textwrap
+
+import geopandas as gpd
+import matplotlib.colors as mcolors
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from matplotlib.colors import LinearSegmentedColormap, Normalize, TwoSlopeNorm
+from matplotlib.lines import Line2D
+from matplotlib.patches import FancyBboxPatch, Patch
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+# global list of excluded countries (ISO-3 codes)
+EXCLUDED_COUNTRIES = [
+    "AFG",
+    "BLR",
+    "COD",
+    "CAF",
+    "CHN",
+    "CUB",
+    "ERI",
+    "ETH",
+    "HKG",
+    "IRN",
+    "PRK",
+    "LBY",
+    "MLI",
+    "MMR",
+    "MAC",
+    "NIC",
+    "RUS",
+    "SDN",
+    "SOM",
+    "SSD",
+    "SYR",
+    "VEN",
+    "YEM",
+]
+
+# Minimum observation thresholds
+MIN_OBSERVATIONS_COUNTRY = 200  # Threshold for countries
+MIN_OBSERVATIONS_US_STATE = 100  # Threshold for US states
+
+# Define the tier colors
+TIER_COLORS_LIST = ["#E6DBD0", "#E5C5AB", "#E4AF86", "#E39961", "#D97757"]
+
+# Anthropic brand color for borders
+ANTHROPIC_OAT = "#E3DACC"
+AUGMENTATION_COLOR = "#00A078"
+AUTOMATION_COLOR = "#FF9940"
+
+# Standard tier color mapping used throughout
+TIER_COLORS_DICT = {
+    "Minimal": TIER_COLORS_LIST[0],  # Lightest
+    "Emerging (bottom 25%)": TIER_COLORS_LIST[1],
+    "Lower middle (25-50%)": TIER_COLORS_LIST[2],
+    "Upper middle (50-75%)": TIER_COLORS_LIST[3],
+    "Leading (top 25%)": TIER_COLORS_LIST[4],  # Darkest
+}
+
+# Standard tier ordering
+TIER_ORDER = [
+    "Leading (top 25%)",
+    "Upper middle (50-75%)",
+    "Lower middle (25-50%)",
+    "Emerging (bottom 25%)",
+    "Minimal",
+]
+
+# Numeric tier color mapping (for tier values 0-4)
+TIER_COLORS_NUMERIC = {i: color for i, color in enumerate(TIER_COLORS_LIST)}
+
+# Numeric tier name mapping (for tier values 1-4 in actual data)
+TIER_NAMES_NUMERIC = {
+    1: "Emerging (bottom 25%)",
+    2: "Lower middle (25-50%)",
+    3: "Upper middle (50-75%)",
+    4: "Leading (top 25%)",
+}
+
+# Create a custom colormap that can be used for continuous variables
+CUSTOM_CMAP = LinearSegmentedColormap.from_list("custom_tier", TIER_COLORS_LIST, N=256)
+
+# Map layout constants
+MAP_PADDING_X = 0.25  # Horizontal padding for legend space
+MAP_PADDING_Y = 0.05  # Vertical padding
+ALASKA_INSET_BOUNDS = [0.26, 0.18, 0.15, 0.15]  # [left, bottom, width, height]
+HAWAII_INSET_BOUNDS = [0.40, 0.18, 0.11, 0.11]  # [left, bottom, width, height]
+
+
+# Figure style and setup
+def setup_plot_style():
+    """Configure matplotlib."""
+    plt.style.use("default")
+    plt.rcParams.update(
+        {
+            "figure.dpi": 150,
+            "savefig.dpi": 150,
+            "font.size": 10,
+            "axes.labelsize": 11,
+            "axes.titlesize": 12,
+            "xtick.labelsize": 9,
+            "ytick.labelsize": 9,
+            "legend.fontsize": 9,
+            "figure.facecolor": "white",
+            "axes.facecolor": "white",
+            "savefig.facecolor": "white",
+            "axes.edgecolor": "#333333",
+            "axes.linewidth": 0.8,
+            "axes.grid": True,
+            "grid.alpha": 0.3,
+            "grid.linestyle": "-",
+            "grid.linewidth": 0.5,
+            "axes.axisbelow": True,
+        }
+    )
+
+
+def create_figure(figsize=(12, 8), tight_layout=True, nrows=1, ncols=1):
+    """Create a figure with consistent settings.
+
+    Args:
+        figsize: Figure size tuple
+        tight_layout: Whether to use tight layout
+        nrows: Number of subplot rows
+        ncols: Number of subplot columns
+
+    Returns:
+        fig, ax or fig, axes depending on subplot configuration
+    """
+    fig, ax = plt.subplots(nrows, ncols, figsize=figsize)
+    if tight_layout:
+        fig.tight_layout()
+    else:
+        # Explicitly disable the layout engine to prevent warnings
+        fig.set_layout_engine(layout="none")
+    return fig, ax
+
+
+def format_axis(
+    ax,
+    xlabel=None,
+    ylabel=None,
+    title=None,
+    xlabel_size=11,
+    ylabel_size=11,
+    title_size=13,
+    grid=True,
+    grid_alpha=0.3,
+):
+    """Apply consistent axis formatting."""
+    if xlabel:
+        ax.set_xlabel(xlabel, fontsize=xlabel_size)
+    if ylabel:
+        ax.set_ylabel(ylabel, fontsize=ylabel_size)
+    if title:
+        ax.set_title(title, fontsize=title_size, fontweight="bold", pad=15)
+    if grid:
+        ax.grid(True, alpha=grid_alpha)
+    return ax
+
+
+def get_color_normalizer(values, center_at_one=False, vmin=None, vmax=None):
+    """Create appropriate color normalizer for data."""
+    if center_at_one:
+        # Use TwoSlopeNorm for diverging around 1.0
+        if vmin is None:
+            vmin = min(values.min(), 0.1)
+        if vmax is None:
+            vmax = max(values.max(), 2.0)
+        return TwoSlopeNorm(vmin=vmin, vcenter=1.0, vmax=vmax)
+    else:
+        # Use regular normalization
+        if vmin is None:
+            vmin = values.min()
+        if vmax is None:
+            vmax = values.max()
+        return Normalize(vmin=vmin, vmax=vmax)
+
+
+def create_tier_legend(
+    ax,
+    tier_colors,
+    tiers_in_data,
+    excluded_countries=False,
+    no_data=False,
+    loc="lower left",
+    title="Anthropic AI Usage Index tier",
+):
+    """Create a consistent tier legend for maps."""
+    legend_elements = []
+    for tier in TIER_ORDER:
+        if tier in tiers_in_data:
+            legend_elements.append(
+                mpatches.Patch(
+                    facecolor=tier_colors[tier], edgecolor="none", label=tier
+                )
+            )
+
+    if excluded_countries:
+        legend_elements.append(
+            mpatches.Patch(
+                facecolor="#c0c0c0", edgecolor="white", label="Claude not available"
+            )
+        )
+
+    if no_data:
+        legend_elements.append(
+            mpatches.Patch(facecolor="#f0f0f0", edgecolor="white", label="No data")
+        )
+
+    if legend_elements:
+        ax.legend(
+            handles=legend_elements,
+            loc=loc,
+            fontsize=10,
+            bbox_to_anchor=(0, 0) if loc == "lower left" else None,
+            title=title,
+            title_fontsize=11,
+            frameon=True,
+            fancybox=True,
+            shadow=True,
+        )
+
+    return ax
+
+
+# Data wrangling helpers
+
+
+def filter_df(df, **kwargs):
+    """Universal filter helper for dataframes.
+
+    Args:
+        df: DataFrame to filter
+        **kwargs: Column-value pairs to filter on
+                  Lists are handled with .isin()
+
+    Returns:
+        Filtered DataFrame
+    """
+    mask = pd.Series([True] * len(df), index=df.index)
+
+    for key, value in kwargs.items():
+        if value is None:
+            continue  # Skip None values
+        if key in df.columns:
+            if isinstance(value, list):
+                mask = mask & df[key].isin(value)
+            else:
+                mask = mask & (df[key] == value)
+
+    return df[mask]
+
+
+def get_filtered_geographies(df, min_obs_country=None, min_obs_state=None):
+    """
+    Get lists of countries and states that meet MIN_OBSERVATIONS thresholds.
+
+    This function does NOT filter the dataframe - it only identifies which
+    geographies meet the thresholds. The full dataframe is preserved
+    so we can still report statistics for all geographies.
+
+    Args:
+        df: Input dataframe
+        min_obs_country: Minimum observations for countries (default: MIN_OBSERVATIONS_COUNTRY)
+        min_obs_state: Minimum observations for states (default: MIN_OBSERVATIONS_US_STATE)
+
+    Returns:
+        Tuple of (filtered_countries list, filtered_states list)
+    """
+    # Use defaults if not specified
+    if min_obs_country is None:
+        min_obs_country = MIN_OBSERVATIONS_COUNTRY
+    if min_obs_state is None:
+        min_obs_state = MIN_OBSERVATIONS_US_STATE
+
+    # Get country usage counts
+    country_usage = filter_df(df, facet="country", variable="usage_count").set_index(
+        "geo_id"
+    )["value"]
+
+    # Get state usage counts
+    state_usage = filter_df(df, facet="state_us", variable="usage_count").set_index(
+        "geo_id"
+    )["value"]
+
+    # Get countries that meet threshold (excluding not_classified)
+    filtered_countries = country_usage[country_usage >= min_obs_country].index.tolist()
+    filtered_countries = [c for c in filtered_countries if c != "not_classified"]
+
+    # Get states that meet threshold (excluding not_classified)
+    filtered_states = state_usage[state_usage >= min_obs_state].index.tolist()
+    filtered_states = [s for s in filtered_states if s != "not_classified"]
+
+    return filtered_countries, filtered_states
+
+
+def filter_requests_by_threshold(df, geography, geo_id, level=1, threshold=1.0):
+    """
+    Filter requests to only include requests at a specific level that meet threshold requirements.
+
+    Args:
+        df: Long format dataframe with request data
+        geography: Current geography level ('country' or 'state_us')
+        geo_id: Current geography ID (e.g., 'USA', 'CA')
+        level: Request level to filter (default=1 for middle aggregated)
+        threshold: Minimum percentage threshold (default=1.0%)
+
+    Returns:
+        List of valid cluster_names that:
+        1. Are at the specified level (default level 1)
+        2. Have >= threshold % in the current geography
+        3. Have >= threshold % in the parent geography (USA for states, GLOBAL for countries)
+    """
+    # Determine parent geography
+    if geography == "state_us":
+        parent_geo = "USA"
+        parent_geography = "country"
+    elif geography == "country":
+        parent_geo = "GLOBAL"
+        parent_geography = "global"
+    else:  # global
+        # For global, no parent filtering needed
+        df_local = filter_df(
+            df,
+            geography=geography,
+            geo_id=geo_id,
+            facet="request",
+            level=level,
+            variable="request_pct",
+        )
+        return df_local[df_local["value"] >= threshold]["cluster_name"].tolist()
+
+    # Get local request percentages at specified level
+    df_local = filter_df(
+        df,
+        geography=geography,
+        geo_id=geo_id,
+        facet="request",
+        level=level,
+        variable="request_pct",
+    )
+
+    # Get parent request percentages at same level
+    df_parent = filter_df(
+        df,
+        geography=parent_geography,
+        geo_id=parent_geo,
+        facet="request",
+        level=level,
+        variable="request_pct",
+    )
+
+    # Filter by local threshold
+    local_valid = set(df_local[df_local["value"] >= threshold]["cluster_name"])
+
+    # Filter by parent threshold
+    parent_valid = set(df_parent[df_parent["value"] >= threshold]["cluster_name"])
+
+    # Return intersection (must meet both thresholds)
+    return list(local_valid & parent_valid)
+
+
+# Data loading
+
+
+def load_world_shapefile():
+    """Load and prepare world shapefile for mapping."""
+    url = "https://naciscdn.org/naturalearth/10m/cultural/ne_10m_admin_0_countries_iso.zip"
+    world = gpd.read_file(url)
+
+    # Remove Antarctica from the dataset entirely
+    world = world[world["ISO_A3_EH"] != "ATA"]
+
+    # Use Robinson projection for better world map appearance
+    world = world.to_crs("+proj=robin")
+
+    # Mark excluded countries using global EXCLUDED_COUNTRIES
+    world["is_excluded"] = world["ISO_A3_EH"].isin(EXCLUDED_COUNTRIES)
+
+    return world
+
+
+def load_us_states_shapefile():
+    """Load and prepare US states shapefile for mapping."""
+    import ssl
+
+    # Create unverified SSL context to handle Census Bureau cert issues
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+    states_url = (
+        "https://www2.census.gov/geo/tiger/GENZ2018/shp/cb_2018_us_state_20m.zip"
+    )
+    states = gpd.read_file(states_url)
+
+    # Filter out territories but keep all 50 states and DC
+    states = states[~states["STUSPS"].isin(["PR", "VI", "MP", "GU", "AS"])]
+
+    return states
+
+
+def merge_geo_data(shapefile, df_data, geo_column, columns_to_merge, is_tier=False):
+    """Merge data with geographic shapefile.
+
+    Args:
+        shapefile: GeoDataFrame (world or states)
+        df_data: DataFrame with data to merge
+        geo_column: Column in shapefile to join on (e.g., 'ISO_A3_EH', 'STUSPS')
+        columns_to_merge: List of columns to merge from df_data
+        is_tier: Whether this is tier data (includes cluster_name)
+
+    Returns:
+        Merged GeoDataFrame
+    """
+    if is_tier and "cluster_name" not in columns_to_merge:
+        columns_to_merge = columns_to_merge + ["cluster_name"]
+
+    return shapefile.merge(
+        df_data[columns_to_merge], left_on=geo_column, right_on="geo_id", how="left"
+    )
+
+
+def prepare_map_data(
+    geo_df,
+    value_column="value",
+    center_at_one=False,
+    excluded_mask=None,
+):
+    """Prepare data and normalization for map plotting.
+
+    Args:
+        geo_df: GeoDataFrame with geographic data and values to plot
+        value_column: Name of column containing values to plot (default: "value")
+        center_at_one: If True, center color scale at 1.0 for diverging colormap (default: False)
+        excluded_mask: Boolean Series indicating which rows to exclude from normalization
+                       (e.g., countries where service isn't available). If None, no exclusions.
+
+    Returns:
+        tuple: (plot_column_name, norm) where norm is the matplotlib Normalize object
+    """
+    if excluded_mask is None:
+        excluded_mask = pd.Series([False] * len(geo_df), index=geo_df.index)
+
+    valid_data = geo_df[geo_df[value_column].notna() & ~excluded_mask][value_column]
+
+    vmin = valid_data.min() if len(valid_data) > 0 else 0
+    vmax = valid_data.max() if len(valid_data) > 0 else 1
+    norm = get_color_normalizer(
+        valid_data, center_at_one=center_at_one, vmin=vmin, vmax=vmax
+    )
+
+    return value_column, norm
+
+
+# Main visualization functions
+
+
+def plot_world_map(
+    ax, world, data_column="value", tier_colors=None, cmap=None, norm=None
+):
+    """Plot world map with data.
+
+    Args:
+        ax: matplotlib axis
+        world: GeoDataFrame with world data (already merged with values)
+        data_column: column name containing data to plot
+        tier_colors: dict mapping tier names to colors (for categorical)
+        cmap: colormap (for continuous)
+        norm: normalization (for continuous)
+    """
+    if tier_colors:
+        # Plot each tier with its color
+        for tier, color in tier_colors.items():
+            tier_countries = world[
+                (world["cluster_name"] == tier) & (~world["is_excluded"])
+            ]
+            tier_countries.plot(ax=ax, color=color, edgecolor="white", linewidth=0.5)
+    else:
+        # Plot continuous data
+        world_with_data = world[
+            world[data_column].notna() & (world["is_excluded"] == False)
+        ]
+        world_with_data.plot(
+            column=data_column, ax=ax, cmap=cmap, norm=norm, legend=False
+        )
+
+    # Plot excluded countries
+    excluded = world[world["is_excluded"] == True]
+    if not excluded.empty:
+        excluded.plot(ax=ax, color="#c0c0c0", edgecolor="white", linewidth=0.5)
+
+    # Plot no-data countries
+    no_data = world[
+        (world[data_column if not tier_colors else "cluster_name"].isna())
+        & (~world["is_excluded"])
+    ]
+    if not no_data.empty:
+        no_data.plot(ax=ax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
+
+    # Set appropriate bounds for Robinson projection
+    ax.set_xlim(-17000000, 17000000)
+    ax.set_ylim(-8500000, 8500000)
+
+
+def plot_us_states_map(
+    fig, ax, states, data_column="value", tier_colors=None, cmap=None, norm=None
+):
+    """Plot US states map with Alaska and Hawaii insets.
+
+    Args:
+        fig: matplotlib figure
+        ax: main axis for continental US
+        states: GeoDataFrame with state data (already merged with values)
+        data_column: column name containing data to plot
+        tier_colors: dict mapping tier names to colors (for categorical)
+        cmap: colormap (for continuous)
+        norm: normalization (for continuous)
+    """
+    # Project to EPSG:2163 for US Albers Equal Area
+    states = states.to_crs("EPSG:2163")
+
+    # Plot continental US (everything except AK and HI)
+    continental = states[~states["STUSPS"].isin(["AK", "HI"])]
+
+    # First plot all continental states as no-data background
+    continental.plot(ax=ax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
+
+    # Plot continental states with data
+    if tier_colors:
+        # Plot each tier with its color
+        for tier, color in tier_colors.items():
+            tier_states = continental[continental["cluster_name"] == tier]
+            if not tier_states.empty:
+                tier_states.plot(ax=ax, color=color, edgecolor="white", linewidth=0.5)
+    else:
+        # Plot continuous data
+        continental_with_data = continental[continental[data_column].notna()]
+        if not continental_with_data.empty:
+            continental_with_data.plot(
+                column=data_column, ax=ax, cmap=cmap, norm=norm, legend=False
+            )
+
+    # Set axis limits with padding for legend
+    xlim = ax.get_xlim()
+    ylim = ax.get_ylim()
+    x_padding = (xlim[1] - xlim[0]) * MAP_PADDING_X
+    y_padding = (ylim[1] - ylim[0]) * MAP_PADDING_Y
+    ax.set_xlim(xlim[0] - x_padding, xlim[1] + x_padding)
+    ax.set_ylim(ylim[0] - y_padding, ylim[1] + y_padding)
+
+    # Add Alaska inset
+    akax = fig.add_axes(ALASKA_INSET_BOUNDS)
+    akax.axis("off")
+
+    alaska = states[states["STUSPS"] == "AK"]
+    if not alaska.empty:
+        alaska.plot(ax=akax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
+
+        if tier_colors and alaska["cluster_name"].notna().any():
+            tier_name = alaska["cluster_name"].iloc[0]
+            if tier_name in tier_colors:
+                alaska.plot(
+                    ax=akax,
+                    color=tier_colors[tier_name],
+                    edgecolor="white",
+                    linewidth=0.5,
+                )
+        elif not tier_colors and alaska[data_column].notna().any():
+            alaska.plot(column=data_column, ax=akax, cmap=cmap, norm=norm, legend=False)
+
+    # Add Hawaii inset
+    hiax = fig.add_axes(HAWAII_INSET_BOUNDS)
+    hiax.axis("off")
+
+    hawaii = states[states["STUSPS"] == "HI"]
+    if not hawaii.empty:
+        hawaii.plot(ax=hiax, color="#f0f0f0", edgecolor="white", linewidth=0.5)
+
+        if tier_colors and hawaii["cluster_name"].notna().any():
+            tier_name = hawaii["cluster_name"].iloc[0]
+            if tier_name in tier_colors:
+                hawaii.plot(
+                    ax=hiax,
+                    color=tier_colors[tier_name],
+                    edgecolor="white",
+                    linewidth=0.5,
+                )
+        elif not tier_colors and hawaii[data_column].notna().any():
+            hawaii.plot(column=data_column, ax=hiax, cmap=cmap, norm=norm, legend=False)
+
+
+def plot_usage_index_bars(
+    df,
+    geography="country",
+    top_n=None,
+    figsize=(12, 8),
+    title=None,
+    filtered_entities=None,
+    show_usage_counts=True,
+    cmap=CUSTOM_CMAP,
+):
+    """
+    Create horizontal bar chart of Anthropic AI Usage Index.
+
+    Args:
+        df: Long format dataframe
+        geography: 'country' or 'state_us'
+        top_n: Number of top entities to show (None for all)
+        figsize: Figure size
+        title: Chart title
+        filtered_entities: List of geo_id values to include (if None, include all)
+        show_usage_counts: If True, show usage counts in labels (default: True)
+    """
+    # Get data
+    df_metric = filter_df(
+        df, geography=geography, facet=geography, variable="usage_per_capita_index"
+    )
+
+    # Apply entity filtering if provided
+    if filtered_entities is not None:
+        df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
+
+    # Get usage counts for display if requested
+    if show_usage_counts:
+        df_usage = filter_df(
+            df, geography=geography, facet=geography, variable="usage_count"
+        )
+        # Merge to get usage counts
+        df_metric = df_metric.merge(
+            df_usage[["geo_id", "value"]],
+            on="geo_id",
+            suffixes=("", "_usage"),
+            how="left",
+        )
+
+    # Select entities to display
+    if top_n is None or top_n >= len(df_metric):
+        # Show all entities, sorted by lowest value first (will appear at bottom of chart)
+        df_top = df_metric.sort_values("value", ascending=True)
+        # Adjust figure height for many entities
+        if len(df_top) > 20:
+            figsize = (figsize[0], max(10, len(df_top) * 0.3))
+    else:
+        # Select top N entities, then sort ascending so highest values appear at top
+        df_top = df_metric.nlargest(top_n, "value")
+        df_top = df_top.sort_values("value", ascending=True)
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Get colormap and create diverging colors centered at 1
+    values = df_top["value"].values
+    min_val = values.min()
+    max_val = values.max()
+
+    # Determine the range for symmetric color scaling around 1
+    max_distance = max(abs(min_val - 1), abs(max_val - 1))
+
+    # Normalize values for color mapping
+    if max_distance > 0:
+        # Normalize to 0-1 centered at 0.5 for value 1
+        normalized = 0.5 + (values - 1) / (2 * max_distance)
+        # Truncate colormap to avoid too light colors
+        truncate_low = 0.2
+        truncate_high = 0.8
+        normalized = truncate_low + normalized * (truncate_high - truncate_low)
+        normalized = np.clip(normalized, truncate_low, truncate_high)
+    else:
+        normalized = np.ones_like(values) * 0.5
+
+    colors = cmap(normalized)
+
+    # Create horizontal bars
+    y_positions = range(len(df_top))
+    bars = ax.barh(y_positions, values, color=colors, height=0.7)
+
+    # Set y-tick labels
+    ax.set_yticks(y_positions)
+    ax.set_yticklabels(df_top["geo_name"].values)
+
+    # Set y-axis limits to reduce white space
+    ax.set_ylim(-0.5, len(df_top) - 0.5)
+
+    # Add baseline reference line at 1.0
+    ax.axvline(x=1.0, color="black", linestyle="--", alpha=0.5, linewidth=1)
+
+    # Calculate and set x-axis limits with extra space for labels
+    if max_val > 2:
+        ax.set_xlim(0, max_val * 1.25)
+    else:
+        ax.set_xlim(0, max_val * 1.2)
+
+    # Add value labels and usage counts
+    for i, bar in enumerate(bars):
+        width = bar.get_width()
+        # Always use 2 decimal places for consistency
+        label = f"{width:.2f}"
+
+        # Get usage count
+        usage_count = df_top.iloc[i]["value_usage"]
+        if usage_count >= 1000:
+            usage_str = f"{usage_count / 1000:.1f}k"
+        else:
+            usage_str = f"{int(usage_count)}"
+
+        # For top_n > 20, combine label with usage count to avoid overlap
+        if not top_n or top_n > 20:
+            combined_label = f"{label} (N={usage_str})"
+            ax.text(
+                width + 0.03,
+                bar.get_y() + bar.get_height() / 2.0,
+                combined_label,
+                ha="left",
+                va="center",
+                fontsize=8,
+            )
+        else:
+            # Add value label to the right of the bar
+            ax.text(
+                width + 0.03,
+                bar.get_y() + bar.get_height() / 2.0,
+                label,
+                ha="left",
+                va="center",
+                fontsize=9,
+            )
+
+            # Add usage count inside the bar
+            usage_str_full = f"N = {usage_str}"
+            ax.text(
+                0.05,
+                bar.get_y() + bar.get_height() / 2.0,
+                usage_str_full,
+                ha="left",
+                va="center",
+                fontsize=8,
+                color="white",
+            )
+
+    # Set labels and title
+    if top_n:
+        default_title = f"Top {top_n} {'countries' if geography == 'country' else 'US states'} by Anthropic AI Usage Index"
+    else:
+        default_title = f"Anthropic AI Usage Index by {'country' if geography == 'country' else 'US state'}"
+
+    format_axis(
+        ax,
+        xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
+        title=title or default_title,
+        grid=True,
+        grid_alpha=0.3,
+    )
+
+    return fig
+
+
+def plot_variable_bars(
+    df,
+    variable,
+    facet,
+    geography="country",
+    geo_id=None,
+    top_n=None,
+    figsize=(12, 8),
+    title=None,
+    xlabel=None,
+    filtered_entities=None,
+    cmap=CUSTOM_CMAP,
+    normalize=False,
+    exclude_not_classified=False,
+):
+    """
+    Create horizontal bar chart for any variable.
+
+    Args:
+        df: Long format dataframe
+        variable: Variable name to plot (e.g., 'soc_pct', 'gdp_per_capita')
+        facet: Facet to use
+        geography: 'country' or 'state_us'
+        geo_id: Optional specific geo_id to filter (e.g., 'USA' for SOC data)
+        top_n: Number of top entities to show (None for all)
+        figsize: Figure size
+        title: Chart title
+        xlabel: x-axis label
+        filtered_entities: List of cluster_name or geo_id values to include
+        cmap: Colormap to use
+        normalize: If True, rescale values to sum to 100% (useful for percentages)
+        exclude_not_classified: If True, exclude 'not_classified' entries before normalizing
+    """
+    # Get data
+    df_metric = filter_df(
+        df, geography=geography, facet=facet, variable=variable, geo_id=geo_id
+    )
+
+    # Exclude not_classified if requested (before normalization)
+    if exclude_not_classified:
+        # Check both cluster_name and geo_id columns
+        if "cluster_name" in df_metric.columns:
+            df_metric = df_metric[
+                ~df_metric["cluster_name"].isin(["not_classified", "none"])
+            ]
+        if "geo_id" in df_metric.columns:
+            df_metric = df_metric[~df_metric["geo_id"].isin(["not_classified", "none"])]
+
+    # Normalize if requested (after filtering not_classified)
+    if normalize:
+        total_sum = df_metric["value"].sum()
+        if total_sum > 0:
+            df_metric["value"] = (df_metric["value"] / total_sum) * 100
+
+    # Apply entity filtering if provided
+    if filtered_entities is not None:
+        # Check if we're filtering by cluster_name or geo_id
+        if "cluster_name" in df_metric.columns:
+            df_metric = df_metric[df_metric["cluster_name"].isin(filtered_entities)]
+        else:
+            df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
+
+    # Select entities to display
+    if top_n is None or top_n >= len(df_metric):
+        # Show all entities, sorted by lowest value first
+        df_top = df_metric.sort_values("value", ascending=True)
+        # Adjust figure height for many entities
+        if len(df_top) > 20:
+            figsize = (figsize[0], max(10, len(df_top) * 0.3))
+    else:
+        # Select top N entities
+        df_top = df_metric.nlargest(top_n, "value")
+        df_top = df_top.sort_values("value", ascending=True)
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Get colormap and colors
+    values = df_top["value"].values
+    min_val = values.min()
+    max_val = values.max()
+
+    # Linear color mapping
+    if max_val > min_val:
+        normalized = (values - min_val) / (max_val - min_val)
+        # Truncate to avoid extremes
+        normalized = 0.2 + normalized * 0.6
+    else:
+        normalized = np.ones_like(values) * 0.5
+
+    colors = cmap(normalized)
+
+    # Create horizontal bars
+    y_positions = range(len(df_top))
+    bars = ax.barh(y_positions, values, color=colors, height=0.7)
+
+    # Set y-tick labels
+    ax.set_yticks(y_positions)
+    # Use cluster_name or geo_name depending on what's available
+    if "cluster_name" in df_top.columns:
+        labels = df_top["cluster_name"].values
+    elif "geo_name" in df_top.columns:
+        labels = df_top["geo_name"].values
+    else:
+        labels = df_top["geo_id"].values
+    ax.set_yticklabels(labels)
+
+    # Set y-axis limits to reduce white space
+    ax.set_ylim(-0.5, len(df_top) - 0.5)
+
+    # Calculate and set x-axis limits
+    x_range = max_val - min_val
+    if min_val < 0:
+        # Include negative values with some padding
+        ax.set_xlim(min_val - x_range * 0.1, max_val + x_range * 0.2)
+    else:
+        # Positive values only
+        ax.set_xlim(0, max_val * 1.2)
+
+    # Add value labels
+    for _, bar in enumerate(bars):
+        width = bar.get_width()
+        # Format based on value magnitude
+        if abs(width) >= 1000:
+            label = f"{width:.0f}"
+        elif abs(width) >= 10:
+            label = f"{width:.1f}"
+        else:
+            label = f"{width:.2f}"
+
+        # Position label
+        if width < 0:
+            ha = "right"
+            x_offset = -0.01 * (max_val - min_val)
+        else:
+            ha = "left"
+            x_offset = 0.01 * (max_val - min_val)
+
+        ax.text(
+            width + x_offset,
+            bar.get_y() + bar.get_height() / 2.0,
+            label,
+            ha=ha,
+            va="center",
+            fontsize=8 if len(df_top) > 20 else 9,
+        )
+
+    # Set labels and title
+    if not title:
+        if top_n:
+            title = f"Top {top_n} by {variable}"
+        else:
+            title = f"{variable} distribution"
+
+    format_axis(
+        ax,
+        xlabel=xlabel or variable,
+        title=title,
+        grid=True,
+        grid_alpha=0.3,
+    )
+
+    return fig
+
+
+def plot_usage_share_bars(
+    df,
+    geography="country",
+    top_n=20,
+    figsize=(12, 8),
+    title=None,
+    filtered_entities=None,
+    cmap=CUSTOM_CMAP,
+):
+    """
+    Create bar chart showing share of global usage.
+
+    Args:
+        df: Long format dataframe
+        geography: Geographic level
+        top_n: Number of top entities
+        figsize: Figure size
+        title: Chart title
+        filtered_entities: List of geo_id values to include (if None, include all)
+
+    """
+    # Get data
+    df_metric = filter_df(
+        df, geography=geography, facet=geography, variable="usage_pct"
+    )
+
+    # Exclude "not_classified" from the data
+    df_metric = df_metric[df_metric["geo_id"] != "not_classified"]
+
+    # Apply entity filtering if provided
+    if filtered_entities is not None:
+        df_metric = df_metric[df_metric["geo_id"].isin(filtered_entities)]
+
+    # Get top n
+    df_top = df_metric.nlargest(top_n, "value")
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Create bars
+    positions = range(len(df_top))
+    values = df_top["value"].values
+    names = df_top["geo_name"].values
+
+    # Use custom colormap
+    norm = get_color_normalizer(values, center_at_one=False)
+    colors = [cmap(norm(val)) for val in values]
+
+    bars = ax.bar(positions, values, color=colors, alpha=0.8)
+
+    # Customize
+    ax.set_xticks(positions)
+    ax.set_xticklabels(names, rotation=45, ha="right")
+    # Reduce horizontal margins to bring bars closer to plot borders
+    ax.margins(x=0.01)
+
+    default_title = f"Top {top_n} {'countries' if geography == 'country' else 'US states'} by share of global Claude usage"
+    format_axis(
+        ax, ylabel="Share of global usage (%)", title=title or default_title, grid=False
+    )
+
+    # Add value labels
+    for bar, value in zip(bars, values, strict=True):
+        label = f"{value:.1f}%"
+
+        # Add value label above the bar
+        ax.text(
+            bar.get_x() + bar.get_width() / 2,
+            value + 0.1,
+            label,
+            ha="center",
+            fontsize=8,
+        )
+
+    # Grid
+    ax.grid(True, axis="y", alpha=0.3)
+
+    return fig
+
+
+def plot_usage_index_histogram(
+    df, geography="country", bins=30, figsize=(10, 6), title=None, cmap=CUSTOM_CMAP
+):
+    """
+    Create histogram of Anthropic AI Usage Index distribution.
+
+    Args:
+        df: Long format dataframe
+        geography: Geographic level
+        bins: Number of histogram bins
+        figsize: Figure size
+        title: Chart title
+    """
+    # Get data
+    df_metric = filter_df(
+        df, geography=geography, facet=geography, variable="usage_per_capita_index"
+    )
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Create histogram
+    values = df_metric["value"].values
+    _, bins_edges, patches = ax.hist(
+        values, bins=bins, edgecolor="white", linewidth=0.5
+    )
+
+    # Color bars with custom gradient based on value
+    norm = get_color_normalizer(
+        values,
+        center_at_one=False,
+        vmin=min(bins_edges[0], 0),
+        vmax=max(bins_edges[-1], 2),
+    )
+
+    for patch, left_edge, right_edge in zip(
+        patches, bins_edges[:-1], bins_edges[1:], strict=True
+    ):
+        # Use the midpoint of the bin for color
+        mid_val = (left_edge + right_edge) / 2
+        color = cmap(norm(mid_val))
+        patch.set_facecolor(color)
+
+    # Add vertical line at 1.0 (where usage and population shares match)
+    ax.axvline(x=1.0, color="black", linestyle="--", alpha=0.5, linewidth=1)
+
+    # Add statistics
+    mean_val = values.mean()
+    median_val = np.median(values)
+
+    stats_text = f"Mean: {mean_val:.2f}\nMedian: {median_val:.2f}\nN = {len(values)}"
+    ax.text(
+        0.98,
+        0.97,
+        stats_text,
+        transform=ax.transAxes,
+        ha="right",
+        va="top",
+        fontsize=9,
+        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+    )
+
+    # Customize
+    geo_label = "countries" if geography == "country" else "US states"
+    default_title = f"Distribution of Anthropic AI Usage Index ({geo_label})"
+
+    format_axis(
+        ax,
+        xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
+        ylabel=f"Number of {geo_label}",
+        title=title or default_title,
+    )
+
+    return fig
+
+
+def plot_gdp_scatter(
+    df,
+    geography="country",
+    figsize=(10, 8),
+    title=None,
+    cmap=CUSTOM_CMAP,
+    filtered_entities=None,
+):
+    """
+    Create log-log scatter plot of GDP vs Anthropic AI Usage Index.
+
+    Args:
+        df: Long format dataframe
+        geography: Geographic level
+        figsize: Figure size
+        title: Chart title
+        cmap: Colormap to use
+        filtered_entities: List of geo_id values that meet MIN_OBSERVATIONS threshold (optional)
+    """
+    # Get usage data
+    df_usage = filter_df(
+        df, geography=geography, facet=geography, variable="usage_per_capita_index"
+    )
+
+    # Apply filtering if provided
+    if filtered_entities is not None:
+        df_usage = df_usage[df_usage["geo_id"].isin(filtered_entities)]
+
+    df_usage = df_usage[["geo_id", "cluster_name", "value"]].rename(
+        columns={"value": "usage_index"}
+    )
+
+    # Get GDP data
+    df_gdp = filter_df(
+        df, geography=geography, facet=geography, variable="gdp_per_working_age_capita"
+    )
+
+    # Apply same filtering to GDP data
+    if filtered_entities is not None:
+        df_gdp = df_gdp[df_gdp["geo_id"].isin(filtered_entities)]
+
+    df_gdp = df_gdp[["geo_id", "value"]].rename(columns={"value": "gdp_per_capita"})
+
+    # Merge
+    df_plot = df_usage.merge(df_gdp, on="geo_id", how="inner")
+
+    # Filter out zeros and negative values for log scale
+    # Explicitly check both GDP and usage are positive (will be true for filtered geos)
+    mask = (df_plot["gdp_per_capita"] > 0) & (df_plot["usage_index"] > 0)
+    df_plot = df_plot[mask]
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Create scatter plot with geo_id values as labels
+    x = df_plot["gdp_per_capita"].values
+    y = df_plot["usage_index"].values
+
+    # Transform to log space for plotting
+    log_x = np.log(x)
+    log_y = np.log(y)
+
+    # Create norm for colorbar (using natural log)
+    norm = plt.Normalize(vmin=log_y.min(), vmax=log_y.max())
+
+    # First, plot invisible points to ensure matplotlib's autoscaling includes all data points
+    ax.scatter(log_x, log_y, s=0, alpha=0)  # Size 0, invisible points for autoscaling
+
+    # Plot the geo_id values as text at the exact data points in log space
+    for ln_x, ln_y, geo_id in zip(log_x, log_y, df_plot["geo_id"].values, strict=True):
+        # Get color from colormap based on ln(usage_index)
+        color_val = norm(ln_y)
+        text_color = cmap(color_val)
+
+        ax.text(
+            ln_x,
+            ln_y,
+            geo_id,
+            fontsize=7,
+            ha="center",
+            va="center",
+            color=text_color,
+            alpha=0.9,
+            weight="bold",
+        )
+
+    # Add constant for intercept
+    X_with_const = sm.add_constant(log_x)
+
+    # Fit OLS regression in log space
+    model = sm.OLS(log_y, X_with_const)
+    results = model.fit()
+
+    # Extract statistics
+    intercept = results.params[0]
+    slope = results.params[1]
+    r_squared = results.rsquared
+    p_value = results.pvalues[1]  # p-value for slope
+
+    # Create fit line (we're already in log space)
+    x_fit = np.linspace(log_x.min(), log_x.max(), 100)
+    y_fit = intercept + slope * x_fit
+    ax.plot(
+        x_fit,
+        y_fit,
+        "gray",
+        linestyle="--",
+        alpha=0.7,
+        linewidth=2,
+        label=f"Power law: AUI ~ GDP^{slope:.2f}",
+    )
+
+    # Add regression statistics
+    # Format p-value display
+    if p_value < 0.001:
+        p_str = "p < 0.001"
+    else:
+        p_str = f"p = {p_value:.3f}"
+
+    ax.text(
+        0.05,
+        0.95,
+        f"$\\beta = {slope:.3f}\\ ({p_str})$\n$R^2 = {r_squared:.3f}$",
+        transform=ax.transAxes,
+        fontsize=10,
+        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+        verticalalignment="top",
+    )
+
+    # Customize labels for log-transformed values
+    xlabel = "ln(GDP per working-age capita in USD)"
+    ylabel = "ln(Anthropic AI Usage Index)"
+    default_title = f"Income and Anthropic AI Usage Index by {'country' if geography == 'country' else 'US state'}"
+
+    format_axis(
+        ax, xlabel=xlabel, ylabel=ylabel, title=title or default_title, grid=False
+    )
+
+    # Grid for log scale
+    ax.grid(True, alpha=0.3, which="both", linestyle="-", linewidth=0.5)
+
+    # Add legend
+    ax.legend(loc="best")
+
+    # Create colorbar using ScalarMappable
+    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    scalar_mappable.set_array([])
+    cbar = plt.colorbar(scalar_mappable, ax=ax)
+    cbar.set_label(
+        "ln(Anthropic AI Usage Index)", fontsize=9, rotation=270, labelpad=15
+    )
+
+    return fig
+
+
+def plot_request_comparison_cards(
+    df,
+    geo_ids,
+    title,
+    geography,
+    top_n=5,
+    figsize=(10, 6),
+    exclude_not_classified=True,
+    request_level=1,
+    request_threshold=1.0,
+):
+    """
+    Create a condensed card visualization showing top overrepresented request categories
+    for multiple geographies (countries or states).
+
+    Args:
+        df: Long format dataframe
+        geo_ids: List of geography IDs to compare (e.g., ['USA', 'BRA', 'VNM', 'IND'])
+        title: Title for the figure (required)
+        geography: Geographic level ('country' or 'state_us')
+        top_n: Number of top requests to show per geography (default 5)
+        figsize: Figure size as tuple
+        exclude_not_classified: Whether to exclude "not_classified" entries
+        request_level: Request hierarchy level to use (default 1)
+        request_threshold: Minimum percentage threshold for requests (default 1.0%)
+    """
+    # Get data for specified geography
+    data_subset = filter_df(df, facet="request", geo_id=geo_ids, geography=geography)
+
+    # Filter for request_pct_index variable and specified level
+    data_subset = filter_df(
+        data_subset, variable="request_pct_index", level=request_level
+    )
+
+    # Exclude not_classified if requested
+    if exclude_not_classified:
+        data_subset = data_subset[
+            ~data_subset["cluster_name"].str.contains("not_classified", na=False)
+        ]
+
+    # Get tier and geo_name information
+    geo_info = filter_df(
+        df, geography=geography, variable="usage_tier", geo_id=geo_ids
+    )[["geo_id", "geo_name", "value"]].drop_duplicates()
+    tier_map = dict(zip(geo_info["geo_id"], geo_info["value"], strict=True))
+    name_map = dict(zip(geo_info["geo_id"], geo_info["geo_name"], strict=True))
+
+    # Set up figure with 2x2 grid for 4 geographies
+    n_rows, n_cols = 2, 2
+    fig, axes = create_figure(figsize=figsize, nrows=n_rows, ncols=n_cols)
+    axes = axes.flatten()
+
+    # Use global tier colors
+    tier_colors = TIER_COLORS_NUMERIC
+
+    # Process each geography
+    for idx, geo_id in enumerate(geo_ids):
+        ax = axes[idx]
+
+        # Apply request threshold filtering to get valid requests for this geography
+        valid_requests = filter_requests_by_threshold(
+            df, geography, geo_id, level=request_level, threshold=request_threshold
+        )
+
+        # Get data for this geography, filtered by valid requests
+        geo_data = data_subset[
+            (data_subset["geo_id"] == geo_id)
+            & (data_subset["cluster_name"].isin(valid_requests))
+            & (data_subset["value"] > 1.0)  # Only show overrepresented requests
+        ].copy()
+
+        # Get top n from the filtered requests
+        geo_data = geo_data.nlargest(top_n, "value")
+
+        # Get tier color
+        tier = tier_map[geo_id]
+        base_color = tier_colors[tier]
+
+        # Create a lighter version of the tier color for the card background
+        rgb = mcolors.to_rgb(base_color)
+        # Mix with white (85% white, 15% color for very subtle background)
+        pastel_rgb = tuple(0.85 + 0.15 * c for c in rgb)
+        card_bg_color = mcolors.to_hex(pastel_rgb)
+
+        # Fill entire axis with background color
+        ax.set_facecolor(card_bg_color)
+
+        # Create card with requests
+        card_height = 0.9  # Fixed height for all cards
+        card_bottom = 0.965 - card_height  # Consistent positioning
+
+        card_rect = FancyBboxPatch(
+            (0.10, card_bottom),
+            0.80,
+            card_height,
+            transform=ax.transAxes,
+            boxstyle="round,pad=0.02,rounding_size=0.035",
+            facecolor=card_bg_color,
+            edgecolor="none",
+            linewidth=2,
+            clip_on=False,
+        )
+        ax.add_patch(card_rect)
+
+        # Header bar
+        header_top = 0.965 - 0.10
+        header_rect = FancyBboxPatch(
+            (0.14, header_top),
+            0.72,
+            0.08,
+            transform=ax.transAxes,
+            boxstyle="round,pad=0.01,rounding_size=0.03",
+            facecolor=base_color,
+            edgecolor="none",
+            alpha=0.7,
+            clip_on=False,
+        )
+        ax.add_patch(header_rect)
+
+        # Add geography name
+        geo_name = name_map[geo_id]
+
+        ax.text(
+            0.5,
+            header_top + 0.04,
+            geo_name,
+            transform=ax.transAxes,
+            ha="center",
+            va="center",
+            fontsize=12,
+            fontweight="bold",
+            color="#1C1C1C",
+        )
+
+        # Adjust start position below header upwards
+        y_pos = header_top - 0.05
+
+        for _, row in geo_data.iterrows():
+            request = row["cluster_name"]
+            value = row["value"]
+
+            # Format ratio
+            if value >= 10:
+                ratio_str = f"{value:.0f}x"
+            elif value >= 2:
+                ratio_str = f"{value:.1f}x"
+            else:
+                ratio_str = f"{value:.2f}x"
+
+            # Wrap text
+            wrapped_text = textwrap.fill(request, width=46, break_long_words=False)
+            lines = wrapped_text.split("\n")
+
+            # Display text lines with sufficient line spacing
+            line_spacing = 0.045
+            for j, line in enumerate(lines):
+                ax.text(
+                    0.13,  # Adjust text position for wider card
+                    y_pos - j * line_spacing,
+                    line,
+                    transform=ax.transAxes,
+                    ha="left",
+                    va="top",
+                    fontsize=9,
+                    color="#1C1C1C",
+                    rasterized=False,
+                )
+
+            # Position ratio with adjusted margin for wide card
+            text_height = len(lines) * line_spacing
+            ax.text(
+                0.85,
+                y_pos - (text_height - line_spacing) / 2,
+                ratio_str,
+                transform=ax.transAxes,
+                ha="right",
+                va="center",
+                fontsize=10,
+                fontweight="bold",
+                color="#B85450",
+                rasterized=False,
+            )
+
+            # Add space between different requests
+            y_pos -= text_height + 0.05
+
+        # Remove axes
+        ax.axis("off")
+
+    # Add title
+    fig.suptitle(title, fontsize=14, fontweight="bold", y=0.98)
+
+    plt.tight_layout()
+    plt.subplots_adjust(
+        top=0.92, bottom=0.02, left=0.01, right=0.99, hspace=0.02, wspace=0.02
+    )
+
+    return fig
+
+
+def plot_dc_task_request_cards(
+    df,
+    title,
+    figsize=(10, 5),
+):
+    """
+    Create professional card visualizations showing top overrepresented O*NET tasks and requests for Washington, DC.
+
+    Args:
+        df: Long format dataframe
+        figsize: Figure size as tuple
+        title: Optional title for the figure
+    """
+    # Fixed parameters for DC
+    geo_id = "DC"
+    geography = "state_us"
+    top_n = 5
+
+    # Get tier for color
+    tier_data = filter_df(
+        df, geography=geography, variable="usage_tier", geo_id=[geo_id]
+    )
+    tier = tier_data["value"].iloc[0]
+
+    # Use tier color
+    tier_colors = TIER_COLORS_NUMERIC
+    base_color = tier_colors[tier]
+
+    # Create lighter version for card background
+    rgb = mcolors.to_rgb(base_color)
+    pastel_rgb = tuple(0.85 + 0.15 * c for c in rgb)
+    card_bg_color = mcolors.to_hex(pastel_rgb)
+
+    # Create figure with 2 subplots (cards)
+    fig, axes = create_figure(figsize=figsize, ncols=2)
+
+    # Card 1: Top O*NET Tasks
+    ax1 = axes[0]
+    ax1.set_facecolor(card_bg_color)
+
+    # Get O*NET task data
+    df_tasks = filter_df(
+        df,
+        geography=geography,
+        geo_id=[geo_id],
+        facet="onet_task",
+        variable="onet_task_pct_index",
+    )
+
+    # Exclude not_classified and none
+    df_tasks = df_tasks[~df_tasks["cluster_name"].isin(["not_classified", "none"])]
+
+    # Get top n overrepresented tasks
+    df_tasks = df_tasks[df_tasks["value"] > 1.0].nlargest(top_n, "value")
+
+    # Use fixed card heights
+    card_height_tasks = 0.955
+    card_bottom_tasks = 0.965 - card_height_tasks
+
+    # Draw card for O*NET tasks
+    card_rect1 = FancyBboxPatch(
+        (0.10, card_bottom_tasks),
+        0.80,
+        card_height_tasks,
+        transform=ax1.transAxes,
+        boxstyle="round,pad=0.02,rounding_size=0.035",
+        facecolor=card_bg_color,
+        edgecolor="none",
+        linewidth=2,
+        clip_on=False,
+    )
+    ax1.add_patch(card_rect1)
+
+    # Header for O*NET tasks
+    header_top = 0.965 - 0.10
+    header_rect1 = FancyBboxPatch(
+        (0.12, header_top),
+        0.76,
+        0.08,
+        transform=ax1.transAxes,
+        boxstyle="round,pad=0.01,rounding_size=0.03",
+        facecolor=base_color,
+        edgecolor="none",
+        alpha=0.7,
+        clip_on=False,
+    )
+    ax1.add_patch(header_rect1)
+
+    ax1.text(
+        0.5,
+        header_top + 0.04,
+        "Top 5 overrepresented O*NET tasks in DC",
+        transform=ax1.transAxes,
+        ha="center",
+        va="center",
+        fontsize=11,
+        fontweight="bold",
+        color="#1C1C1C",
+    )
+
+    # Add task items
+    y_pos = header_top - 0.05
+
+    for _, row in df_tasks.iterrows():
+        task = row["cluster_name"]
+        value = row["value"]
+
+        # Convert to sentence case and remove trailing period
+        task = task[0].upper() + task[1:].lower() if task else task
+        task = task.rstrip(".")  # Remove trailing period
+
+        # Format ratio - always with 2 decimal places
+        ratio_str = f"{value:.2f}x"
+
+        # Wrap text
+        wrapped_text = textwrap.fill(task, width=46, break_long_words=False)
+        lines = wrapped_text.split("\n")
+
+        # Display text lines
+        line_spacing = 0.045
+        for j, line in enumerate(lines):
+            ax1.text(
+                0.13,
+                y_pos - j * line_spacing,
+                line,
+                transform=ax1.transAxes,
+                ha="left",
+                va="top",
+                fontsize=9,
+                color="#1C1C1C",
+                rasterized=False,
+            )
+
+        # Add ratio at the right with consistent color
+        ax1.text(
+            0.87,
+            y_pos - (len(lines) - 1) * line_spacing / 2,
+            ratio_str,
+            transform=ax1.transAxes,
+            ha="right",
+            va="center",
+            fontsize=10,
+            color="#B85450",
+            fontweight="bold",
+        )
+
+        # Move to next item position
+        y_pos -= len(lines) * line_spacing + 0.025
+
+    ax1.axis("off")
+
+    # Card 2: Top Requests
+    ax2 = axes[1]
+    ax2.set_facecolor(card_bg_color)
+
+    # Get valid requests using threshold
+    valid_requests = filter_requests_by_threshold(
+        df, geography, geo_id, level=1, threshold=1.0
+    )
+
+    # Get request data
+    df_requests = filter_df(
+        df,
+        geography=geography,
+        geo_id=[geo_id],
+        facet="request",
+        variable="request_pct_index",
+        level=1,
+    )
+
+    # Filter by valid requests and overrepresented
+    df_requests = df_requests[
+        (df_requests["cluster_name"].isin(valid_requests))
+        & (df_requests["value"] > 1.0)
+        & (~df_requests["cluster_name"].str.contains("not_classified", na=False))
+    ]
+
+    # Get top n
+    df_requests = df_requests.nlargest(top_n, "value")
+
+    # Draw card for requests with fixed height
+    card_height_requests = 0.72
+    card_bottom_requests = 0.965 - card_height_requests
+
+    card_rect2 = FancyBboxPatch(
+        (0.10, card_bottom_requests),
+        0.80,
+        card_height_requests,
+        transform=ax2.transAxes,
+        boxstyle="round,pad=0.02,rounding_size=0.035",
+        facecolor=card_bg_color,
+        edgecolor="none",
+        linewidth=2,
+        clip_on=False,
+    )
+    ax2.add_patch(card_rect2)
+
+    # Header for requests
+    header_rect2 = FancyBboxPatch(
+        (0.12, header_top),
+        0.76,
+        0.08,
+        transform=ax2.transAxes,
+        boxstyle="round,pad=0.01,rounding_size=0.03",
+        facecolor=base_color,
+        edgecolor="none",
+        alpha=0.7,
+        clip_on=False,
+    )
+    ax2.add_patch(header_rect2)
+
+    ax2.text(
+        0.5,
+        header_top + 0.04,
+        "Top 5 overrepresented request clusters in DC",
+        transform=ax2.transAxes,
+        ha="center",
+        va="center",
+        fontsize=11,
+        fontweight="bold",
+        color="#1C1C1C",
+    )
+
+    # Add request items
+    y_pos = header_top - 0.05
+
+    for _, row in df_requests.iterrows():
+        request = row["cluster_name"]
+        value = row["value"]
+
+        # Format ratio always with 2 decimal places
+        ratio_str = f"{value:.2f}x"
+
+        # Wrap text
+        wrapped_text = textwrap.fill(request, width=46, break_long_words=False)
+        lines = wrapped_text.split("\n")
+
+        # Display text lines
+        line_spacing = 0.045
+        for j, line in enumerate(lines):
+            ax2.text(
+                0.13,
+                y_pos - j * line_spacing,
+                line,
+                transform=ax2.transAxes,
+                ha="left",
+                va="top",
+                fontsize=9,
+                color="#1C1C1C",
+                rasterized=False,
+            )
+
+        # Add ratio at the right with consistent color
+        ax2.text(
+            0.87,
+            y_pos - (len(lines) - 1) * line_spacing / 2,
+            ratio_str,
+            transform=ax2.transAxes,
+            ha="right",
+            va="center",
+            fontsize=10,
+            color="#B85450",
+            fontweight="bold",
+        )
+
+        # Move to next item position
+        y_pos -= len(lines) * line_spacing + 0.025
+
+    ax2.axis("off")
+
+    # Add subtle title if provided
+    fig.suptitle(title, fontsize=13, fontweight="bold", y=0.98)
+
+    plt.tight_layout()
+    return fig
+
+
+# Summary statistics function
+def plot_tier_summary_table(df, geography="country", figsize=(12, 6)):
+    """
+    Create a visual table showing entities per tier and example members.
+
+    Args:
+        df: Long format dataframe
+        geography: 'country' or 'state_us'
+        figsize: Figure size
+    """
+    # Get tier data
+    df_tier = filter_df(df, geography=geography, variable="usage_tier")
+
+    # Exclude US territories that appear as countries (may be confusing to readers)
+    if geography == "country":
+        us_territories_as_countries = [
+            "PRI",
+            "VIR",
+            "GUM",
+            "ASM",
+            "MNP",
+        ]  # Puerto Rico, Virgin Islands, Guam, American Samoa, Northern Mariana Islands
+        df_tier = df_tier[~df_tier["geo_id"].isin(us_territories_as_countries)]
+
+    # Get usage per capita index for sorting entities within tiers
+    df_usage_index = filter_df(
+        df, geography=geography, variable="usage_per_capita_index"
+    )
+
+    # Apply same territory filter to usage index data
+    if geography == "country":
+        df_usage_index = df_usage_index[
+            ~df_usage_index["geo_id"].isin(us_territories_as_countries)
+        ]
+
+    # Merge tier with usage index
+    df_tier_full = df_tier[["geo_id", "geo_name", "cluster_name"]].merge(
+        df_usage_index[["geo_id", "value"]],
+        on="geo_id",
+        how="left",
+        suffixes=("", "_index"),
+    )
+
+    # Use global tier colors
+    tier_colors = TIER_COLORS_DICT
+
+    # Calculate appropriate figure height based on number of tiers
+    n_tiers = sum(
+        1 for tier in TIER_ORDER if tier in df_tier_full["cluster_name"].values
+    )
+    # Adjust height: minimal padding for compact display
+    fig_height = 0.5 + n_tiers * 0.3  # Much more compact
+
+    # Create figure with calculated size
+    fig, ax = create_figure(figsize=(figsize[0], fig_height))
+    ax.axis("tight")
+    ax.axis("off")
+
+    # Make background transparent
+    fig.patch.set_alpha(0.0)
+    ax.patch.set_alpha(0.0)
+
+    # Prepare table data
+    table_data = []
+    entity_type = "countries" if geography == "country" else "states"
+    col_labels = [
+        "Tier",
+        "AUI range",
+        f"# of {entity_type}",
+        f"Example {entity_type}",
+    ]
+
+    for tier in TIER_ORDER:
+        if tier in df_tier_full["cluster_name"].values:
+            # Get entities in this tier
+            tier_entities = filter_df(df_tier_full, cluster_name=tier)
+            count = len(tier_entities)
+
+            # Calculate usage index range for this tier
+            min_index = tier_entities["value"].min()
+            max_index = tier_entities["value"].max()
+            index_range = f"{min_index:.2f} - {max_index:.2f}"
+
+            # For Minimal tier where all have 0 index, pick shortest names
+            if tier == "Minimal" and tier_entities["value"].max() == 0:
+                tier_entities = tier_entities.copy()
+                tier_entities["name_length"] = tier_entities["geo_name"].str.len()
+                top_entities = tier_entities.nsmallest(5, "name_length")[
+                    "geo_name"
+                ].tolist()
+            else:
+                # Get top 5 entities by usage index in this tier
+                top_entities = tier_entities.nlargest(5, "value")["geo_name"].tolist()
+
+            # Format the example entities as a comma-separated string
+            examples = ", ".join(top_entities[:5])
+
+            table_data.append([tier, index_range, str(count), examples])
+
+    # Create table with better column widths
+    table = ax.table(
+        cellText=table_data,
+        colLabels=col_labels,
+        cellLoc="left",
+        loc="center",
+        colWidths=[0.20, 0.18, 0.12, 0.50],
+        colColours=[ANTHROPIC_OAT] * 4,
+    )
+
+    # Style the table
+    table.auto_set_font_size(False)
+    table.set_fontsize(11)
+    table.scale(1, 2.2)
+
+    # Set all cell edges to Anthropic oat color
+    for _, cell in table.get_celld().items():
+        cell.set_edgecolor(ANTHROPIC_OAT)
+        cell.set_linewidth(1.5)
+
+    # Color code the rows with consistent black text
+    for i, row_data in enumerate(table_data):
+        tier_name = row_data[0]
+        if tier_name in tier_colors:
+            # Color the tier name cell with full opacity
+            table[(i + 1, 0)].set_facecolor(tier_colors[tier_name])
+            table[(i + 1, 0)].set_text_props(color="black", weight="bold")
+
+            # Light background for usage index range column
+            table[(i + 1, 1)].set_facecolor(tier_colors[tier_name])
+            table[(i + 1, 1)].set_alpha(0.3)
+            table[(i + 1, 1)].set_text_props(ha="center", color="black")
+
+            # Light background for count column
+            table[(i + 1, 2)].set_facecolor(tier_colors[tier_name])
+            table[(i + 1, 2)].set_alpha(0.2)
+            table[(i + 1, 2)].set_text_props(ha="center", color="black")
+
+            # Even lighter background for examples column
+            table[(i + 1, 3)].set_facecolor(tier_colors[tier_name])
+            table[(i + 1, 3)].set_alpha(0.1)
+            table[(i + 1, 3)].set_text_props(color="black")
+
+    # Style header row with Anthropic oat and black text
+    for j in range(4):
+        table[(0, j)].set_facecolor(ANTHROPIC_OAT)
+        table[(0, j)].set_text_props(color="black", weight="bold")
+
+    # Center the count column
+    for i in range(len(table_data)):
+        table[(i + 1, 1)].set_text_props(ha="center")
+
+    return fig
+
+
+def plot_tier_map(
+    df,
+    title,
+    geography,
+    figsize=(16, 10),
+    show_labels=True,
+):
+    """
+    Create a map showing per Anthropic AI Usage Tiers.
+
+    Args:
+        df: Long format dataframe with usage_tier variable
+        geography: 'country' or 'state_us'
+        figsize: Figure size
+        title: Map title
+        show_labels: whether to show title and legend (False for clean export)
+    """
+    # Filter for tier data
+    df_tier = filter_df(df, geography=geography, variable="usage_tier").copy()
+
+    # Use global tier colors definition
+    tier_colors = TIER_COLORS_DICT
+
+    # Map tiers to colors
+    df_tier["color"] = df_tier["cluster_name"].map(tier_colors)
+
+    # Set up figure
+    # Create figure with tight_layout disabled
+    fig, ax = create_figure(figsize=figsize, tight_layout=False)
+
+    if geography == "country":
+        # Load world shapefile function
+        world = load_world_shapefile()
+
+        # Merge with world data using geo_id (which contains ISO-3 codes)
+        # Use ISO_A3_EH for merging as it's complete (ISO_A3 has -99 for France)
+        world = merge_geo_data(
+            world,
+            df_tier,
+            "ISO_A3_EH",
+            ["geo_id", "color", "cluster_name"],
+            is_tier=True,
+        )
+
+        # Plot world map
+        plot_world_map(ax, world, data_column="cluster_name", tier_colors=tier_colors)
+
+    else:  # state_us
+        # Load US states shapefile function
+        states = load_us_states_shapefile()
+
+        # Merge with tier data BEFORE projection
+        states = merge_geo_data(
+            states, df_tier, "STUSPS", ["geo_id", "color", "cluster_name"], is_tier=True
+        )
+
+        # Pot states with insets
+        plot_us_states_map(
+            fig, ax, states, data_column="cluster_name", tier_colors=tier_colors
+        )
+
+    # Remove axes
+    ax.set_axis_off()
+
+    # Add title only if show_labels=True
+    if show_labels:
+        format_axis(ax, title=title, title_size=14, grid=False)
+
+    # Check which tiers actually appear in the data
+    tiers_in_data = df_tier["cluster_name"].unique()
+
+    # Add legend only if show_labels=True
+    if show_labels:
+        # Check for excluded countries and no data
+        excluded = False
+        no_data = False
+        if geography == "country":
+            if "world" in locals() and "is_excluded" in world.columns:
+                excluded = world["is_excluded"].any()
+            if "world" in locals():
+                no_data = world["cluster_name"].isna().any()
+        else:  # state_us
+            if "states" in locals():
+                no_data = states["cluster_name"].isna().any()
+
+        create_tier_legend(
+            ax, tier_colors, tiers_in_data, excluded_countries=excluded, no_data=no_data
+        )
+
+    return fig
+
+
+def plot_variable_map(
+    df,
+    variable,
+    geography="country",
+    figsize=(16, 10),
+    title=None,
+    cmap=CUSTOM_CMAP,
+    center_at_one=None,
+):
+    """
+    Create static map for any variable.
+
+    Args:
+        df: Long format dataframe
+        variable: Variable to plot (e.g., 'usage_pct')
+        geography: 'country' or 'state_us'
+        figsize: Figure size (width, height) in inches
+        title: Map title
+        cmap: Matplotlib colormap or name (default uses custom colormap)
+        center_at_one: Whether to center the color scale at 1.0 (default True for usage_per_capita_index)
+    """
+    # Get data for the specified variable
+    df_data = filter_df(df, geography=geography, facet=geography, variable=variable)
+
+    # Create figure
+    fig = plt.figure(figsize=figsize, dpi=150)
+    fig.set_layout_engine(layout="none")  # Disable layout engine for custom axes
+    ax = fig.add_subplot(111)
+
+    if geography == "country":
+        # Load world shapefile function (automatically marks excluded countries)
+        world = load_world_shapefile()
+
+        # Merge using geo_id (which contains ISO-3 codes)
+        world = merge_geo_data(
+            world, df_data, "ISO_A3_EH", ["geo_id", "value"], is_tier=False
+        )
+
+        # Prepare data and normalization
+        plot_column, norm = prepare_map_data(
+            world, "value", center_at_one, world["is_excluded"]
+        )
+
+        # Plot world map
+        plot_world_map(ax, world, data_column=plot_column, cmap=cmap, norm=norm)
+
+    else:  # state_us
+        # Load US states shapefile function
+        states = load_us_states_shapefile()
+
+        # Merge our data with the states shapefile
+        states = merge_geo_data(
+            states, df_data, "STUSPS", ["geo_id", "value"], is_tier=False
+        )
+
+        # Prepare data and normalization
+        plot_column, norm = prepare_map_data(states, "value", center_at_one)
+
+        # Plot states with insets
+        plot_us_states_map(
+            fig, ax, states, data_column=plot_column, cmap=cmap, norm=norm
+        )
+
+    # Remove axes
+    ax.set_axis_off()
+
+    # Add colorbar with proper size and positioning
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="3%", pad=0.1)
+
+    # Create colorbar
+    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    scalar_mappable.set_array([])
+    cbar = plt.colorbar(scalar_mappable, cax=cax)
+
+    # Set colorbar label based on variable
+    if variable == "usage_pct":
+        cbar.set_label("Usage share (%)", fontsize=10, rotation=270, labelpad=15)
+    elif variable == "usage_per_capita_index":
+        cbar.set_label(
+            "Anthropic AI Usage Index", fontsize=10, rotation=270, labelpad=15
+        )
+    else:
+        cbar.set_label(variable, fontsize=10, rotation=270, labelpad=15)
+
+    # Set title
+    if variable == "usage_pct":
+        default_title = "Share of Claude usage by " + (
+            "country" if geography == "country" else "US state"
+        )
+    else:
+        default_title = f"{variable} by " + (
+            "country" if geography == "country" else "US state"
+        )
+
+    format_axis(ax, title=title or default_title, title_size=14, grid=False)
+
+    # Add legend for excluded countries and no data
+    legend_elements = []
+
+    # Check if we have excluded countries or no data regions
+    if geography == "country":
+        # Check for excluded countries (world['is_excluded'] == True)
+        if "is_excluded" in world.columns:
+            excluded_countries = world[world["is_excluded"] == True]
+            if not excluded_countries.empty:
+                legend_elements.append(
+                    Patch(
+                        facecolor="#c0c0c0",
+                        edgecolor="white",
+                        label="Claude not available",
+                    )
+                )
+
+            # Check for countries with no data
+            no_data_countries = world[
+                (world["value"].isna()) & (world["is_excluded"] != True)
+            ]
+            if not no_data_countries.empty:
+                legend_elements.append(
+                    Patch(facecolor="#f0f0f0", edgecolor="white", label="No data")
+                )
+
+    if legend_elements:
+        ax.legend(
+            handles=legend_elements,
+            loc="lower left",
+            fontsize=9,
+            frameon=True,
+            fancybox=True,
+            shadow=True,
+            bbox_to_anchor=(0, 0),
+        )
+
+    return fig
+
+
+def plot_soc_usage_scatter(
+    df,
+    geography,
+    filtered_entities=None,
+):
+    """
+    Create faceted scatterplot of SOC percentages vs Anthropic AI Usage Index.
+    Always creates a 2x2 grid of square subplots showing the top 4 SOC groups.
+
+    Args:
+        df: Long format dataframe with enriched data
+        geography: 'country' or 'state_us'
+        filtered_entities: List of geo_id values that meet MIN_OBSERVATIONS threshold
+    """
+    # Fixed configuration for 2x2 grid
+    n_cols = 2
+    n_rows = 2
+    n_top_groups = 4
+
+    # Apply MIN_OBSERVATIONS filtering if not provided
+    if filtered_entities is None:
+        filtered_countries, filtered_states = get_filtered_geographies(df)
+        filtered_entities = (
+            filtered_countries if geography == "country" else filtered_states
+        )
+
+    # Get Anthropic AI Usage Index data
+    df_usage_index = filter_df(
+        df,
+        geography=geography,
+        variable="usage_per_capita_index",
+        geo_id=filtered_entities,
+    )[["geo_id", "value"]].rename(columns={"value": "ai_usage_index"})
+
+    # Get usage counts for bubble sizes
+    df_usage = filter_df(
+        df, geography=geography, variable="usage_count", geo_id=filtered_entities
+    )[["geo_id", "value"]].rename(columns={"value": "usage_count"})
+
+    # Get tier data for colors
+    df_tier = filter_df(
+        df, geography=geography, variable="usage_tier", geo_id=filtered_entities
+    )[["geo_id", "cluster_name", "value"]].rename(
+        columns={"cluster_name": "tier_name", "value": "tier_value"}
+    )
+
+    # Get SOC percentages
+    df_soc = filter_df(
+        df,
+        geography=geography,
+        facet="soc_occupation",
+        variable="soc_pct",
+        geo_id=filtered_entities,
+    )[["geo_id", "cluster_name", "value"]].rename(
+        columns={"cluster_name": "soc_group", "value": "soc_pct"}
+    )
+
+    # Merge all data
+    df_plot = df_soc.merge(
+        df_usage_index, on="geo_id", how="inner"
+    )  # inner join because some geographies don't have data for all SOC groups
+    df_plot = df_plot.merge(df_usage, on="geo_id", how="left")
+    df_plot = df_plot.merge(
+        df_tier[["geo_id", "tier_name", "tier_value"]], on="geo_id", how="left"
+    )
+
+    # Use parent geography reference for consistent SOC selection
+    if geography == "country":
+        # Use global reference for countries
+        reference_soc = filter_df(
+            df,
+            geography="global",
+            geo_id="GLOBAL",
+            facet="soc_occupation",
+            variable="soc_pct",
+        )
+    else:  # state_us
+        # Use US reference for states
+        reference_soc = filter_df(
+            df,
+            geography="country",
+            geo_id="USA",
+            facet="soc_occupation",
+            variable="soc_pct",
+        )
+
+    # Get top SOC groups from reference (excluding not_classified)
+    reference_filtered = reference_soc[
+        ~reference_soc["cluster_name"].str.contains("not_classified", na=False)
+    ]
+    plot_soc_groups = reference_filtered.nlargest(n_top_groups, "value")[
+        "cluster_name"
+    ].tolist()
+
+    # Filter to selected SOC groups
+    df_plot = df_plot[df_plot["soc_group"].isin(plot_soc_groups)]
+
+    tier_colors = TIER_COLORS_DICT
+
+    # Fixed square subplot size for 2x2 grid
+    subplot_size = 6  # Each subplot is 6x6 inches
+    figsize = (subplot_size * n_cols, subplot_size * n_rows)
+
+    # Create figure
+    fig, axes = create_figure(figsize=figsize, nrows=n_rows, ncols=n_cols)
+    fig.suptitle(
+        "Occupation group shares vs Anthropic AI Usage Index",
+        fontsize=16,
+        fontweight="bold",
+        y=0.98,
+    )
+
+    # Flatten axes for easier iteration (always 2x2 grid)
+    axes_flat = axes.flatten()
+
+    # Plot each SOC group
+    for idx, soc_group in enumerate(plot_soc_groups):
+        ax = axes_flat[idx]
+
+        # Get data for this SOC group
+        soc_data = filter_df(df_plot, soc_group=soc_group)
+
+        # Create scatter plot for each tier
+        for tier_name in tier_colors.keys():
+            tier_data = filter_df(soc_data, tier_name=tier_name)
+
+            # Scale bubble sizes using sqrt for better visibility
+            sizes = np.sqrt(tier_data["usage_count"]) * 2
+
+            ax.scatter(
+                tier_data["ai_usage_index"],
+                tier_data["soc_pct"],
+                s=sizes,
+                c=tier_colors[tier_name],
+                alpha=0.6,
+                edgecolors="black",
+                linewidth=0.5,
+                label=tier_name,
+            )
+
+        # Add trend line and regression statistics
+        X = sm.add_constant(soc_data["ai_usage_index"].values)
+        y = soc_data["soc_pct"].values
+
+        model = sm.OLS(y, X)
+        results = model.fit()
+
+        intercept = results.params[0]
+        slope = results.params[1]
+        r_squared = results.rsquared
+        p_value = results.pvalues[1]  # p-value for slope
+
+        # Plot trend line
+        x_line = np.linspace(
+            soc_data["ai_usage_index"].min(), soc_data["ai_usage_index"].max(), 100
+        )
+        y_line = intercept + slope * x_line
+        ax.plot(x_line, y_line, "--", color="gray", alpha=0.5, linewidth=1)
+
+        # Format p-value display
+        if p_value < 0.001:
+            p_str = "p < 0.001"
+        else:
+            p_str = f"p = {p_value:.3f}"
+
+        # Add regression statistics
+        ax.text(
+            0.95,
+            0.95,
+            f"$\\beta = {slope:.3f}\\ ({p_str})$\n$R^2 = {r_squared:.3f}$",
+            transform=ax.transAxes,
+            ha="right",
+            va="top",
+            fontsize=9,
+            bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+        )
+
+        # Format axes
+        format_axis(
+            ax,
+            xlabel="Anthropic AI Usage Index (usage % / working-age population %)",
+            ylabel="Occupation group share (%)",
+            title=soc_group,
+            xlabel_size=10,
+            ylabel_size=10,
+            grid=False,
+        )
+        ax.grid(True, alpha=0.3)
+
+    # Add legend
+    handles, labels = axes_flat[0].get_legend_handles_labels()
+    if handles:
+        # Create new handles with consistent size for legend only
+        # This doesn't modify the actual plot markers
+        legend_handles = []
+        for handle in handles:
+            # Get the color from the original handle
+            color = (
+                handle.get_facecolor()[0]
+                if hasattr(handle, "get_facecolor")
+                else "gray"
+            )
+            # Create a Line2D object with circle marker for legend
+            new_handle = Line2D(
+                [0],
+                [0],
+                marker="o",
+                color="w",
+                markerfacecolor=color,
+                markersize=8,
+                markeredgecolor="black",
+                markeredgewidth=0.5,
+                alpha=0.6,
+            )
+            legend_handles.append(new_handle)
+
+        # Position tier legend centered under the left column with vertical layout
+        fig.legend(
+            legend_handles,
+            labels,
+            title="Anthropic AI Usage Index tier",
+            loc="upper center",
+            bbox_to_anchor=(0.25, -0.03),
+            frameon=True,
+            fancybox=True,
+            shadow=True,
+            ncol=2,
+            borderpad=0.6,
+        )
+
+    # Add size legend using actual scatter points for perfect matching
+    reference_counts = [100, 1000, 10000]
+
+    # Create invisible scatter points with the exact same size formula as the plot
+    size_legend_elements = []
+    for count in reference_counts:
+        # Use exact same formula as in the plot
+        size = np.sqrt(count) * 2
+        # Create scatter on first axis (will be invisible) just for legend
+        scatter = axes_flat[0].scatter(
+            [],
+            [],  # Empty data
+            s=size,
+            c="gray",
+            alpha=0.6,
+            edgecolors="black",
+            linewidth=0.5,
+            label=f"{count:,}",
+        )
+        size_legend_elements.append(scatter)
+
+    # Add size legend centered under the right column with vertical layout
+    fig.legend(
+        handles=size_legend_elements,
+        title="Claude usage count",
+        loc="upper center",
+        bbox_to_anchor=(0.75, -0.03),
+        frameon=True,
+        fancybox=True,
+        shadow=True,
+        ncol=1,
+        borderpad=0.6,
+    )
+
+    plt.tight_layout(rect=[0, -0.03, 1, 0.98])
+    return fig
+
+
+def collaboration_task_regression(df, geography="country"):
+    """
+    Analyze automation vs augmentation patterns controlling for task mix for
+    geographies that meet the minimum observation threshold.
+
+    Uses global task weights to calculate expected automation for each geography,
+    then compares actual vs expected automation.
+
+    Note: Includes "none" tasks in calculations since they have automation/augmentation
+    patterns in the data. Excludes "not_classified" tasks which lack collaboration data.
+
+    Args:
+        df: Input dataframe
+        geography: "country" or "state_us"
+    """
+    # Filter to geographies that meet min observation threshold
+    filtered_countries, filtered_states = get_filtered_geographies(df)
+    filtered_geos = filtered_countries if geography == "country" else filtered_states
+
+    # Get collaboration automation data
+    df_automation = filter_df(
+        df,
+        facet="collaboration_automation_augmentation",
+        geography=geography,
+        variable="automation_pct",
+        geo_id=filtered_geos,
+    )[["geo_id", "value"]].rename(columns={"value": "automation_pct"})
+
+    # Get Anthropic AI Usage Index data
+    df_usage = filter_df(
+        df,
+        geography=geography,
+        facet=geography,
+        variable="usage_per_capita_index",
+        geo_id=filtered_geos,
+    )[["geo_id", "geo_name", "value"]].copy()
+    df_usage.rename(columns={"value": "usage_per_capita_index"}, inplace=True)
+
+    # Get geography-specific task weights (percentages)
+    df_geo_tasks = filter_df(
+        df,
+        facet="onet_task",
+        geography=geography,
+        variable="onet_task_pct",
+        geo_id=filtered_geos,
+    ).copy()
+
+    # Exclude not_classified and none tasks
+    df_geo_tasks = df_geo_tasks[
+        ~df_geo_tasks["cluster_name"].isin(["not_classified", "none"])
+    ]
+
+    # Get global task-specific collaboration patterns (only available at global level)
+    df_task_collab = filter_df(
+        df,
+        facet="onet_task::collaboration",
+        geography="global",
+        geo_id="GLOBAL",
+        variable="onet_task_collaboration_pct",
+    ).copy()
+
+    # Parse task name and collaboration type from cluster_name
+    df_task_collab["task_name"] = df_task_collab["cluster_name"].str.split("::").str[0]
+    df_task_collab["collab_type"] = (
+        df_task_collab["cluster_name"].str.split("::").str[1]
+    )
+
+    # Map collaboration types to automation/augmentation
+    # Automation: directive, feedback loop
+    # Augmentation: validation, task iteration, learning
+    # Excluded: none, not_classified
+    def is_automation(collab_type):
+        if collab_type in ["directive", "feedback loop"]:
+            return True
+        elif collab_type in [
+            "validation",
+            "task iteration",
+            "learning",
+        ]:
+            return False
+        else:  # none, not_classified
+            return None
+
+    df_task_collab["is_automation"] = df_task_collab["collab_type"].apply(is_automation)
+
+    # Exclude not_classified tasks upfront
+    df_task_collab_valid = df_task_collab[
+        df_task_collab["task_name"] != "not_classified"
+    ]
+
+    # Calculate automation percentage for each task
+    task_automation_rates = {}
+    for task_name in df_task_collab_valid["task_name"].unique():
+        task_data = df_task_collab_valid[
+            (df_task_collab_valid["task_name"] == task_name)
+            & (df_task_collab_valid["is_automation"].notna())
+        ]
+
+        # Skip tasks that only have "not_classified" collaboration types
+        if task_data.empty or task_data["value"].sum() == 0:
+            continue
+
+        automation_sum = task_data[task_data["is_automation"]]["value"].sum()
+        total_sum = task_data["value"].sum()
+        task_automation_rates[task_name] = (automation_sum / total_sum) * 100
+
+    # Calculate expected automation for each country using its own task weights
+    expected_automation = []
+    geo_ids = []
+
+    for geo_id in filtered_geos:
+        # Get this geography's task distribution (excluding not_classified)
+        geo_tasks = df_geo_tasks[
+            (df_geo_tasks["geo_id"] == geo_id)
+            & (df_geo_tasks["cluster_name"] != "not_classified")
+        ]
+
+        # Skip geographies with no task data
+        if geo_tasks.empty:
+            continue
+
+        # Calculate weighted automation using geography's task weights
+        weighted_auto = 0.0
+        total_weight = 0.0
+
+        for _, row in geo_tasks.iterrows():
+            task = row["cluster_name"]
+            weight = row["value"]  # Already in percentage
+
+            # Get automation rate for this task (from global data)
+            if task in task_automation_rates:
+                auto_rate = task_automation_rates[task]
+                weighted_auto += weight * auto_rate
+                total_weight += weight
+
+        # Calculate expected automation
+        expected_auto = weighted_auto / total_weight
+        expected_automation.append(expected_auto)
+        geo_ids.append(geo_id)
+
+    # Create dataframe with expected automation
+    df_expected = pd.DataFrame(
+        {"geo_id": geo_ids, "expected_automation_pct": expected_automation}
+    )
+
+    # Merge all data
+    df_regression = df_automation.merge(df_expected, on="geo_id", how="inner")
+    df_regression = df_regression.merge(df_usage, on="geo_id", how="inner")
+
+    # Count unique tasks for reporting
+    n_tasks = len(task_automation_rates)
+
+    # Calculate residuals from regressions for proper partial correlation
+    # For automation, regress actual on expected to get residuals
+    X_expected = sm.add_constant(df_regression["expected_automation_pct"])
+    model_automation = sm.OLS(df_regression["automation_pct"], X_expected)
+    results_automation = model_automation.fit()
+    df_regression["automation_residuals"] = results_automation.resid
+
+    # For usage, regress on expected automation to get residuals
+    model_usage = sm.OLS(df_regression["usage_per_capita_index"], X_expected)
+    results_usage = model_usage.fit()
+    df_regression["usage_residuals"] = results_usage.resid
+
+    # Partial regression is regression of residuals
+    # We want usage (X) to explain automation (Y)
+    X_partial = sm.add_constant(df_regression["usage_residuals"])
+    model_partial = sm.OLS(df_regression["automation_residuals"], X_partial)
+    results_partial = model_partial.fit()
+    partial_slope = results_partial.params.iloc[1]
+    partial_r2 = results_partial.rsquared
+    partial_p = results_partial.pvalues.iloc[1]
+
+    # Create visualization - only show partial correlation
+    fig, ax = create_figure(figsize=(10, 8))
+
+    # Define colormap for automation residuals
+    colors_automation = [AUGMENTATION_COLOR, AUTOMATION_COLOR]
+    cmap_automation = LinearSegmentedColormap.from_list(
+        "automation", colors_automation, N=100
+    )
+
+    # Plot partial correlation
+    # Create colormap normalization for automation residuals
+    norm = plt.Normalize(
+        vmin=df_regression["automation_residuals"].min(),
+        vmax=df_regression["automation_residuals"].max(),
+    )
+
+    # Plot invisible points to ensure matplotlib's autoscaling includes all data points
+    ax.scatter(
+        df_regression["usage_residuals"],
+        df_regression["automation_residuals"],
+        s=0,  # invisible points for autoscaling
+        alpha=0,
+    )
+
+    # Plot country geo_id values as text instead of scatter points
+    for _, row in df_regression.iterrows():
+        color_val = norm(row["automation_residuals"])
+        text_color = cmap_automation(color_val)
+
+        ax.text(
+            row["usage_residuals"],
+            row["automation_residuals"],
+            row["geo_id"],
+            fontsize=7,
+            ha="center",
+            va="center",
+            color=text_color,
+            alpha=0.9,
+            weight="bold",
+        )
+
+    # Create a ScalarMappable for the colorbar
+    scalar_mappable = plt.cm.ScalarMappable(cmap=cmap_automation, norm=norm)
+    scalar_mappable.set_array([])
+
+    # Add regression line using actual regression results
+    # OLS model: automation_residuals = intercept + slope * usage_residuals
+    x_resid_line = np.linspace(
+        df_regression["usage_residuals"].min(),
+        df_regression["usage_residuals"].max(),
+        100,
+    )
+    intercept = results_partial.params.iloc[0]
+    y_resid_line = intercept + partial_slope * x_resid_line
+    ax.plot(
+        x_resid_line,
+        y_resid_line,
+        "grey",
+        linestyle="--",
+        linewidth=2,
+        alpha=0.7,
+    )
+
+    # Set axis labels and title
+    format_axis(
+        ax,
+        xlabel="Anthropic AI Usage Index residuals\n(per capita usage not explained by task mix)",
+        ylabel="Automation % residuals\n(automation not explained by task mix)",
+        title="Relationship between Anthropic AI Usage Index and automation",
+        grid=False,
+    )
+
+    # Add correlation info inside the plot
+    if partial_p < 0.001:
+        p_str = "p < 0.001"
+    else:
+        p_str = f"p = {partial_p:.3f}"
+
+    ax.text(
+        0.08,
+        0.975,
+        f"Partial regression (controlling for task mix): $\\beta = {partial_slope:.3f}, R^2 = {partial_r2:.3f}\\ ({p_str})$",
+        transform=ax.transAxes,
+        fontsize=10,
+        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+        verticalalignment="top",
+    )
+
+    ax.axhline(y=0, color="gray", linestyle=":", linewidth=1, alpha=0.3)
+    ax.axvline(x=0, color="gray", linestyle=":", linewidth=1, alpha=0.3)
+    ax.grid(True, alpha=0.3, linestyle="--")
+
+    # Add colorbar
+    fig.subplots_adjust(right=0.92)
+    cbar_ax = fig.add_axes([0.94, 0.2, 0.02, 0.6])
+    cbar = plt.colorbar(scalar_mappable, cax=cbar_ax)
+    cbar.set_label("Automation % residuals", fontsize=10, rotation=270, labelpad=15)
+
+    # Adjust plot to make room for titles and ensure all data is visible
+    plt.subplots_adjust(top=0.92, right=0.92, left=0.12, bottom=0.12)
+
+    # Return results
+    return {
+        "figure": fig,
+        "partial_slope": partial_slope,
+        "partial_r2": partial_r2,
+        "partial_pvalue": partial_p,
+        "n_countries": len(df_regression),
+        "n_tasks": n_tasks,
+        "df_residuals": df_regression,
+    }
+
+
+def plot_automation_preference_residuals(df, geography="country", figsize=(14, 12)):
+    """Plot automation vs augmentation preference after controlling for task mix.
+
+    For geographies meeting minimum observation threshold only.
+
+    Args:
+        df: Input dataframe
+        geography: "country" or "state_us"
+        figsize: Figure size
+    """
+    # First run the collaboration analysis to get residuals
+    results = collaboration_task_regression(df, geography=geography)
+
+    # Suppress figure created by collaboration_task_regression
+    plt.close(results["figure"])
+
+    # Get the dataframe with residuals
+    df_residuals = results["df_residuals"]
+
+    # Sort by automation residuals (most augmentation to most automation)
+    df_plot = df_residuals.sort_values("automation_residuals", ascending=True)
+
+    # Adjust figure size based on number of geographies
+    n_geos = len(df_plot)
+    fig_height = max(8, n_geos * 0.25)
+    fig, ax = create_figure(figsize=(figsize[0], fig_height))
+
+    # Create color map
+    colors = [
+        AUGMENTATION_COLOR if x < 0 else AUTOMATION_COLOR
+        for x in df_plot["automation_residuals"]
+    ]
+
+    # Create horizontal bar chart
+    ax.barh(
+        range(len(df_plot)),
+        df_plot["automation_residuals"].values,
+        color=colors,
+        alpha=0.8,
+    )
+
+    # Set y-axis labels with geography names only
+    y_labels = [row["geo_name"] for _, row in df_plot.iterrows()]
+    ax.set_yticks(range(len(df_plot)))
+    ax.set_yticklabels(y_labels, fontsize=7)
+
+    # Reduce white space at top and bottom
+    ax.set_ylim(-0.5, len(df_plot) - 0.5)
+
+    # Add vertical line at zero
+    ax.axvline(x=0, color="black", linestyle="-", linewidth=1, alpha=0.7)
+
+    # Labels and title
+    geo_label = "Countries'" if geography == "country" else "States'"
+    format_axis(
+        ax,
+        xlabel="Automation % residual (after controlling for task mix)",
+        ylabel="",
+        title=f"{geo_label} automation vs augmentation preference\n(after controlling for task composition)",
+        grid=False,
+    )
+
+    # Add grid
+    ax.grid(True, axis="x", alpha=0.3, linestyle="--")
+
+    # Add value labels on the bars
+    for i, (_, row) in enumerate(df_plot.iterrows()):
+        value = row["automation_residuals"]
+        x_offset = 0.2 if abs(value) < 5 else 0.3
+        x_pos = value + (x_offset if value > 0 else -x_offset)
+        ax.text(
+            x_pos,
+            i,
+            f"{value:.1f}",
+            ha="left" if value > 0 else "right",
+            va="center",
+            fontsize=8,
+        )
+
+    # Add annotations
+    y_range = ax.get_ylim()
+    annotation_y = y_range[1] * 0.85
+
+    # Left annotation for augmentation
+    ax.text(
+        ax.get_xlim()[0] * 0.7,
+        annotation_y,
+        "Prefer augmentation",
+        fontsize=9,
+        color=AUGMENTATION_COLOR,
+        fontweight="bold",
+        ha="left",
+        va="center",
+    )
+
+    # Right annotation for automation
+    ax.text(
+        ax.get_xlim()[1] * 0.7,
+        annotation_y,
+        "Prefer automation",
+        fontsize=9,
+        color=AUTOMATION_COLOR,
+        fontweight="bold",
+        ha="right",
+        va="center",
+    )
+
+    plt.tight_layout()
+
+    return fig
+
+
+def plot_soc_distribution(
+    df, geo_list, geography, figsize=(14, 10), title=None, exclude_not_classified=True
+):
+    """
+    Plot SOC occupation distribution for multiple geographies (countries or states) with horizontal bars, colored by tier.
+
+    Args:
+        df: Long format dataframe
+        geo_list: List of geo_id values to compare (e.g., ['USA', 'BRA'] for countries or ['CA', 'TX'] for states)
+        geography: Geographic level ('country' or 'state_us')
+        figsize: Figure size
+        title: Chart title
+        exclude_not_classified: If True, excludes 'not_classified' from the chart
+    """
+    # Use global tier colors and names
+    tier_colors = TIER_COLORS_NUMERIC
+    tier_names = TIER_NAMES_NUMERIC
+
+    # Get usage tier and geo_name for each geography
+    tier_data = filter_df(
+        df, geography=geography, variable="usage_tier", facet=geography, geo_id=geo_list
+    )[["geo_id", "geo_name", "value"]].rename(columns={"value": "tier"})
+
+    # Collect SOC data for all geographies first to determine consistent ordering
+    all_soc_data = []
+    for geo_id in geo_list:
+        geo_soc = filter_df(
+            df,
+            geography=geography,
+            geo_id=geo_id,
+            facet="soc_occupation",
+            variable="soc_pct",
+        ).copy()
+
+        if not geo_soc.empty:
+            # Optionally filter out not_classified
+            if exclude_not_classified:
+                geo_soc = geo_soc[geo_soc["cluster_name"] != "not_classified"].copy()
+
+            geo_soc["geo"] = geo_id
+            all_soc_data.append(geo_soc)
+
+    combined_data = pd.concat(all_soc_data)
+
+    # Use global SOC distribution for countries, USA distribution for states
+    if geography == "country":
+        reference_data = filter_df(
+            df,
+            geography="global",
+            geo_id="GLOBAL",
+            facet="soc_occupation",
+            variable="soc_pct",
+        )
+    else:  # state_us
+        reference_data = filter_df(
+            df,
+            geography="country",
+            geo_id="USA",
+            facet="soc_occupation",
+            variable="soc_pct",
+        )
+
+    # Filter out not_classified from reference data if needed
+    if exclude_not_classified:
+        reference_data = reference_data[
+            reference_data["cluster_name"] != "not_classified"
+        ]
+
+    # Sort by reference values ascending so highest appears at top when plotted
+    soc_order = reference_data.sort_values("value", ascending=True)[
+        "cluster_name"
+    ].tolist()
+
+    # Create figure
+    fig, ax = create_figure(figsize=figsize)
+
+    # Width of bars and positions
+    n_geos = len(geo_list)
+    bar_width = 0.95 / n_geos  # Wider bars, less spacing within groups
+    y_positions = (
+        np.arange(len(soc_order)) * 1.05
+    )  # Reduce spacing between SOC groups to 5%
+
+    # Sort geo_list to ensure highest tier appears at top within each group
+    # Reverse the order so tier 4 is plotted first and appears on top
+    geo_tier_map = dict(zip(tier_data["geo_id"], tier_data["tier"], strict=True))
+    geo_list_sorted = sorted(geo_list, key=lambda x: geo_tier_map[x])
+
+    # Plot bars for each geography
+    for i, geo_id in enumerate(geo_list_sorted):
+        geo_data = filter_df(combined_data, geo=geo_id)
+        geo_name = filter_df(tier_data, geo_id=geo_id)["geo_name"].iloc[0]
+        geo_tier = filter_df(tier_data, geo_id=geo_id)["tier"].iloc[0]
+
+        # Get values in the right order
+        values = []
+        for soc in soc_order:
+            val_data = filter_df(geo_data, cluster_name=soc)["value"]
+            # Use NaN for missing data
+            values.append(val_data.iloc[0] if not val_data.empty else float("nan"))
+
+        # Determine color based on tier
+        color = tier_colors[int(geo_tier)]
+
+        # Create bars with offset for multiple geographies
+        # Reverse the offset calculation so first geo (lowest tier) goes to bottom
+        offset = ((n_geos - 1 - i) - n_geos / 2 + 0.5) * bar_width
+
+        # Get tier name for label
+        tier_label = tier_names[int(geo_tier)]
+        label_text = f"{geo_name} ({tier_label})"
+
+        bars = ax.barh(
+            y_positions + offset,
+            values,
+            bar_width,
+            label=label_text,
+            color=color,
+            alpha=0.8,
+        )
+
+        # Add value labels for bars with data
+        for bar, value in zip(bars, values, strict=True):
+            if not pd.isna(value):
+                ax.text(
+                    value + 0.1,
+                    bar.get_y() + bar.get_height() / 2,
+                    f"{value:.1f}%",
+                    va="center",
+                    fontsize=5,
+                )
+
+    # Set y-axis labels - position them at the center of each SOC group
+    ax.set_yticks(y_positions)
+    ax.set_yticklabels(soc_order, fontsize=9, va="center")
+
+    # Reduce white space at top and bottom
+    ax.set_ylim(y_positions[0] - 0.5, y_positions[-1] + 0.5)
+
+    # Customize plot
+    format_axis(
+        ax,
+        xlabel="Share of Claude task usage (%)",
+        ylabel="Standard Occupation Classification group",
+        grid=False,
+    )
+
+    if title is None:
+        title = "Claude task usage by occupation: Comparison by AI usage tier"
+    format_axis(ax, title=title, title_size=14, grid=False)
+
+    # Add legend
+    ax.legend(loc="lower right", fontsize=10, framealpha=0.95)
+
+    # Grid
+    ax.grid(True, axis="x", alpha=0.3, linestyle="--")
+    ax.set_xlim(0, max(combined_data["value"]) * 1.15)
+
+    plt.tight_layout()
+    return fig

release_2025_09_15/code/aei_report_v3_analysis_1p_api.ipynb

@@ -0,0 +1,315 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AEI Report v3 API Analysis\n",
+    "This notebook produces the streamlined analysis for the AEI report API chapter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Import the analysis functions\n",
+    "from aei_analysis_functions_1p_api import (\n",
+    "    setup_plot_style,\n",
+    "    load_preprocessed_data,\n",
+    "    create_top_requests_bar_chart,\n",
+    "    create_platform_occupational_comparison,\n",
+    "    create_platform_lorenz_curves,\n",
+    "    create_collaboration_alluvial,\n",
+    "    create_automation_augmentation_panel,\n",
+    "    create_token_output_bar_chart,\n",
+    "    create_completion_vs_input_tokens_scatter,\n",
+    "    create_occupational_usage_cost_scatter,\n",
+    "    create_partial_regression_plot,\n",
+    "    perform_usage_share_regression_unweighted,\n",
+    "    create_btos_ai_adoption_chart,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Set matplotlib to use the correct backend and style\n",
+    "setup_plot_style()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Set up output directory for saving figures\n",
+    "output_dir = Path(\"../data/output/figures/\")\n",
+    "btos_data_path = Path(\"../data/input/BTOS_National.xlsx\")\n",
+    "api_data_path = Path(\"../data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv\")\n",
+    "cai_data_path = Path(\n",
+    "    \"../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
+    ")\n",
+    "\n",
+    "# Create output directory\n",
+    "output_dir.mkdir(parents=True, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Load BTOS Data\n",
+    "print(\"Loading BTOS data...\")\n",
+    "btos_df = pd.read_excel(btos_data_path, sheet_name=\"Response Estimates\")\n",
+    "btos_df_ref_dates_df = pd.read_excel(\n",
+    "    btos_data_path, sheet_name=\"Collection and Reference Dates\"\n",
+    ")\n",
+    "\n",
+    "# Load the API data\n",
+    "print(\"Loading API data...\")\n",
+    "api_df = load_preprocessed_data(api_data_path)\n",
+    "\n",
+    "# Load the Claude.ai data\n",
+    "print(\"Loading Claude.ai data...\")\n",
+    "cai_df = load_preprocessed_data(cai_data_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "create_btos_ai_adoption_chart(btos_df, btos_df_ref_dates_df, output_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the top requests bar chart\n",
+    "print(\"Creating top requests bar chart...\")\n",
+    "top_requests_chart = create_top_requests_bar_chart(api_df, output_dir)\n",
+    "print(f\"Chart saved to: {top_requests_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the platform occupational comparison chart\n",
+    "print(\"Creating platform occupational comparison chart...\")\n",
+    "occupational_comparison_chart = create_platform_occupational_comparison(\n",
+    "    api_df, cai_df, output_dir\n",
+    ")\n",
+    "print(f\"Chart saved to: {occupational_comparison_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the platform Lorenz curves\n",
+    "print(\"Creating platform Lorenz curves...\")\n",
+    "lorenz_curves_chart = create_platform_lorenz_curves(api_df, cai_df, output_dir)\n",
+    "print(f\"Chart saved to: {lorenz_curves_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the collaboration alluvial diagram\n",
+    "print(\"Creating collaboration alluvial diagram...\")\n",
+    "alluvial_chart = create_collaboration_alluvial(api_df, cai_df, output_dir)\n",
+    "print(f\"Chart saved to: {alluvial_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the automation vs augmentation panel\n",
+    "print(\"Creating automation vs augmentation panel...\")\n",
+    "automation_panel_chart = create_automation_augmentation_panel(\n",
+    "    api_df, cai_df, output_dir\n",
+    ")\n",
+    "print(f\"Chart saved to: {automation_panel_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the token output bar chart\n",
+    "print(\"Creating token output bar chart...\")\n",
+    "token_output_chart = create_token_output_bar_chart(api_df, output_dir)\n",
+    "print(f\"Chart saved to: {token_output_chart}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the completion vs input tokens scatter plot\n",
+    "print(\"Creating completion vs input tokens scatter plot...\")\n",
+    "completion_input_scatter = create_completion_vs_input_tokens_scatter(api_df, output_dir)\n",
+    "print(f\"Chart saved to: {completion_input_scatter}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the occupational usage vs cost scatter plot\n",
+    "print(\"Creating occupational usage vs cost scatter plot...\")\n",
+    "usage_cost_scatter = create_occupational_usage_cost_scatter(api_df, output_dir)\n",
+    "print(f\"Chart saved to: {usage_cost_scatter}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create the partial regression plot\n",
+    "print(\"Creating partial regression plot...\")\n",
+    "partial_plot, regression_results = create_partial_regression_plot(\n",
+    "    api_df, cai_df, output_dir\n",
+    ")\n",
+    "print(f\"Chart saved to: {partial_plot}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Perform the unweighted usage share regression analysis\n",
+    "print(\"Performing unweighted usage share regression analysis...\")\n",
+    "regression_model = perform_usage_share_regression_unweighted(api_df, cai_df, output_dir)\n",
+    "regression_model.summary()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Coconut",
+   "language": "coconut",
+   "name": "coconut"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "python",
+    "version": 3
+   },
+   "file_extension": ".coco",
+   "mimetype": "text/x-python3",
+   "name": "coconut",
+   "pygments_lexer": "coconut",
+   "version": "3.0.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

release_2025_09_15/code/aei_report_v3_analysis_claude_ai.ipynb

@@ -0,0 +1,868 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AEI Report v3 Claude.ai Analysis\n",
+    "\n",
+    "This notebook performs statistical analysis and creates visualizations from enriched Clio data.\n",
+    "It works directly with long format data from the preprocessing pipeline.\n",
+    "\n",
+    "**Input**: `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv`\n",
+    "\n",
+    "**Output**: Visualizations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Setup and Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Import all analysis functions\n",
+    "from aei_analysis_functions_claude_ai import (\n",
+    "    setup_plot_style,\n",
+    "    get_filtered_geographies,\n",
+    "    plot_usage_index_bars,\n",
+    "    plot_tier_map,\n",
+    "    plot_usage_share_bars,\n",
+    "    plot_tier_summary_table,\n",
+    "    plot_gdp_scatter,\n",
+    "    plot_request_comparison_cards,\n",
+    "    plot_soc_usage_scatter,\n",
+    "    plot_dc_task_request_cards,\n",
+    "    collaboration_task_regression,\n",
+    "    plot_usage_index_histogram,\n",
+    "    plot_variable_map,\n",
+    "    plot_soc_distribution,\n",
+    "    plot_automation_preference_residuals,\n",
+    "    plot_variable_bars,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Set matplotlib to use the correct backend and style\n",
+    "setup_plot_style()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Set up output directory for saving figures\n",
+    "output_dir = Path(\"../data/output/figures/\")\n",
+    "output_dir.mkdir(parents=True, exist_ok=True)\n",
+    "output_dir_app = Path(\"../data/output/figures/appendix/\")\n",
+    "output_dir_app.mkdir(parents=True, exist_ok=True)\n",
+    "\n",
+    "# Load enriched data\n",
+    "data_path = \"../data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
+    "\n",
+    "# Load the data - use keep_default_na=False to preserve \"NA\" (Namibia) as string\n",
+    "df = pd.read_csv(data_path, keep_default_na=False, na_values=[\"\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Filter countries to those with at least 200 observations\n",
+    "# Filter US states to those with at least 100 observations\n",
+    "filtered_countries, filtered_states = get_filtered_geographies(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.2 Global"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Top countries by share of global usage\n",
+    "plot_usage_share_bars(\n",
+    "    df,\n",
+    "    geography=\"country\",\n",
+    "    top_n=30,\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"usage_pct_bar_country_top30.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create world map showing usage tiers\n",
+    "plot_tier_map(\n",
+    "    df,\n",
+    "    geography=\"country\",\n",
+    "    title=\"Anthropic AI Usage Index tiers by country\",\n",
+    "    figsize=(16, 10),\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_tier_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create tier summary table for countries\n",
+    "plot_tier_summary_table(df, geography=\"country\")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"tier_summary_table_country.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    "    transparent=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Top countries by usage per capita\n",
+    "plot_usage_index_bars(\n",
+    "    df, geography=\"country\", top_n=20, filtered_entities=filtered_countries\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_bar_country_top20.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GDP vs usage regression for countries\n",
+    "plot_gdp_scatter(df, geography=\"country\", filtered_entities=filtered_countries)\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_gdp_reg_country_min_obs.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GDP vs usage regression for countries\n",
+    "plot_gdp_scatter(\n",
+    "    df, geography=\"country\", filtered_entities=filtered_countries, figsize=(13.2, 8.25)\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_gdp_reg_country_min_obs_wide.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create SOC diffusion scatter plot with top 4 classified SOC groups (2x2 grid)\n",
+    "plot_soc_usage_scatter(df, geography=\"country\")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"soc_usage_scatter_top4_country_min.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Find the highest usage country in each tier (1-4)\n",
+    "\n",
+    "# Get usage tier and usage count data for all countries\n",
+    "tier_data = df[\n",
+    "    (df[\"geography\"] == \"country\")\n",
+    "    & (df[\"variable\"] == \"usage_tier\")\n",
+    "    & (df[\"facet\"] == \"country\")\n",
+    "][[\"geo_id\", \"value\"]].rename(columns={\"value\": \"tier\"})\n",
+    "\n",
+    "usage_data = df[\n",
+    "    (df[\"geography\"] == \"country\")\n",
+    "    & (df[\"variable\"] == \"usage_count\")\n",
+    "    & (df[\"facet\"] == \"country\")\n",
+    "][[\"geo_id\", \"geo_name\", \"value\"]].rename(columns={\"value\": \"usage_count\"})\n",
+    "\n",
+    "# Merge tier and usage data\n",
+    "country_data = usage_data.merge(tier_data, on=\"geo_id\")\n",
+    "\n",
+    "selected_countries = [\n",
+    "    country_data[country_data[\"tier\"] == tier]\n",
+    "    .sort_values(\"usage_count\", ascending=False)\n",
+    "    .iloc[0][\"geo_id\"]\n",
+    "    for tier in [4, 3, 2, 1]\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Compare top overrepresented requests for 4 highest usage countries in each tier\n",
+    "plot_request_comparison_cards(\n",
+    "    df,\n",
+    "    geo_ids=selected_countries,\n",
+    "    top_n=5,\n",
+    "    title=\"Top overrepresented requests for the United States, Brazil, Vietnam and India\",\n",
+    "    geography=\"country\",\n",
+    ")\n",
+    "\n",
+    "plt.savefig(\n",
+    "    output_dir / \"request_comparison_cards_by_tier_country_selected4.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. United States"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# State tier map\n",
+    "plot_tier_map(\n",
+    "    df, geography=\"state_us\", title=\"Anthropic AI Usage Index tier by US state\"\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_tier_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Top 20 US states\n",
+    "plot_usage_index_bars(\n",
+    "    df,\n",
+    "    geography=\"state_us\",\n",
+    "    top_n=20,\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"ai_usage_index_bar_state_top20.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create tier summary table for US states\n",
+    "plot_tier_summary_table(df, geography=\"state_us\")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"tier_summary_table_state.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    "    transparent=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Find the highest usage US state in each tier (1-4)\n",
+    "\n",
+    "# Get usage tier and usage count data for US states\n",
+    "tier_data_states = df[\n",
+    "    (df[\"geography\"] == \"state_us\")\n",
+    "    & (df[\"variable\"] == \"usage_tier\")\n",
+    "    & (df[\"facet\"] == \"state_us\")\n",
+    "][[\"geo_id\", \"value\"]].rename(columns={\"value\": \"tier\"})\n",
+    "\n",
+    "usage_data_states = df[\n",
+    "    (df[\"geography\"] == \"state_us\")\n",
+    "    & (df[\"variable\"] == \"usage_count\")\n",
+    "    & (df[\"facet\"] == \"state_us\")\n",
+    "][[\"geo_id\", \"geo_name\", \"value\"]].rename(columns={\"value\": \"usage_count\"})\n",
+    "\n",
+    "# Merge tier and usage data\n",
+    "state_data = usage_data_states.merge(tier_data_states, on=\"geo_id\")\n",
+    "\n",
+    "# Find the highest usage state in each tier\n",
+    "selected_states = [\n",
+    "    state_data[state_data[\"tier\"] == tier]\n",
+    "    .sort_values(\"usage_count\", ascending=False)\n",
+    "    .iloc[0][\"geo_id\"]\n",
+    "    for tier in [4, 3, 2, 1]\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Compare top overrepresented requests for US states representing each tier\n",
+    "# CA (Tier 4), TX (Tier 3), FL (Tier 2), SC (Tier 1)\n",
+    "states_to_compare = [\"CA\", \"TX\", \"FL\", \"SC\"]\n",
+    "\n",
+    "plot_request_comparison_cards(\n",
+    "    df,\n",
+    "    geo_ids=states_to_compare,\n",
+    "    top_n=5,\n",
+    "    title=\"Top overrepresented high-level requests for California, Texas, Florida and South Carolina\",\n",
+    "    geography=\"state_us\",\n",
+    ")\n",
+    "\n",
+    "plt.savefig(\n",
+    "    output_dir / \"request_comparison_cards_by_tier_state_selected4.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create card-style visualization for Washington DC\n",
+    "# Shows top O*NET tasks and top request categories\n",
+    "plot_dc_task_request_cards(\n",
+    "    df, title=\"Washington, DC: Highest Anthropic AI Usage Index in the US\"\n",
+    ")\n",
+    "\n",
+    "plt.savefig(\n",
+    "    output_dir / \"task_request_comparison_state_dc.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Collaboration pattern analysis with task mix control\n",
+    "# This analysis determines whether the relationship between AUI\n",
+    "# and automation preference persists after controlling for task composition\n",
+    "collaboration_task_regression(df, geography=\"country\")\n",
+    "plt.savefig(\n",
+    "    output_dir / \"collaboration_task_control_partial_corr_country.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Appendix"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Global"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Distribution histogram\n",
+    "plot_usage_index_histogram(\n",
+    "    df, geography=\"country\", title=\"Distribution of Anthropic AI Usage Index\"\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_histogram_country_all.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create map showing share of usage\n",
+    "plot_variable_map(\n",
+    "    df,\n",
+    "    variable=\"usage_pct\",\n",
+    "    geography=\"country\",\n",
+    "    title=\"Share of global Claude usage by country\",\n",
+    "    figsize=(14, 8),\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"usage_pct_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create world map showing usage per capita\n",
+    "plot_variable_map(\n",
+    "    df,\n",
+    "    variable=\"usage_per_capita_index\",\n",
+    "    geography=\"country\",\n",
+    "    title=\"Anthropic AI Usage Index by country\",\n",
+    "    center_at_one=True,\n",
+    "    figsize=(14, 8),\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_map_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# AUI for all countries\n",
+    "plot_usage_index_bars(\n",
+    "    df,\n",
+    "    geography=\"country\",\n",
+    "    filtered_entities=filtered_countries,\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_country_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# SOC distribution comparison for countries by usage tier\n",
+    "plot_soc_distribution(\n",
+    "    df,\n",
+    "    selected_countries,\n",
+    "    \"country\",\n",
+    "    title=\"Occupation groups by Claude task usage in the United States, Brazil, Vietnam and India\",\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"soc_distribution_by_tier_country_selected4.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Plot automation preference residuals after controlling for task mix\n",
+    "# This shows which countries prefer more automation vs augmentation\n",
+    "# than would be expected given their task composition\n",
+    "plot_automation_preference_residuals(df)\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"automation_preference_residuals.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## United States"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Top countries by share of global usage\n",
+    "plot_usage_share_bars(\n",
+    "    df,\n",
+    "    geography=\"state_us\",\n",
+    "    top_n=30,\n",
+    "    title=\"Top 30 US states by share of US Claude usage\",\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"usage_pct_bar_state_top30.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Distribution histogram\n",
+    "plot_usage_index_histogram(\n",
+    "    df, geography=\"state_us\", title=\"Distribution of Anthropic AI Usage Index\"\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_histogram_state_all.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create map showing share of usage\n",
+    "plot_variable_map(\n",
+    "    df,\n",
+    "    variable=\"usage_pct\",\n",
+    "    geography=\"state_us\",\n",
+    "    title=\"Share of global Claude usage by US state\",\n",
+    "    figsize=(14, 8),\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"usage_pct_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create map showing per capita usage\n",
+    "plot_variable_map(\n",
+    "    df,\n",
+    "    variable=\"usage_per_capita_index\",\n",
+    "    geography=\"state_us\",\n",
+    "    title=\"Anthropic AI Usage Index by US state\",\n",
+    "    center_at_one=True,\n",
+    "    figsize=(14, 8),\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_map_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "plot_usage_index_bars(\n",
+    "    df,\n",
+    "    geography=\"state_us\",\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_bar_state_all.png\", dpi=300, bbox_inches=\"tight\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# GDP vs usage regression for US states\n",
+    "plot_gdp_scatter(df, geography=\"state_us\", filtered_entities=filtered_states)\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"ai_usage_index_gdp_reg_state_min_obs.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# SOC distribution comparison for US states by usage tier\n",
+    "plot_soc_distribution(\n",
+    "    df,\n",
+    "    selected_states,\n",
+    "    \"state_us\",\n",
+    "    title=\"Occupation groups by Claude task usage in California, Texas, Florida and South Carolina\",\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"soc_distribution_by_tier_state_selected4.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Top SOC chart\n",
+    "plot_variable_bars(\n",
+    "    df,\n",
+    "    variable=\"soc_pct\",\n",
+    "    geography=\"country\",\n",
+    "    facet=\"soc_occupation\",\n",
+    "    geo_id=\"USA\",\n",
+    "    title=\"Occupation groups in the US by Claude use for associated tasks\",\n",
+    "    xlabel=\"Share of total usage (%)\",\n",
+    "    exclude_not_classified=True,\n",
+    ")\n",
+    "\n",
+    "# Save the figure\n",
+    "plt.savefig(output_dir_app / \"soc_bar_country_us.png\", dpi=300, bbox_inches=\"tight\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Create SOC diffusion scatter plot with top 4 classified SOC groups\n",
+    "plot_soc_usage_scatter(\n",
+    "    df,\n",
+    "    geography=\"state_us\",\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    output_dir_app / \"soc_usage_scatter_top4_state_min.png\",\n",
+    "    dpi=300,\n",
+    "    bbox_inches=\"tight\",\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Coconut",
+   "language": "coconut",
+   "name": "coconut"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "python",
+    "version": 3
+   },
+   "file_extension": ".coco",
+   "mimetype": "text/x-python3",
+   "name": "coconut",
+   "pygments_lexer": "coconut",
+   "version": "3.0.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

release_2025_09_15/code/aei_report_v3_change_over_time_claude_ai.py

@@ -0,0 +1,564 @@
+#!/usr/bin/env python3
+"""
+Clean Economic Analysis Figure Generator
+======================================
+Generates three key figures for V1→V2→V3 economic analysis:
+1. Usage Share Trends Across Economic Index Reports
+2. Notable Task Changes (Growing/Declining Tasks)
+3. Automation vs Augmentation Evolution
+
+ASSUMPTIONS:
+- V1/V2/V3 use same task taxonomy
+- GLOBAL geo_id is representative
+- Missing values = 0% usage
+- Percentages don't need renormalization
+"""
+
+import os
+import warnings
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+
+# Use default matplotlib styling
+plt.style.use("default")
+
+# Configuration
+FILES = {
+    "v1_tasks": "../data/input/task_pct_v1.csv",
+    "v2_tasks": "../data/input/task_pct_v2.csv",
+    "v3_data": "../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv",
+    "v1_auto": "../data/input/automation_vs_augmentation_v1.csv",
+    "v2_auto": "../data/input/automation_vs_augmentation_v2.csv",
+    "onet": "../data/intermediate/onet_task_statements.csv",
+    "soc": "../data/intermediate/soc_structure.csv",
+}
+
+AUTOMATION_TYPES = ["directive", "feedback_loop"]
+AUGMENTATION_TYPES = ["validation", "task_iteration", "learning"]
+MIN_THRESHOLD = 1.0
+COLORS = {
+    "increase": "#2E8B57",
+    "decrease": "#CD5C5C",
+    "automation": "#FF6B6B",
+    "augmentation": "#4ECDC4",
+}
+
+# ============================================================================
+# DATA LOADING
+# ============================================================================
+
+
+def load_task_data(filepath, version_name):
+    """Load and validate task percentage data for any version."""
+    if not Path(filepath).exists():
+        raise FileNotFoundError(f"Missing {version_name} data: {filepath}")
+
+    df = pd.read_csv(filepath)
+
+    if version_name == "V3":
+        # Filter V3 data for global onet tasks
+        df = df[
+            (df["geo_id"] == "GLOBAL")
+            & (df["facet"] == "onet_task")
+            & (df["variable"] == "onet_task_pct")
+        ].copy()
+        df = df.rename(columns={"cluster_name": "task_name", "value": "pct"})
+
+        # Remove "not_classified" from V3 for fair comparison with V1/V2
+        # Keep "none" as it represents legitimate unclassifiable tasks across all versions
+        not_classified_pct = df[df["task_name"] == "not_classified"]["pct"].sum()
+        df = df[df["task_name"] != "not_classified"].copy()
+
+        # Renormalize V3 to 100% after removing not_classified
+        if not_classified_pct > 0:
+            remaining_total = df["pct"].sum()
+            normalization_factor = 100 / remaining_total
+            df["pct"] = df["pct"] * normalization_factor
+            print(
+                f"  → Removed {not_classified_pct:.1f}% not_classified, renormalized by {normalization_factor:.3f}x"
+            )
+
+    # Validate structure
+    if "task_name" not in df.columns or "pct" not in df.columns:
+        raise ValueError(f"{version_name} data missing required columns")
+
+    # Normalize task names and validate totals
+    df["task_name"] = df["task_name"].str.lower().str.strip()
+    total = df["pct"].sum()
+
+    if not (80 <= total <= 120):
+        warnings.warn(
+            f"{version_name} percentages sum to {total:.1f}% (expected ~100%)",
+            stacklevel=2,
+        )
+
+    print(f"✓ {version_name}: {len(df)} tasks, {total:.1f}% coverage")
+    return df[["task_name", "pct"]]
+
+
+def load_automation_data():
+    """Load automation/collaboration data for all versions."""
+    result = {}
+
+    # V1 and V2 - always renormalize to 100%
+    for version in ["v1", "v2"]:
+        df = pd.read_csv(FILES[f"{version}_auto"])
+
+        # Always renormalize to 100%
+        total = df["pct"].sum()
+        normalization_factor = 100 / total
+        df["pct"] = df["pct"] * normalization_factor
+        print(
+            f"  → {version.upper()} automation: renormalized from {total:.1f}% to 100.0%"
+        )
+
+        result[version] = df
+
+    # V3 from processed data
+    df = pd.read_csv(FILES["v3_data"])
+    v3_collab = df[
+        (df["geo_id"] == "GLOBAL")
+        & (df["facet"] == "collaboration")
+        & (df["level"] == 0)
+        & (df["variable"] == "collaboration_pct")
+    ].copy()
+    v3_collab = v3_collab.rename(
+        columns={"cluster_name": "interaction_type", "value": "pct"}
+    )
+
+    # Remove "not_classified" from V3 collaboration data for fair comparison
+    not_classified_pct = v3_collab[v3_collab["interaction_type"] == "not_classified"][
+        "pct"
+    ].sum()
+    v3_collab = v3_collab[v3_collab["interaction_type"] != "not_classified"].copy()
+
+    # Renormalize V3 collaboration to 100% after removing not_classified
+    if not_classified_pct > 0:
+        remaining_total = v3_collab["pct"].sum()
+        normalization_factor = 100 / remaining_total
+        v3_collab["pct"] = v3_collab["pct"] * normalization_factor
+        print(
+            f"  → V3 collaboration: removed {not_classified_pct:.1f}% not_classified, renormalized by {normalization_factor:.3f}x"
+        )
+
+    result["v3"] = v3_collab[["interaction_type", "pct"]]
+
+    print(f"✓ Automation data loaded for all versions")
+    return result
+
+
+def load_occupational_mapping():
+    """Load O*NET to SOC mapping data."""
+    onet_df = pd.read_csv(FILES["onet"])
+    soc_df = pd.read_csv(FILES["soc"]).dropna(subset=["Major Group"])
+
+    onet_df["soc_major_group"] = onet_df["O*NET-SOC Code"].str[:2]
+    soc_df["soc_major_group"] = soc_df["Major Group"].str[:2]
+
+    merged = onet_df.merge(
+        soc_df[["soc_major_group", "SOC or O*NET-SOC 2019 Title"]], on="soc_major_group"
+    )
+    merged["task_normalized"] = merged["Task"].str.lower().str.strip()
+
+    print(f"✓ Occupational mapping: {merged['soc_major_group'].nunique()} SOC groups")
+    return merged
+
+
+# ============================================================================
+# ANALYSIS
+# ============================================================================
+
+
+def analyze_occupational_trends(task_data, onet_soc_data):
+    """Analyze occupational category trends across versions."""
+
+    def aggregate_by_occupation(df):
+        merged = df.merge(
+            onet_soc_data[
+                ["task_normalized", "SOC or O*NET-SOC 2019 Title"]
+            ].drop_duplicates(),
+            left_on="task_name",
+            right_on="task_normalized",
+            how="left",
+        )
+
+        unmapped = merged[merged["SOC or O*NET-SOC 2019 Title"].isna()]
+        # Only warn if there are real unmapped tasks (not just "none" and "not_classified")
+        real_unmapped = unmapped[
+            ~unmapped["task_name"].isin(["none", "not_classified"])
+        ]
+        if len(real_unmapped) > 0:
+            real_unmapped_pct = real_unmapped["pct"].sum()
+            warnings.warn(
+                f"{real_unmapped_pct:.1f}% of tasks unmapped to occupational categories",
+                stacklevel=2,
+            )
+
+        return merged.groupby("SOC or O*NET-SOC 2019 Title")["pct"].sum()
+
+    # Aggregate all versions
+    comparison_df = pd.DataFrame(
+        {
+            "v1": aggregate_by_occupation(task_data["v1"]),
+            "v2": aggregate_by_occupation(task_data["v2"]),
+            "v3": aggregate_by_occupation(task_data["v3"]),
+        }
+    ).fillna(0)
+
+    # Calculate changes and filter economically significant categories
+    comparison_df["v3_v1_diff"] = comparison_df["v3"] - comparison_df["v1"]
+    significant = comparison_df[
+        (comparison_df[["v1", "v2", "v3"]] >= MIN_THRESHOLD).any(axis=1)
+    ]
+
+    print(
+        f"✓ Occupational analysis: {len(significant)} economically significant categories"
+    )
+    return significant.sort_values("v1", ascending=False)
+
+
+def analyze_task_changes(task_data, onet_soc_data, top_n=12):
+    """Identify most notable task changes V1→V3."""
+    v1, v3 = task_data["v1"], task_data["v3"]
+
+    # Compare changes
+    comparison = (
+        v1[["task_name", "pct"]]
+        .rename(columns={"pct": "v1_pct"})
+        .merge(
+            v3[["task_name", "pct"]].rename(columns={"pct": "v3_pct"}),
+            on="task_name",
+            how="outer",
+        )
+        .fillna(0)
+    )
+
+    comparison["change"] = comparison["v3_pct"] - comparison["v1_pct"]
+    comparison["rel_change"] = np.where(
+        comparison["v1_pct"] > 0,
+        (comparison["v3_pct"] - comparison["v1_pct"]) / comparison["v1_pct"] * 100,
+        np.inf,
+    )
+
+    # Add SOC context
+    with_context = comparison.merge(
+        onet_soc_data[
+            ["task_normalized", "SOC or O*NET-SOC 2019 Title"]
+        ].drop_duplicates(),
+        left_on="task_name",
+        right_on="task_normalized",
+        how="left",
+    )
+
+    # Get all tasks with economically significant changes (>= 0.2pp)
+    significant_changes = with_context[abs(with_context["change"]) >= 0.2].copy()
+
+    # Create category column with formatted relative percentage change
+    def format_rel_change(row):
+        if row["v1_pct"] > 0:
+            rel_change = (row["v3_pct"] - row["v1_pct"]) / row["v1_pct"] * 100
+            return f"{rel_change:+.0f}%"
+        else:
+            return "new"
+
+    significant_changes["category"] = significant_changes.apply(
+        format_rel_change, axis=1
+    )
+
+    # Rename column and sort by change descending
+    significant_changes = significant_changes.rename(
+        columns={"SOC or O*NET-SOC 2019 Title": "soc_group"}
+    )
+    significant_changes = significant_changes.sort_values("change", ascending=False)
+
+    # Round to 3 decimals
+    significant_changes[["v1_pct", "v3_pct", "change"]] = significant_changes[
+        ["v1_pct", "v3_pct", "change"]
+    ].round(3)
+
+    print(f"✓ Task changes: {len(significant_changes)} notable changes identified")
+    return significant_changes
+
+
+def analyze_automation_trends(automation_data):
+    """Analyze automation vs augmentation trends across versions."""
+    # Standardize interaction names
+    for df in automation_data.values():
+        df["interaction_type"] = df["interaction_type"].replace(
+            {"task iteration": "task_iteration", "feedback loop": "feedback_loop"}
+        )
+
+    results = {}
+    for version, data in automation_data.items():
+        auto_total = data[data["interaction_type"].isin(AUTOMATION_TYPES)]["pct"].sum()
+        aug_total = data[data["interaction_type"].isin(AUGMENTATION_TYPES)]["pct"].sum()
+
+        interaction_dict = dict(zip(data["interaction_type"], data["pct"], strict=True))
+        results[version] = {
+            "automation_total": auto_total,
+            "augmentation_total": aug_total,
+            "directive": interaction_dict["directive"],
+            "feedback_loop": interaction_dict["feedback_loop"],
+            "validation": interaction_dict["validation"],
+            "task_iteration": interaction_dict["task_iteration"],
+            "learning": interaction_dict["learning"],
+        }
+
+    print("✓ Automation trends analysis complete")
+    return results
+
+
+# ============================================================================
+# VISUALIZATION
+# ============================================================================
+
+
+def setup_plot_style():
+    """Configure consistent plot styling."""
+    plt.rcParams.update({"font.size": 12, "axes.titlesize": 16, "axes.labelsize": 14})
+    sns.set_context("notebook", font_scale=1.1)
+
+
+def create_usage_trends_figure(comparison_df):
+    """Create Usage Share Trends subplot figure."""
+    setup_plot_style()
+
+    # Get top categories
+    top_cats = comparison_df[
+        (comparison_df[["v1", "v2", "v3"]] >= MIN_THRESHOLD).any(axis=1)
+    ].head(8)
+    top_cats.index = top_cats.index.str.replace(" Occupations", "")
+
+    fig, axes = plt.subplots(2, 4, figsize=(20, 15))
+    axes = axes.flatten()
+
+    line_color = "#FF8E53"
+    fill_color = "#DEB887"
+
+    # Simplified date labels (actual periods: Dec 2024-Jan 2025, Feb-Mar 2025, Aug 2025)
+    versions, version_labels = [1, 2, 3], ["Jan 2025", "Mar 2025", "Aug 2025"]
+
+    for i, (category, data) in enumerate(top_cats.iterrows()):
+        if i >= len(axes):
+            break
+        ax = axes[i]
+        values = [data["v1"], data["v2"], data["v3"]]
+
+        ax.plot(
+            versions,
+            values,
+            "o-",
+            color=line_color,
+            linewidth=3,
+            markersize=8,
+            markerfacecolor=line_color,
+            markeredgecolor="white",
+            markeredgewidth=2,
+        )
+        ax.fill_between(versions, values, alpha=0.3, color=fill_color)
+
+        # Add value labels
+        for x, y in zip(versions, values, strict=True):
+            ax.text(
+                x,
+                y + max(values) * 0.02,
+                f"{y:.1f}%",
+                ha="center",
+                va="bottom",
+                fontsize=12,
+                fontweight="bold",
+            )
+
+        ax.set_title(category, fontsize=14, fontweight="bold", pad=10)
+        ax.set_xticks(versions)
+        ax.set_xticklabels(version_labels)
+        ax.set_ylabel("Percentage", fontsize=12)
+        ax.set_ylim(0, max(values) * 1.15)
+        ax.grid(True, alpha=0.3)
+        ax.spines["top"].set_visible(False)
+        ax.spines["right"].set_visible(False)
+
+    fig.suptitle(
+        "Usage share trends across economic index reports (V1 to V3)",
+        fontsize=18,
+        fontweight="bold",
+        y=0.98,
+    )
+    plt.tight_layout()
+    plt.subplots_adjust(top=0.88)
+    return fig
+
+
+def create_automation_figure(trends):
+    """Create Automation vs Augmentation Evolution figure."""
+    setup_plot_style()
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))
+
+    # Simplified date labels (actual periods: Dec 2024-Jan 2025, Feb-Mar 2025, Aug 2025)
+    version_labels = ["Jan 2025", "Mar 2025", "Aug 2025"]
+    x_pos = [1, 2, 3]
+
+    # Left: Overall trends (no fill)
+    auto_vals = [trends[v]["automation_total"] for v in ["v1", "v2", "v3"]]
+    aug_vals = [trends[v]["augmentation_total"] for v in ["v1", "v2", "v3"]]
+
+    ax1.plot(
+        x_pos,
+        auto_vals,
+        "o-",
+        color=COLORS["automation"],
+        linewidth=3,
+        markersize=8,
+        label="Automation",
+        markeredgecolor="white",
+        markeredgewidth=2,
+    )
+    ax1.plot(
+        x_pos,
+        aug_vals,
+        "o-",
+        color=COLORS["augmentation"],
+        linewidth=3,
+        markersize=8,
+        label="Augmentation",
+        markeredgecolor="white",
+        markeredgewidth=2,
+    )
+
+    # Value labels with automation above and augmentation below dots
+    y_max = max(max(auto_vals), max(aug_vals))
+    for i, (auto, aug) in enumerate(zip(auto_vals, aug_vals, strict=True)):
+        # Red (automation) always above the dot
+        ax1.text(
+            x_pos[i],
+            auto + 1.2,
+            f"{auto:.1f}%",
+            ha="center",
+            va="bottom",
+            fontweight="bold",
+            color=COLORS["automation"],
+        )
+        # Blue (augmentation) always below the dot
+        ax1.text(
+            x_pos[i],
+            aug - 1.5,
+            f"{aug:.1f}%",
+            ha="center",
+            va="top",
+            fontweight="bold",
+            color=COLORS["augmentation"],
+        )
+
+    ax1.set_xticks(x_pos)
+    ax1.set_xticklabels(version_labels)
+    ax1.set_ylabel("Percentage")
+    ax1.set_title("Automation vs augmentation trends")
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    ax1.spines[["top", "right"]].set_visible(False)
+    ax1.set_ylim(0, y_max * 1.15)
+
+    # Right: Individual interaction types with color-coded groups
+    interactions = [
+        "directive",
+        "feedback_loop",
+        "validation",
+        "task_iteration",
+        "learning",
+    ]
+    # Automation = red shades, Augmentation = cool shades
+    colors_individual = ["#DC143C", "#FF6B6B", "#4682B4", "#5F9EA0", "#4169E1"]
+
+    for interaction, color in zip(interactions, colors_individual, strict=True):
+        values = [trends[v][interaction] for v in ["v1", "v2", "v3"]]
+        ax2.plot(
+            x_pos,
+            values,
+            "o-",
+            color=color,
+            linewidth=2.5,
+            markersize=6,
+            label=interaction.replace("_", " ").title(),
+            alpha=0.8,
+        )
+
+    ax2.set_xticks(x_pos)
+    ax2.set_xticklabels(version_labels)
+    ax2.set_ylabel("Percentage")
+    ax2.set_title("Individual interaction types")
+    ax2.legend(bbox_to_anchor=(1.05, 1), loc="upper left")
+    ax2.grid(True, alpha=0.3)
+    ax2.spines[["top", "right"]].set_visible(False)
+
+    plt.suptitle(
+        "Automation vs augmentation evolution (V1 to V3)",
+        fontsize=16,
+        fontweight="bold",
+    )
+    plt.tight_layout()
+    return fig
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+
+def main():
+    """Generate all three economic analysis figures."""
+    print("=" * 80)
+    print("ECONOMIC ANALYSIS FIGURE GENERATION")
+    print("=" * 80)
+
+    # Use consistent output directory for all economic research scripts
+    output_dir = "../data/output/figures"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Load all data
+    print("\nLoading data...")
+    task_data = {
+        "v1": load_task_data(FILES["v1_tasks"], "V1"),
+        "v2": load_task_data(FILES["v2_tasks"], "V2"),
+        "v3": load_task_data(FILES["v3_data"], "V3"),
+    }
+    automation_data = load_automation_data()
+    onet_soc_data = load_occupational_mapping()
+
+    # Analysis
+    print("\nAnalyzing trends...")
+    occupational_trends = analyze_occupational_trends(task_data, onet_soc_data)
+    task_changes = analyze_task_changes(task_data, onet_soc_data)
+    automation_trends = analyze_automation_trends(automation_data)
+
+    # Generate figures
+    print("\nGenerating figures...")
+
+    fig1 = create_usage_trends_figure(occupational_trends)
+    fig1.savefig(
+        f"{output_dir}/main_occupational_categories.png",
+        dpi=300,
+        bbox_inches="tight",
+        facecolor="white",
+    )
+    print("✓ Saved: main_occupational_categories.png")
+
+    fig3 = create_automation_figure(automation_trends)
+    fig3.savefig(
+        f"{output_dir}/automation_trends_v1_v2_v3.png",
+        dpi=300,
+        bbox_inches="tight",
+        facecolor="white",
+    )
+    print("✓ Saved: automation_trends_v1_v2_v3.png")
+
+    print(f"\n✅ All figures generated successfully!")
+    return occupational_trends, task_changes, automation_trends
+
+
+if __name__ == "__main__":
+    results = main()

release_2025_09_15/code/aei_report_v3_preprocessing_claude_ai.ipynb

@@ -0,0 +1,1840 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AEI Report v3 Claude.ai Preprocessing\n",
+    "\n",
+    "This notebook takes processed Clio data and enriches it with external sources:\n",
+    "1. Merges with population data for per capita calculations\n",
+    "2. Merges with GDP data for economic analysis\n",
+    "3. Merges with SOC/O*NET data for occupational analysis\n",
+    "4. Applies MIN_OBSERVATIONS filtering\n",
+    "5. Calculates derived metrics (per capita, indices, tiers)\n",
+    "6. Categorizes collaboration patterns\n",
+    "\n",
+    "**Input**: `aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv`\n",
+    "\n",
+    "**Output**: `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Configuration and Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Year for external data\n",
+    "YEAR = 2024\n",
+    "\n",
+    "# Data paths - using local directories\n",
+    "DATA_INPUT_DIR = \"../data/input\"  # Raw external data\n",
+    "DATA_INTERMEDIATE_DIR = (\n",
+    "    \"../data/intermediate\"  # Processed external data and Clio output\n",
+    ")\n",
+    "DATA_OUTPUT_DIR = \"../data/output\"  # Final enriched data\n",
+    "\n",
+    "# Minimum observation thresholds\n",
+    "MIN_OBSERVATIONS_COUNTRY = 200  # Threshold for countries\n",
+    "MIN_OBSERVATIONS_US_STATE = 100  # Threshold for US states"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Countries where Claude doesn't operate (23 countries)\n",
+    "EXCLUDED_COUNTRIES = [\n",
+    "    \"AF\",  # Afghanistan\n",
+    "    \"BY\",  # Belarus\n",
+    "    \"CD\",  # Democratic Republic of the Congo\n",
+    "    \"CF\",  # Central African Republic\n",
+    "    \"CN\",  # China\n",
+    "    \"CU\",  # Cuba\n",
+    "    \"ER\",  # Eritrea\n",
+    "    \"ET\",  # Ethiopia\n",
+    "    \"HK\",  # Hong Kong\n",
+    "    \"IR\",  # Iran\n",
+    "    \"KP\",  # North Korea\n",
+    "    \"LY\",  # Libya\n",
+    "    \"ML\",  # Mali\n",
+    "    \"MM\",  # Myanmar\n",
+    "    \"MO\",  # Macau\n",
+    "    \"NI\",  # Nicaragua\n",
+    "    \"RU\",  # Russia\n",
+    "    \"SD\",  # Sudan\n",
+    "    \"SO\",  # Somalia\n",
+    "    \"SS\",  # South Sudan\n",
+    "    \"SY\",  # Syria\n",
+    "    \"VE\",  # Venezuela\n",
+    "    \"YE\",  # Yemen\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Loading Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_population_data():\n",
+    "    \"\"\"\n",
+    "    Load population data for countries and US states.\n",
+    "\n",
+    "    Args:\n",
+    "        verbose: Whether to print progress\n",
+    "\n",
+    "    Returns:\n",
+    "        Dict with country and state_us population dataframes\n",
+    "    \"\"\"\n",
+    "    pop_country_path = (\n",
+    "        Path(DATA_INTERMEDIATE_DIR) / f\"working_age_pop_{YEAR}_country.csv\"\n",
+    "    )\n",
+    "    pop_state_path = (\n",
+    "        Path(DATA_INTERMEDIATE_DIR) / f\"working_age_pop_{YEAR}_us_state.csv\"\n",
+    "    )\n",
+    "\n",
+    "    if not pop_country_path.exists() or not pop_state_path.exists():\n",
+    "        raise FileNotFoundError(\n",
+    "            f\"Population data is required but not found.\\n\"\n",
+    "            f\"  Expected files:\\n\"\n",
+    "            f\"    - {pop_country_path}\\n\"\n",
+    "            f\"    - {pop_state_path}\\n\"\n",
+    "            f\"  Run preprocess_population.py first to generate these files.\"\n",
+    "        )\n",
+    "\n",
+    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
+    "    df_pop_country = pd.read_csv(\n",
+    "        pop_country_path, keep_default_na=False, na_values=[\"\"]\n",
+    "    )\n",
+    "    df_pop_state = pd.read_csv(pop_state_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "    return {\"country\": df_pop_country, \"state_us\": df_pop_state}\n",
+    "\n",
+    "\n",
+    "def load_gdp_data():\n",
+    "    \"\"\"\n",
+    "    Load GDP data for countries and US states.\n",
+    "\n",
+    "    Returns:\n",
+    "        Dict with country and state_us GDP dataframes\n",
+    "    \"\"\"\n",
+    "    gdp_country_path = Path(DATA_INTERMEDIATE_DIR) / f\"gdp_{YEAR}_country.csv\"\n",
+    "    gdp_state_path = Path(DATA_INTERMEDIATE_DIR) / f\"gdp_{YEAR}_us_state.csv\"\n",
+    "\n",
+    "    if not gdp_country_path.exists() or not gdp_state_path.exists():\n",
+    "        raise FileNotFoundError(\n",
+    "            f\"GDP data is required but not found.\\n\"\n",
+    "            f\"  Expected files:\\n\"\n",
+    "            f\"    - {gdp_country_path}\\n\"\n",
+    "            f\"    - {gdp_state_path}\\n\"\n",
+    "            f\"  Run preprocess_gdp.py first to generate these files.\"\n",
+    "        )\n",
+    "\n",
+    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
+    "    df_gdp_country = pd.read_csv(\n",
+    "        gdp_country_path, keep_default_na=False, na_values=[\"\"]\n",
+    "    )\n",
+    "    df_gdp_state = pd.read_csv(gdp_state_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "    return {\"country\": df_gdp_country, \"state_us\": df_gdp_state}\n",
+    "\n",
+    "\n",
+    "def load_task_data():\n",
+    "    \"\"\"\n",
+    "    Load O*NET task statements with SOC codes.\n",
+    "\n",
+    "    Returns:\n",
+    "        DataFrame with O*NET tasks and SOC major groups\n",
+    "    \"\"\"\n",
+    "    onet_path = Path(DATA_INTERMEDIATE_DIR) / \"onet_task_statements.csv\"\n",
+    "\n",
+    "    if not onet_path.exists():\n",
+    "        raise FileNotFoundError(\n",
+    "            f\"O*NET data is required but not found.\\n\"\n",
+    "            f\"  Expected file:\\n\"\n",
+    "            f\"    - {onet_path}\\n\"\n",
+    "            f\"  Run preprocess_onet.py first to generate this file.\"\n",
+    "        )\n",
+    "\n",
+    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
+    "    df_onet = pd.read_csv(onet_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "    # Normalize task names for matching with Clio data\n",
+    "    df_onet[\"task_normalized\"] = df_onet[\"Task\"].str.lower().str.strip()\n",
+    "\n",
+    "    return df_onet\n",
+    "\n",
+    "\n",
+    "def load_soc_data():\n",
+    "    \"\"\"\n",
+    "    Load SOC structure data for occupation names.\n",
+    "\n",
+    "    Returns:\n",
+    "        DataFrame with SOC major groups and their titles\n",
+    "    \"\"\"\n",
+    "    soc_path = Path(DATA_INTERMEDIATE_DIR) / \"soc_structure.csv\"\n",
+    "\n",
+    "    if not soc_path.exists():\n",
+    "        raise FileNotFoundError(\n",
+    "            f\"SOC structure data is required but not found.\\n\"\n",
+    "            f\"  Expected file:\\n\"\n",
+    "            f\"    - {soc_path}\\n\"\n",
+    "            f\"  Run preprocess_onet.py first to generate this file.\"\n",
+    "        )\n",
+    "\n",
+    "    # Use keep_default_na=False to preserve any \"NA\" values as strings\n",
+    "    df_soc = pd.read_csv(soc_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "    # Get unique major groups with their titles for SOC name mapping\n",
+    "    df_major_groups = df_soc[df_soc[\"soc_major_group\"].notna()][\n",
+    "        [\"soc_major_group\", \"SOC or O*NET-SOC 2019 Title\"]\n",
+    "    ].drop_duplicates(subset=[\"soc_major_group\"])\n",
+    "\n",
+    "    return df_major_groups\n",
+    "\n",
+    "\n",
+    "def load_external_data():\n",
+    "    \"\"\"\n",
+    "    Load all external data sources from local files.\n",
+    "\n",
+    "    Returns:\n",
+    "        Dict with population, gdp, task_statements, and soc_structure dataframes\n",
+    "    \"\"\"\n",
+    "\n",
+    "    external_data = {}\n",
+    "\n",
+    "    # Load each data source with its specific function\n",
+    "    external_data[\"population\"] = load_population_data()\n",
+    "    external_data[\"gdp\"] = load_gdp_data()\n",
+    "    external_data[\"task_statements\"] = load_task_data()\n",
+    "    external_data[\"soc_structure\"] = load_soc_data()\n",
+    "\n",
+    "    return external_data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Filtering Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_filtered_geographies(df):\n",
+    "    \"\"\"\n",
+    "    Get lists of countries and states that meet MIN_OBSERVATIONS thresholds.\n",
+    "\n",
+    "    This function does NOT filter the dataframe - it only identifies which\n",
+    "    geographies meet the thresholds. The full dataframe is preserved\n",
+    "    so we can still report statistics for all geographies.\n",
+    "\n",
+    "    Args:\n",
+    "        df: Input dataframe\n",
+    "\n",
+    "    Returns:\n",
+    "        Tuple of (filtered_countries list, filtered_states list)\n",
+    "    \"\"\"\n",
+    "    # Get country usage counts\n",
+    "    country_usage = df[\n",
+    "        (df[\"facet\"] == \"country\") & (df[\"variable\"] == \"usage_count\")\n",
+    "    ].set_index(\"geo_id\")[\"value\"]\n",
+    "\n",
+    "    # Get state usage counts\n",
+    "    state_usage = df[\n",
+    "        (df[\"facet\"] == \"state_us\") & (df[\"variable\"] == \"usage_count\")\n",
+    "    ].set_index(\"geo_id\")[\"value\"]\n",
+    "\n",
+    "    # Get countries that meet MIN_OBSERVATIONS threshold\n",
+    "    filtered_countries = country_usage[\n",
+    "        country_usage >= MIN_OBSERVATIONS_COUNTRY\n",
+    "    ].index.tolist()\n",
+    "\n",
+    "    # Get states that meet MIN_OBSERVATIONS threshold\n",
+    "    filtered_states = state_usage[\n",
+    "        state_usage >= MIN_OBSERVATIONS_US_STATE\n",
+    "    ].index.tolist()\n",
+    "\n",
+    "    return filtered_countries, filtered_states"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Merge Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def merge_population_data(df, population_data):\n",
+    "    \"\"\"\n",
+    "    Merge population data in long format.\n",
+    "\n",
+    "    This function:\n",
+    "    1. Adds countries/states that have population but no usage (with 0 usage values)\n",
+    "    2. Adds population as new rows with variable=\"working_age_pop\"\n",
+    "\n",
+    "    Args:\n",
+    "        df: Input dataframe in long format\n",
+    "        population_data: Dict with country and state_us population dataframes\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with all geographies and population added as rows\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "    new_rows = []\n",
+    "\n",
+    "    # Get unique date/platform combinations to replicate for new data\n",
+    "    date_platform_combos = df_result[\n",
+    "        [\"date_start\", \"date_end\", \"platform_and_product\"]\n",
+    "    ].drop_duplicates()\n",
+    "\n",
+    "    # Process countries\n",
+    "    if \"country\" in population_data and not population_data[\"country\"].empty:\n",
+    "        pop_country = population_data[\"country\"]\n",
+    "\n",
+    "        # Get existing countries in our data\n",
+    "        existing_countries = df_result[\n",
+    "            (df_result[\"geography\"] == \"country\")\n",
+    "            & (df_result[\"variable\"] == \"usage_count\")\n",
+    "        ][\"geo_id\"].unique()\n",
+    "\n",
+    "        # Add missing countries with 0 usage (excluding excluded countries)\n",
+    "        missing_countries = (\n",
+    "            set(pop_country[\"country_code\"])\n",
+    "            - set(existing_countries)\n",
+    "            - set(EXCLUDED_COUNTRIES)\n",
+    "        )\n",
+    "\n",
+    "        for _, combo in date_platform_combos.iterrows():\n",
+    "            # Add missing countries with 0 usage (both count and percentage)\n",
+    "            for country_code in missing_countries:\n",
+    "                # Add usage_count = 0\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": country_code,\n",
+    "                        \"geography\": \"country\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"country\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"usage_count\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": 0.0,\n",
+    "                    }\n",
+    "                )\n",
+    "                # Add usage_pct = 0\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": country_code,\n",
+    "                        \"geography\": \"country\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"country\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"usage_pct\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": 0.0,\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "            # Add population data for all countries (that are not excluded)\n",
+    "            for _, pop_row in pop_country.iterrows():\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": pop_row[\"country_code\"],\n",
+    "                        \"geography\": \"country\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"country\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"working_age_pop\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": float(pop_row[\"working_age_pop\"]),\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "    # Process US states\n",
+    "    if \"state_us\" in population_data and not population_data[\"state_us\"].empty:\n",
+    "        pop_state = population_data[\"state_us\"]\n",
+    "\n",
+    "        # Get existing states in our data\n",
+    "        existing_states = df_result[\n",
+    "            (df_result[\"geography\"] == \"state_us\")\n",
+    "            & (df_result[\"variable\"] == \"usage_count\")\n",
+    "        ][\"geo_id\"].unique()\n",
+    "\n",
+    "        # Add missing states with 0 usage\n",
+    "        missing_states = set(pop_state[\"state_code\"]) - set(existing_states)\n",
+    "\n",
+    "        for _, combo in date_platform_combos.iterrows():\n",
+    "            # Add missing states with 0 usage (both count and percentage)\n",
+    "            for state_code in missing_states:\n",
+    "                # Add usage_count = 0\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": state_code,\n",
+    "                        \"geography\": \"state_us\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"state_us\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"usage_count\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": 0.0,\n",
+    "                    }\n",
+    "                )\n",
+    "                # Add usage_pct = 0\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": state_code,\n",
+    "                        \"geography\": \"state_us\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"state_us\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"usage_pct\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": 0.0,\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "            # Add population data for all states\n",
+    "            for _, pop_row in pop_state.iterrows():\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": pop_row[\"state_code\"],\n",
+    "                        \"geography\": \"state_us\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"state_us\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"working_age_pop\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": float(pop_row[\"working_age_pop\"]),\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "    # Add all new rows to the dataframe\n",
+    "    if new_rows:\n",
+    "        df_new = pd.DataFrame(new_rows)\n",
+    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
+    "\n",
+    "    return df_result\n",
+    "\n",
+    "\n",
+    "def merge_gdp_data(df, gdp_data, population_data):\n",
+    "    \"\"\"\n",
+    "    Merge GDP data and calculate GDP per working age capita.\n",
+    "\n",
+    "    Since we have total GDP in actual dollars, we divide by population to get per capita.\n",
+    "\n",
+    "    Args:\n",
+    "        df: Input dataframe in long format\n",
+    "        gdp_data: Dict with country and state_us GDP dataframes (total GDP in dollars)\n",
+    "        population_data: Dict with country and state_us population dataframes\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with GDP per capita data added as rows\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "    new_rows = []\n",
+    "\n",
+    "    # Get unique date/platform combinations\n",
+    "    date_platform_combos = df_result[\n",
+    "        [\"date_start\", \"date_end\", \"platform_and_product\"]\n",
+    "    ].drop_duplicates()\n",
+    "\n",
+    "    # Process country GDP\n",
+    "    if \"country\" in gdp_data and \"country\" in population_data:\n",
+    "        gdp_country = gdp_data[\"country\"]\n",
+    "        pop_country = population_data[\"country\"]\n",
+    "\n",
+    "        # Merge GDP with population to calculate per capita\n",
+    "        gdp_pop = gdp_country.merge(pop_country, on=\"iso_alpha_3\", how=\"inner\")\n",
+    "\n",
+    "        # Calculate GDP per working age capita\n",
+    "        gdp_pop[\"gdp_per_working_age_capita\"] = (\n",
+    "            gdp_pop[\"gdp_total\"] / gdp_pop[\"working_age_pop\"]\n",
+    "        )\n",
+    "\n",
+    "        for _, combo in date_platform_combos.iterrows():\n",
+    "            for _, gdp_row in gdp_pop.iterrows():\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": gdp_row[\"country_code\"],  # Use 2-letter code\n",
+    "                        \"geography\": \"country\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"country\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"gdp_per_working_age_capita\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": float(gdp_row[\"gdp_per_working_age_capita\"]),\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "    # Process state GDP\n",
+    "    if \"state_us\" in gdp_data and \"state_us\" in population_data:\n",
+    "        gdp_state = gdp_data[\"state_us\"]\n",
+    "        pop_state = population_data[\"state_us\"]\n",
+    "\n",
+    "        # Merge GDP with population\n",
+    "        # Column names from preprocess_gdp.py: state_code, gdp_total (in actual dollars)\n",
+    "        gdp_pop = gdp_state.merge(pop_state, on=\"state_code\", how=\"inner\")\n",
+    "\n",
+    "        # Calculate GDP per working age capita\n",
+    "        gdp_pop[\"gdp_per_working_age_capita\"] = (\n",
+    "            gdp_pop[\"gdp_total\"] / gdp_pop[\"working_age_pop\"]\n",
+    "        )\n",
+    "\n",
+    "        for _, combo in date_platform_combos.iterrows():\n",
+    "            for _, gdp_row in gdp_pop.iterrows():\n",
+    "                new_rows.append(\n",
+    "                    {\n",
+    "                        \"geo_id\": gdp_row[\"state_code\"],\n",
+    "                        \"geography\": \"state_us\",\n",
+    "                        \"date_start\": combo[\"date_start\"],\n",
+    "                        \"date_end\": combo[\"date_end\"],\n",
+    "                        \"platform_and_product\": combo[\"platform_and_product\"],\n",
+    "                        \"facet\": \"state_us\",\n",
+    "                        \"level\": 0,\n",
+    "                        \"variable\": \"gdp_per_working_age_capita\",\n",
+    "                        \"cluster_name\": \"\",\n",
+    "                        \"value\": float(gdp_row[\"gdp_per_working_age_capita\"]),\n",
+    "                    }\n",
+    "                )\n",
+    "\n",
+    "    # Add all new rows to the dataframe\n",
+    "    if new_rows:\n",
+    "        df_new = pd.DataFrame(new_rows)\n",
+    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
+    "\n",
+    "    return df_result\n",
+    "\n",
+    "\n",
+    "def calculate_soc_distribution(\n",
+    "    df, df_onet, df_soc_structure, filtered_countries=None, filtered_states=None\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Calculate SOC occupation distribution from O*NET task usage.\n",
+    "\n",
+    "    This uses the following approach:\n",
+    "    1. Map tasks directly to SOC major groups (with minimal double counting)\n",
+    "    2. Combine \"none\" and \"not_classified\" tasks into a single \"not_classified\" SOC group\n",
+    "    3. Sum percentages by SOC group\n",
+    "    4. Normalize to 100% for each geography\n",
+    "    5. Calculate for countries, US states, and global that meet MIN_OBSERVATIONS threshold\n",
+    "\n",
+    "    NOTE: For US states, only ~449 O*NET tasks have state-level data (those with sufficient\n",
+    "    observations), but these tasks still map to SOC groups the same way as for countries.\n",
+    "\n",
+    "    Args:\n",
+    "        df: DataFrame with O*NET task percentages\n",
+    "        df_onet: O*NET task data with SOC codes\n",
+    "        df_soc_structure: SOC structure with major group names\n",
+    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS (optional)\n",
+    "        filtered_states: List of states that meet MIN_OBSERVATIONS (optional)\n",
+    "\n",
+    "    Returns:\n",
+    "        DataFrame with SOC distribution rows added\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "    soc_rows = []\n",
+    "\n",
+    "    # Get all O*NET task percentage data (including not_classified and \"none\")\n",
+    "    df_task_pct_all = df_result[\n",
+    "        (df_result[\"facet\"] == \"onet_task\") & (df_result[\"variable\"] == \"onet_task_pct\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    if df_task_pct_all.empty:\n",
+    "        return df_result\n",
+    "\n",
+    "    # Build masks for each geography type\n",
+    "    # Always include global\n",
+    "    global_mask = df_task_pct_all[\"geography\"] == \"global\"\n",
+    "\n",
+    "    # Apply filtering for countries\n",
+    "    if filtered_countries is not None:\n",
+    "        country_mask = (df_task_pct_all[\"geography\"] == \"country\") & (\n",
+    "            df_task_pct_all[\"geo_id\"].isin(filtered_countries)\n",
+    "        )\n",
+    "    else:\n",
+    "        # If no filter, keep all countries\n",
+    "        country_mask = df_task_pct_all[\"geography\"] == \"country\"\n",
+    "\n",
+    "    # Apply filtering for states\n",
+    "    if filtered_states is not None:\n",
+    "        state_mask = (df_task_pct_all[\"geography\"] == \"state_us\") & (\n",
+    "            df_task_pct_all[\"geo_id\"].isin(filtered_states)\n",
+    "        )\n",
+    "    else:\n",
+    "        # If no filter, keep all states\n",
+    "        state_mask = df_task_pct_all[\"geography\"] == \"state_us\"\n",
+    "\n",
+    "    # Combine masks to keep relevant geographies\n",
+    "    combined_mask = global_mask | country_mask | state_mask\n",
+    "    df_task_pct_all = df_task_pct_all[combined_mask].copy()\n",
+    "\n",
+    "    if df_task_pct_all.empty:\n",
+    "        return df_result\n",
+    "\n",
+    "    # Separate not_classified and none tasks from real O*NET tasks\n",
+    "    df_not_classified = df_task_pct_all[\n",
+    "        (df_task_pct_all[\"cluster_name\"].str.contains(\"not_classified\", na=False))\n",
+    "        | (df_task_pct_all[\"cluster_name\"] == \"none\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    # Get real O*NET tasks (excluding not_classified and none)\n",
+    "    df_task_pct = df_task_pct_all[\n",
+    "        (~df_task_pct_all[\"cluster_name\"].str.contains(\"not_classified\", na=False))\n",
+    "        & (df_task_pct_all[\"cluster_name\"] != \"none\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    # Normalize task names for matching\n",
+    "    df_task_pct[\"task_normalized\"] = df_task_pct[\"cluster_name\"].str.lower().str.strip()\n",
+    "\n",
+    "    # Get unique task-SOC pairs from O*NET data\n",
+    "    # This keeps tasks that map to multiple SOC groups (different rows)\n",
+    "    df_task_soc = df_onet[[\"task_normalized\", \"soc_major_group\"]].drop_duplicates()\n",
+    "\n",
+    "    # Merge tasks with their SOC codes\n",
+    "    df_with_soc = df_task_pct.merge(df_task_soc, on=\"task_normalized\", how=\"left\")\n",
+    "\n",
+    "    # Check for unmapped tasks and raise error if found (same as for countries)\n",
+    "    unmapped_tasks = df_with_soc[df_with_soc[\"soc_major_group\"].isna()]\n",
+    "    if not unmapped_tasks.empty:\n",
+    "        unmapped_list = unmapped_tasks[\"cluster_name\"].unique()[:10]  # Show first 10\n",
+    "        n_unmapped = len(unmapped_tasks[\"cluster_name\"].unique())\n",
+    "\n",
+    "        # Check which geographies have unmapped tasks\n",
+    "        unmapped_geos = unmapped_tasks[\"geography\"].unique()\n",
+    "\n",
+    "        raise ValueError(\n",
+    "            f\"Found {n_unmapped} O*NET tasks that could not be mapped to SOC codes.\\n\"\n",
+    "            f\"Geographies with unmapped tasks: {unmapped_geos.tolist()}\\n\"\n",
+    "            f\"First 10 unmapped tasks:\\n\"\n",
+    "            + \"\\n\".join(f\"  - {task}\" for task in unmapped_list)\n",
+    "            + f\"\\n\\nThis likely means the O*NET data is out of sync with the Clio task data.\\n\"\n",
+    "            f\"Please verify that preprocess_onet.py has been run with the correct O*NET version.\"\n",
+    "        )\n",
+    "\n",
+    "    # Create SOC name mapping if SOC structure is available\n",
+    "    soc_names = {}\n",
+    "    if not df_soc_structure.empty:\n",
+    "        for _, row in df_soc_structure.iterrows():\n",
+    "            soc_code = row[\"soc_major_group\"]\n",
+    "            title = row[\"SOC or O*NET-SOC 2019 Title\"]\n",
+    "            # Clean up title (remove \"Occupations\" suffix)\n",
+    "            clean_title = title.replace(\" Occupations\", \"\").replace(\" Occupation\", \"\")\n",
+    "            soc_names[soc_code] = clean_title\n",
+    "\n",
+    "    # Group by geography and process each group\n",
+    "    geo_groups = df_with_soc.groupby(\n",
+    "        [\"geo_id\", \"geography\", \"date_start\", \"date_end\", \"platform_and_product\"]\n",
+    "    )\n",
+    "\n",
+    "    # Also group not_classified data by geography\n",
+    "    not_classified_groups = df_not_classified.groupby(\n",
+    "        [\"geo_id\", \"geography\", \"date_start\", \"date_end\", \"platform_and_product\"]\n",
+    "    )\n",
+    "\n",
+    "    # Track statistics\n",
+    "    states_with_soc = set()\n",
+    "    countries_with_soc = set()\n",
+    "\n",
+    "    # Process all geographies\n",
+    "    all_geos = set()\n",
+    "    for (geo_id, geography, date_start, date_end, platform), _ in geo_groups:\n",
+    "        all_geos.add((geo_id, geography, date_start, date_end, platform))\n",
+    "    for (geo_id, geography, date_start, date_end, platform), _ in not_classified_groups:\n",
+    "        all_geos.add((geo_id, geography, date_start, date_end, platform))\n",
+    "\n",
+    "    for geo_id, geography, date_start, date_end, platform in all_geos:\n",
+    "        # Get mapped SOC data for this geography\n",
+    "        try:\n",
+    "            geo_data = geo_groups.get_group(\n",
+    "                (geo_id, geography, date_start, date_end, platform)\n",
+    "            )\n",
+    "            # Sum percentages by SOC major group\n",
+    "            # If a task maps to multiple SOC groups, its percentage is added to each\n",
+    "            soc_totals = geo_data.groupby(\"soc_major_group\")[\"value\"].sum()\n",
+    "        except KeyError:\n",
+    "            # No mapped tasks for this geography\n",
+    "            soc_totals = pd.Series(dtype=float)\n",
+    "\n",
+    "        # Get not_classified/none data for this geography\n",
+    "        try:\n",
+    "            not_classified_data = not_classified_groups.get_group(\n",
+    "                (geo_id, geography, date_start, date_end, platform)\n",
+    "            )\n",
+    "            # Sum all not_classified and none percentages\n",
+    "            not_classified_total = not_classified_data[\"value\"].sum()\n",
+    "        except KeyError:\n",
+    "            # No not_classified/none for this geography\n",
+    "            not_classified_total = 0\n",
+    "\n",
+    "        # Combine and normalize to 100%\n",
+    "        total_pct = soc_totals.sum() + not_classified_total\n",
+    "\n",
+    "        if total_pct > 0:\n",
+    "            # Normalize mapped SOC groups\n",
+    "            if len(soc_totals) > 0:\n",
+    "                soc_normalized = (soc_totals / total_pct) * 100\n",
+    "            else:\n",
+    "                soc_normalized = pd.Series(dtype=float)\n",
+    "\n",
+    "            # Calculate normalized not_classified percentage\n",
+    "            not_classified_normalized = (not_classified_total / total_pct) * 100\n",
+    "\n",
+    "            # Track geographies that have SOC data\n",
+    "            if geography == \"state_us\":\n",
+    "                states_with_soc.add(geo_id)\n",
+    "            elif geography == \"country\":\n",
+    "                countries_with_soc.add(geo_id)\n",
+    "\n",
+    "            # Create rows for each SOC group\n",
+    "            for soc_group, pct_value in soc_normalized.items():\n",
+    "                # Get SOC name if available, otherwise use code\n",
+    "                soc_name = soc_names.get(soc_group, f\"SOC {soc_group}\")\n",
+    "\n",
+    "                soc_row = {\n",
+    "                    \"geo_id\": geo_id,\n",
+    "                    \"geography\": geography,\n",
+    "                    \"date_start\": date_start,\n",
+    "                    \"date_end\": date_end,\n",
+    "                    \"platform_and_product\": platform,\n",
+    "                    \"facet\": \"soc_occupation\",\n",
+    "                    \"level\": 0,\n",
+    "                    \"variable\": \"soc_pct\",\n",
+    "                    \"cluster_name\": soc_name,\n",
+    "                    \"value\": pct_value,\n",
+    "                }\n",
+    "                soc_rows.append(soc_row)\n",
+    "\n",
+    "            # Add not_classified SOC row if there's any not_classified/none percentage\n",
+    "            if not_classified_normalized > 0:\n",
+    "                soc_row = {\n",
+    "                    \"geo_id\": geo_id,\n",
+    "                    \"geography\": geography,\n",
+    "                    \"date_start\": date_start,\n",
+    "                    \"date_end\": date_end,\n",
+    "                    \"platform_and_product\": platform,\n",
+    "                    \"facet\": \"soc_occupation\",\n",
+    "                    \"level\": 0,\n",
+    "                    \"variable\": \"soc_pct\",\n",
+    "                    \"cluster_name\": \"not_classified\",\n",
+    "                    \"value\": not_classified_normalized,\n",
+    "                }\n",
+    "                soc_rows.append(soc_row)\n",
+    "\n",
+    "    # Print summary\n",
+    "    if countries_with_soc:\n",
+    "        print(\n",
+    "            f\"Calculated SOC distributions for {len(countries_with_soc)} countries + global\"\n",
+    "        )\n",
+    "    if states_with_soc:\n",
+    "        print(f\"Calculated SOC distributions for {len(states_with_soc)} US states\")\n",
+    "\n",
+    "    # Add all SOC rows to result\n",
+    "    if soc_rows:\n",
+    "        df_soc = pd.DataFrame(soc_rows)\n",
+    "        df_result = pd.concat([df_result, df_soc], ignore_index=True)\n",
+    "\n",
+    "    return df_result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Metric Calculation Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_per_capita_metrics(df):\n",
+    "    \"\"\"\n",
+    "    Calculate per capita metrics by joining usage and population data.\n",
+    "\n",
+    "    Since data is in long format, this function:\n",
+    "    1. Extracts usage count rows\n",
+    "    2. Extracts population rows\n",
+    "    3. Joins them and calculates per capita\n",
+    "    4. Adds results as new rows\n",
+    "\n",
+    "    Args:\n",
+    "        df: Dataframe in long format with usage and population as rows\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with per capita metrics added as new rows\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    # Define which metrics should have per capita calculations\n",
+    "    count_metrics = [\"usage_count\"]\n",
+    "\n",
+    "    # Get population data\n",
+    "    df_pop = df_result[df_result[\"variable\"] == \"working_age_pop\"][\n",
+    "        [\n",
+    "            \"geo_id\",\n",
+    "            \"geography\",\n",
+    "            \"date_start\",\n",
+    "            \"date_end\",\n",
+    "            \"platform_and_product\",\n",
+    "            \"value\",\n",
+    "        ]\n",
+    "    ].rename(columns={\"value\": \"population\"})\n",
+    "\n",
+    "    # Calculate per capita for each count metric\n",
+    "    per_capita_rows = []\n",
+    "\n",
+    "    for metric in count_metrics:\n",
+    "        # Get the count data for this metric\n",
+    "        df_metric = df_result[df_result[\"variable\"] == metric].copy()\n",
+    "\n",
+    "        # Join with population data\n",
+    "        df_joined = df_metric.merge(\n",
+    "            df_pop,\n",
+    "            on=[\n",
+    "                \"geo_id\",\n",
+    "                \"geography\",\n",
+    "                \"date_start\",\n",
+    "                \"date_end\",\n",
+    "                \"platform_and_product\",\n",
+    "            ],\n",
+    "            how=\"left\",\n",
+    "        )\n",
+    "\n",
+    "        # Calculate per capita where population exists and is > 0\n",
+    "        df_joined = df_joined[\n",
+    "            df_joined[\"population\"].notna() & (df_joined[\"population\"] > 0)\n",
+    "        ]\n",
+    "\n",
+    "        if not df_joined.empty:\n",
+    "            # Create per capita rows\n",
+    "            for _, row in df_joined.iterrows():\n",
+    "                per_capita_row = {\n",
+    "                    \"geo_id\": row[\"geo_id\"],\n",
+    "                    \"geography\": row[\"geography\"],\n",
+    "                    \"date_start\": row[\"date_start\"],\n",
+    "                    \"date_end\": row[\"date_end\"],\n",
+    "                    \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                    \"facet\": row[\"facet\"],\n",
+    "                    \"level\": row[\"level\"],\n",
+    "                    \"variable\": metric.replace(\"_count\", \"_per_capita\"),\n",
+    "                    \"cluster_name\": row[\"cluster_name\"],\n",
+    "                    \"value\": row[\"value\"] / row[\"population\"],\n",
+    "                }\n",
+    "                per_capita_rows.append(per_capita_row)\n",
+    "\n",
+    "    # Add all per capita rows to the result\n",
+    "    if per_capita_rows:\n",
+    "        df_per_capita = pd.DataFrame(per_capita_rows)\n",
+    "        df_result = pd.concat([df_result, df_per_capita], ignore_index=True)\n",
+    "\n",
+    "    return df_result\n",
+    "\n",
+    "\n",
+    "def calculate_usage_per_capita_index(df, filtered_countries=None, filtered_states=None):\n",
+    "    \"\"\"\n",
+    "    Calculate usage concentration index: (% of usage) / (% of population).\n",
+    "\n",
+    "    This shows whether a geography has more or less usage than expected based on its population.\n",
+    "    - Index = 1.0: Usage proportional to population\n",
+    "    - Index > 1.0: Over-representation (more usage than expected)\n",
+    "    - Index < 1.0: Under-representation (less usage than expected)\n",
+    "    - Index = 0.0: No usage at all\n",
+    "\n",
+    "    The function calculates the index for all countries/states that have usage data.\n",
+    "    Excluded countries don't have usage data, so they're automatically excluded.\n",
+    "    Countries with zero usage get index=0 naturally from the calculation.\n",
+    "\n",
+    "    Args:\n",
+    "        df: Dataframe with usage and population data\n",
+    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold (used for baseline calculation)\n",
+    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold (used for baseline calculation)\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with usage concentration index added as new rows\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    index_rows = []\n",
+    "\n",
+    "    # Process countries\n",
+    "    # Get all countries with usage data (excluded countries won't be here)\n",
+    "    df_usage_country = df_result[\n",
+    "        (df_result[\"geography\"] == \"country\") & (df_result[\"variable\"] == \"usage_count\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    # Get population data for the same countries\n",
+    "    df_pop_country = df_result[\n",
+    "        (df_result[\"geography\"] == \"country\")\n",
+    "        & (df_result[\"variable\"] == \"working_age_pop\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    if not df_usage_country.empty and not df_pop_country.empty:\n",
+    "        # For baseline calculation, use filtered countries if provided, otherwise use all\n",
+    "        if filtered_countries is not None:\n",
+    "            # Calculate totals using only filtered countries for the baseline\n",
+    "            usage_for_baseline = df_usage_country[\n",
+    "                df_usage_country[\"geo_id\"].isin(filtered_countries)\n",
+    "            ]\n",
+    "            pop_for_baseline = df_pop_country[\n",
+    "                df_pop_country[\"geo_id\"].isin(filtered_countries)\n",
+    "            ]\n",
+    "            total_usage = usage_for_baseline[\"value\"].sum()\n",
+    "            total_pop = pop_for_baseline[\"value\"].sum()\n",
+    "        else:\n",
+    "            # Use all countries for baseline\n",
+    "            total_usage = df_usage_country[\"value\"].sum()\n",
+    "            total_pop = df_pop_country[\"value\"].sum()\n",
+    "\n",
+    "        if total_usage > 0 and total_pop > 0:\n",
+    "            # Calculate index for all countries (not just filtered)\n",
+    "            for _, usage_row in df_usage_country.iterrows():\n",
+    "                # Find corresponding population\n",
+    "                pop_value = df_pop_country[\n",
+    "                    df_pop_country[\"geo_id\"] == usage_row[\"geo_id\"]\n",
+    "                ][\"value\"].values\n",
+    "\n",
+    "                if len(pop_value) > 0 and pop_value[0] > 0:\n",
+    "                    # Calculate shares\n",
+    "                    usage_share = (\n",
+    "                        usage_row[\"value\"] / total_usage\n",
+    "                        if usage_row[\"value\"] > 0\n",
+    "                        else 0\n",
+    "                    )\n",
+    "                    pop_share = pop_value[0] / total_pop\n",
+    "\n",
+    "                    # Calculate index (will be 0 if usage is 0)\n",
+    "                    index_value = usage_share / pop_share if pop_share > 0 else 0\n",
+    "\n",
+    "                    index_row = {\n",
+    "                        \"geo_id\": usage_row[\"geo_id\"],\n",
+    "                        \"geography\": usage_row[\"geography\"],\n",
+    "                        \"date_start\": usage_row[\"date_start\"],\n",
+    "                        \"date_end\": usage_row[\"date_end\"],\n",
+    "                        \"platform_and_product\": usage_row[\"platform_and_product\"],\n",
+    "                        \"facet\": usage_row[\"facet\"],\n",
+    "                        \"level\": usage_row[\"level\"],\n",
+    "                        \"variable\": \"usage_per_capita_index\",\n",
+    "                        \"cluster_name\": usage_row[\"cluster_name\"],\n",
+    "                        \"value\": index_value,\n",
+    "                    }\n",
+    "                    index_rows.append(index_row)\n",
+    "\n",
+    "    # Process states\n",
+    "    # Get all states with usage data\n",
+    "    df_usage_state = df_result[\n",
+    "        (df_result[\"geography\"] == \"state_us\")\n",
+    "        & (df_result[\"variable\"] == \"usage_count\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    # Get population data for the same states\n",
+    "    df_pop_state = df_result[\n",
+    "        (df_result[\"geography\"] == \"state_us\")\n",
+    "        & (df_result[\"variable\"] == \"working_age_pop\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    if not df_usage_state.empty and not df_pop_state.empty:\n",
+    "        # For baseline calculation, use filtered states if provided, otherwise use all\n",
+    "        if filtered_states is not None:\n",
+    "            # Calculate totals using only filtered states for the baseline\n",
+    "            usage_for_baseline = df_usage_state[\n",
+    "                df_usage_state[\"geo_id\"].isin(filtered_states)\n",
+    "            ]\n",
+    "            pop_for_baseline = df_pop_state[\n",
+    "                df_pop_state[\"geo_id\"].isin(filtered_states)\n",
+    "            ]\n",
+    "            total_usage = usage_for_baseline[\"value\"].sum()\n",
+    "            total_pop = pop_for_baseline[\"value\"].sum()\n",
+    "        else:\n",
+    "            # Use all states for baseline\n",
+    "            total_usage = df_usage_state[\"value\"].sum()\n",
+    "            total_pop = df_pop_state[\"value\"].sum()\n",
+    "\n",
+    "        if total_usage > 0 and total_pop > 0:\n",
+    "            # Calculate index for all states (not just filtered)\n",
+    "            for _, usage_row in df_usage_state.iterrows():\n",
+    "                # Find corresponding population\n",
+    "                pop_value = df_pop_state[df_pop_state[\"geo_id\"] == usage_row[\"geo_id\"]][\n",
+    "                    \"value\"\n",
+    "                ].values\n",
+    "\n",
+    "                if len(pop_value) > 0 and pop_value[0] > 0:\n",
+    "                    # Calculate shares\n",
+    "                    usage_share = (\n",
+    "                        usage_row[\"value\"] / total_usage\n",
+    "                        if usage_row[\"value\"] > 0\n",
+    "                        else 0\n",
+    "                    )\n",
+    "                    pop_share = pop_value[0] / total_pop\n",
+    "\n",
+    "                    # Calculate index (will be 0 if usage is 0)\n",
+    "                    index_value = usage_share / pop_share if pop_share > 0 else 0\n",
+    "\n",
+    "                    index_row = {\n",
+    "                        \"geo_id\": usage_row[\"geo_id\"],\n",
+    "                        \"geography\": usage_row[\"geography\"],\n",
+    "                        \"date_start\": usage_row[\"date_start\"],\n",
+    "                        \"date_end\": usage_row[\"date_end\"],\n",
+    "                        \"platform_and_product\": usage_row[\"platform_and_product\"],\n",
+    "                        \"facet\": usage_row[\"facet\"],\n",
+    "                        \"level\": usage_row[\"level\"],\n",
+    "                        \"variable\": \"usage_per_capita_index\",\n",
+    "                        \"cluster_name\": usage_row[\"cluster_name\"],\n",
+    "                        \"value\": index_value,\n",
+    "                    }\n",
+    "                    index_rows.append(index_row)\n",
+    "\n",
+    "    # Add all index rows to result\n",
+    "    if index_rows:\n",
+    "        df_index = pd.DataFrame(index_rows)\n",
+    "        df_result = pd.concat([df_result, df_index], ignore_index=True)\n",
+    "\n",
+    "    return df_result\n",
+    "\n",
+    "\n",
+    "def calculate_category_percentage_index(\n",
+    "    df, filtered_countries=None, filtered_states=None\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Calculate category percentage index for facet specialization.\n",
+    "\n",
+    "    For countries: Compare to global percentage for that cluster\n",
+    "    For US states: Compare to US country percentage for that cluster\n",
+    "\n",
+    "    Only calculates for countries/states that meet MIN_OBSERVATIONS.\n",
+    "    Excludes \"not_classified\" and \"none\" categories as these are catch-alls.\n",
+    "\n",
+    "    Args:\n",
+    "        df: Dataframe with percentage metrics as rows\n",
+    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold\n",
+    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with category percentage index added as new rows (only for filtered geographies)\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    # Process percentage metrics for content facets\n",
+    "    pct_vars = [\"onet_task_pct\", \"collaboration_pct\", \"request_pct\"]\n",
+    "\n",
+    "    index_rows = []\n",
+    "\n",
+    "    for pct_var in pct_vars:\n",
+    "        # Get the base facet name\n",
+    "        facet_name = pct_var.replace(\"_pct\", \"\")\n",
+    "\n",
+    "        # Get percentage data for this variable\n",
+    "        df_pct = df_result[\n",
+    "            (df_result[\"variable\"] == pct_var) & (df_result[\"facet\"] == facet_name)\n",
+    "        ].copy()\n",
+    "\n",
+    "        # Exclude not_classified and none categories from index calculation\n",
+    "        # These are catch-all/no-pattern categories that don't provide meaningful comparisons\n",
+    "        df_pct = df_pct[~df_pct[\"cluster_name\"].isin([\"not_classified\", \"none\"])]\n",
+    "\n",
+    "        if not df_pct.empty and \"cluster_name\" in df_pct.columns:\n",
+    "            # Check if this facet has levels (like request)\n",
+    "            has_levels = df_pct[\"level\"].notna().any() and (df_pct[\"level\"] != 0).any()\n",
+    "\n",
+    "            if has_levels:\n",
+    "                # Process each level separately\n",
+    "                levels = df_pct[\"level\"].dropna().unique()\n",
+    "\n",
+    "                for level in levels:\n",
+    "                    df_level = df_pct[df_pct[\"level\"] == level].copy()\n",
+    "\n",
+    "                    # Get global baselines for this level\n",
+    "                    global_baselines = (\n",
+    "                        df_level[\n",
+    "                            (df_level[\"geography\"] == \"global\")\n",
+    "                            & (df_level[\"geo_id\"] == \"GLOBAL\")\n",
+    "                        ]\n",
+    "                        .set_index(\"cluster_name\")[\"value\"]\n",
+    "                        .to_dict()\n",
+    "                    )\n",
+    "\n",
+    "                    # Get US baselines for this level\n",
+    "                    us_baselines = (\n",
+    "                        df_level[\n",
+    "                            (df_level[\"geography\"] == \"country\")\n",
+    "                            & (df_level[\"geo_id\"] == \"US\")\n",
+    "                        ]\n",
+    "                        .set_index(\"cluster_name\")[\"value\"]\n",
+    "                        .to_dict()\n",
+    "                    )\n",
+    "\n",
+    "                    # Process countries for this level\n",
+    "                    if filtered_countries is not None and global_baselines:\n",
+    "                        df_countries = df_level[\n",
+    "                            (df_level[\"geography\"] == \"country\")\n",
+    "                            & (df_level[\"geo_id\"].isin(filtered_countries))\n",
+    "                        ].copy()\n",
+    "\n",
+    "                        for _, row in df_countries.iterrows():\n",
+    "                            baseline = global_baselines.get(row[\"cluster_name\"])\n",
+    "\n",
+    "                            if baseline and baseline > 0:\n",
+    "                                index_row = {\n",
+    "                                    \"geo_id\": row[\"geo_id\"],\n",
+    "                                    \"geography\": row[\"geography\"],\n",
+    "                                    \"date_start\": row[\"date_start\"],\n",
+    "                                    \"date_end\": row[\"date_end\"],\n",
+    "                                    \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                    \"facet\": row[\"facet\"],\n",
+    "                                    \"level\": row[\"level\"],\n",
+    "                                    \"variable\": f\"{facet_name}_pct_index\",\n",
+    "                                    \"cluster_name\": row[\"cluster_name\"],\n",
+    "                                    \"value\": row[\"value\"] / baseline,\n",
+    "                                }\n",
+    "                                index_rows.append(index_row)\n",
+    "\n",
+    "                    # Process states for this level\n",
+    "                    if filtered_states is not None and us_baselines:\n",
+    "                        df_states = df_level[\n",
+    "                            (df_level[\"geography\"] == \"state_us\")\n",
+    "                            & (df_level[\"geo_id\"].isin(filtered_states))\n",
+    "                        ].copy()\n",
+    "\n",
+    "                        for _, row in df_states.iterrows():\n",
+    "                            baseline = us_baselines.get(row[\"cluster_name\"])\n",
+    "\n",
+    "                            if baseline and baseline > 0:\n",
+    "                                index_row = {\n",
+    "                                    \"geo_id\": row[\"geo_id\"],\n",
+    "                                    \"geography\": row[\"geography\"],\n",
+    "                                    \"date_start\": row[\"date_start\"],\n",
+    "                                    \"date_end\": row[\"date_end\"],\n",
+    "                                    \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                    \"facet\": row[\"facet\"],\n",
+    "                                    \"level\": row[\"level\"],\n",
+    "                                    \"variable\": f\"{facet_name}_pct_index\",\n",
+    "                                    \"cluster_name\": row[\"cluster_name\"],\n",
+    "                                    \"value\": row[\"value\"] / baseline,\n",
+    "                                }\n",
+    "                                index_rows.append(index_row)\n",
+    "            else:\n",
+    "                # No levels (onet_task, collaboration)\n",
+    "                # Get global baselines\n",
+    "                global_baselines = (\n",
+    "                    df_pct[\n",
+    "                        (df_pct[\"geography\"] == \"global\")\n",
+    "                        & (df_pct[\"geo_id\"] == \"GLOBAL\")\n",
+    "                    ]\n",
+    "                    .set_index(\"cluster_name\")[\"value\"]\n",
+    "                    .to_dict()\n",
+    "                )\n",
+    "\n",
+    "                # Get US baselines\n",
+    "                us_baselines = (\n",
+    "                    df_pct[\n",
+    "                        (df_pct[\"geography\"] == \"country\") & (df_pct[\"geo_id\"] == \"US\")\n",
+    "                    ]\n",
+    "                    .set_index(\"cluster_name\")[\"value\"]\n",
+    "                    .to_dict()\n",
+    "                )\n",
+    "\n",
+    "                # Process countries\n",
+    "                if filtered_countries is not None and global_baselines:\n",
+    "                    df_countries = df_pct[\n",
+    "                        (df_pct[\"geography\"] == \"country\")\n",
+    "                        & (df_pct[\"geo_id\"].isin(filtered_countries))\n",
+    "                    ].copy()\n",
+    "\n",
+    "                    for _, row in df_countries.iterrows():\n",
+    "                        baseline = global_baselines.get(row[\"cluster_name\"])\n",
+    "\n",
+    "                        if baseline and baseline > 0:\n",
+    "                            index_row = {\n",
+    "                                \"geo_id\": row[\"geo_id\"],\n",
+    "                                \"geography\": row[\"geography\"],\n",
+    "                                \"date_start\": row[\"date_start\"],\n",
+    "                                \"date_end\": row[\"date_end\"],\n",
+    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                \"facet\": row[\"facet\"],\n",
+    "                                \"level\": row[\"level\"],\n",
+    "                                \"variable\": f\"{facet_name}_pct_index\",\n",
+    "                                \"cluster_name\": row[\"cluster_name\"],\n",
+    "                                \"value\": row[\"value\"] / baseline,\n",
+    "                            }\n",
+    "                            index_rows.append(index_row)\n",
+    "\n",
+    "                # Process states\n",
+    "                if filtered_states is not None and us_baselines:\n",
+    "                    df_states = df_pct[\n",
+    "                        (df_pct[\"geography\"] == \"state_us\")\n",
+    "                        & (df_pct[\"geo_id\"].isin(filtered_states))\n",
+    "                    ].copy()\n",
+    "\n",
+    "                    for _, row in df_states.iterrows():\n",
+    "                        baseline = us_baselines.get(row[\"cluster_name\"])\n",
+    "\n",
+    "                        if baseline and baseline > 0:\n",
+    "                            index_row = {\n",
+    "                                \"geo_id\": row[\"geo_id\"],\n",
+    "                                \"geography\": row[\"geography\"],\n",
+    "                                \"date_start\": row[\"date_start\"],\n",
+    "                                \"date_end\": row[\"date_end\"],\n",
+    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                \"facet\": row[\"facet\"],\n",
+    "                                \"level\": row[\"level\"],\n",
+    "                                \"variable\": f\"{facet_name}_pct_index\",\n",
+    "                                \"cluster_name\": row[\"cluster_name\"],\n",
+    "                                \"value\": row[\"value\"] / baseline,\n",
+    "                            }\n",
+    "                            index_rows.append(index_row)\n",
+    "\n",
+    "    # Add all index rows to result\n",
+    "    if index_rows:\n",
+    "        df_index = pd.DataFrame(index_rows)\n",
+    "        df_result = pd.concat([df_result, df_index], ignore_index=True)\n",
+    "\n",
+    "    return df_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_usage_tiers(df, n_tiers=4, filtered_countries=None, filtered_states=None):\n",
+    "    \"\"\"\n",
+    "    Calculate usage tiers based on indexed per capita usage.\n",
+    "    - Tier 0: Zero adoption (index = 0)\n",
+    "    - Tiers 1-4: Quartiles based on thresholds from filtered countries/states\n",
+    "\n",
+    "    Quartile thresholds are calculated using only countries/states with ≥MIN_OBSERVATIONS,\n",
+    "    but applied to all countries/states to ensure complete visualization.\n",
+    "\n",
+    "    Note: Tier assignments for countries/states with <MIN_OBSERVATIONS should be\n",
+    "    interpreted with caution due to sample size limitations.\n",
+    "\n",
+    "    Args:\n",
+    "        df: Input dataframe\n",
+    "        n_tiers: Number of quartiles to create for non-zero usage (default 4)\n",
+    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS threshold\n",
+    "        filtered_states: List of states that meet MIN_OBSERVATIONS threshold\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with usage tier rows added\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    # Calculate tiers for indexed per capita metrics\n",
+    "    if \"variable\" in df_result.columns and \"value\" in df_result.columns:\n",
+    "        index_vars = [\"usage_per_capita_index\"]\n",
+    "\n",
+    "        quartile_labels = [\n",
+    "            \"Emerging (bottom 25%)\",\n",
+    "            \"Lower middle (25-50%)\",\n",
+    "            \"Upper middle (50-75%)\",\n",
+    "            \"Leading (top 25%)\",\n",
+    "        ]\n",
+    "\n",
+    "        tier_rows = []\n",
+    "\n",
+    "        for var in index_vars:\n",
+    "            # Process countries\n",
+    "            # Get all countries with the index variable\n",
+    "            all_country_data = df_result[\n",
+    "                (df_result[\"variable\"] == var) & (df_result[\"geography\"] == \"country\")\n",
+    "            ].copy()\n",
+    "\n",
+    "            if not all_country_data.empty:\n",
+    "                # Separate zero and non-zero usage\n",
+    "                zero_usage = all_country_data[all_country_data[\"value\"] == 0].copy()\n",
+    "                nonzero_usage = all_country_data[all_country_data[\"value\"] > 0].copy()\n",
+    "\n",
+    "                # Calculate quartile thresholds using ONLY filtered countries\n",
+    "                if filtered_countries is not None and not nonzero_usage.empty:\n",
+    "                    # Get only filtered countries for quartile calculation\n",
+    "                    filtered_for_quartiles = nonzero_usage[\n",
+    "                        nonzero_usage[\"geo_id\"].isin(filtered_countries)\n",
+    "                    ].copy()\n",
+    "\n",
+    "                    if not filtered_for_quartiles.empty:\n",
+    "                        # Calculate quartile thresholds from filtered countries\n",
+    "                        quartiles = (\n",
+    "                            filtered_for_quartiles[\"value\"]\n",
+    "                            .quantile([0.25, 0.5, 0.75])\n",
+    "                            .values\n",
+    "                        )\n",
+    "\n",
+    "                        # Apply thresholds to all non-zero countries\n",
+    "                        for _, row in nonzero_usage.iterrows():\n",
+    "                            value = row[\"value\"]\n",
+    "\n",
+    "                            # Assign tier based on thresholds\n",
+    "                            if value <= quartiles[0]:\n",
+    "                                tier_label = quartile_labels[0]  # Bottom 25%\n",
+    "                                tier_value = 1\n",
+    "                            elif value <= quartiles[1]:\n",
+    "                                tier_label = quartile_labels[1]  # 25-50%\n",
+    "                                tier_value = 2\n",
+    "                            elif value <= quartiles[2]:\n",
+    "                                tier_label = quartile_labels[2]  # 50-75%\n",
+    "                                tier_value = 3\n",
+    "                            else:\n",
+    "                                tier_label = quartile_labels[3]  # Top 25%\n",
+    "                                tier_value = 4\n",
+    "\n",
+    "                            tier_row = {\n",
+    "                                \"geo_id\": row[\"geo_id\"],\n",
+    "                                \"geography\": row[\"geography\"],\n",
+    "                                \"date_start\": row[\"date_start\"],\n",
+    "                                \"date_end\": row[\"date_end\"],\n",
+    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                \"facet\": row[\"facet\"],\n",
+    "                                \"level\": row[\"level\"],\n",
+    "                                \"variable\": \"usage_tier\",\n",
+    "                                \"cluster_name\": tier_label,\n",
+    "                                \"value\": tier_value,\n",
+    "                            }\n",
+    "                            tier_rows.append(tier_row)\n",
+    "\n",
+    "                # Add tier 0 for all zero usage countries\n",
+    "                for _, row in zero_usage.iterrows():\n",
+    "                    tier_row = {\n",
+    "                        \"geo_id\": row[\"geo_id\"],\n",
+    "                        \"geography\": row[\"geography\"],\n",
+    "                        \"date_start\": row[\"date_start\"],\n",
+    "                        \"date_end\": row[\"date_end\"],\n",
+    "                        \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                        \"facet\": row[\"facet\"],\n",
+    "                        \"level\": row[\"level\"],\n",
+    "                        \"variable\": \"usage_tier\",\n",
+    "                        \"cluster_name\": \"Minimal\",\n",
+    "                        \"value\": 0,\n",
+    "                    }\n",
+    "                    tier_rows.append(tier_row)\n",
+    "\n",
+    "            # Process states\n",
+    "            # Get all states with the index variable\n",
+    "            all_state_data = df_result[\n",
+    "                (df_result[\"variable\"] == var) & (df_result[\"geography\"] == \"state_us\")\n",
+    "            ].copy()\n",
+    "\n",
+    "            if not all_state_data.empty:\n",
+    "                # Separate zero and non-zero usage\n",
+    "                zero_usage = all_state_data[all_state_data[\"value\"] == 0].copy()\n",
+    "                nonzero_usage = all_state_data[all_state_data[\"value\"] > 0].copy()\n",
+    "\n",
+    "                # Calculate quartile thresholds using ONLY filtered states\n",
+    "                if filtered_states is not None and not nonzero_usage.empty:\n",
+    "                    # Get only filtered states for quartile calculation\n",
+    "                    filtered_for_quartiles = nonzero_usage[\n",
+    "                        nonzero_usage[\"geo_id\"].isin(filtered_states)\n",
+    "                    ].copy()\n",
+    "\n",
+    "                    if not filtered_for_quartiles.empty:\n",
+    "                        # Calculate quartile thresholds from filtered states\n",
+    "                        quartiles = (\n",
+    "                            filtered_for_quartiles[\"value\"]\n",
+    "                            .quantile([0.25, 0.5, 0.75])\n",
+    "                            .values\n",
+    "                        )\n",
+    "\n",
+    "                        # Apply thresholds to all non-zero states\n",
+    "                        for _, row in nonzero_usage.iterrows():\n",
+    "                            value = row[\"value\"]\n",
+    "\n",
+    "                            # Assign tier based on thresholds\n",
+    "                            if value <= quartiles[0]:\n",
+    "                                tier_label = quartile_labels[0]  # Bottom 25%\n",
+    "                                tier_value = 1\n",
+    "                            elif value <= quartiles[1]:\n",
+    "                                tier_label = quartile_labels[1]  # 25-50%\n",
+    "                                tier_value = 2\n",
+    "                            elif value <= quartiles[2]:\n",
+    "                                tier_label = quartile_labels[2]  # 50-75%\n",
+    "                                tier_value = 3\n",
+    "                            else:\n",
+    "                                tier_label = quartile_labels[3]  # Top 25%\n",
+    "                                tier_value = 4\n",
+    "\n",
+    "                            tier_row = {\n",
+    "                                \"geo_id\": row[\"geo_id\"],\n",
+    "                                \"geography\": row[\"geography\"],\n",
+    "                                \"date_start\": row[\"date_start\"],\n",
+    "                                \"date_end\": row[\"date_end\"],\n",
+    "                                \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                                \"facet\": row[\"facet\"],\n",
+    "                                \"level\": row[\"level\"],\n",
+    "                                \"variable\": \"usage_tier\",\n",
+    "                                \"cluster_name\": tier_label,\n",
+    "                                \"value\": tier_value,\n",
+    "                            }\n",
+    "                            tier_rows.append(tier_row)\n",
+    "\n",
+    "                # Add tier 0 for all zero usage states\n",
+    "                for _, row in zero_usage.iterrows():\n",
+    "                    tier_row = {\n",
+    "                        \"geo_id\": row[\"geo_id\"],\n",
+    "                        \"geography\": row[\"geography\"],\n",
+    "                        \"date_start\": row[\"date_start\"],\n",
+    "                        \"date_end\": row[\"date_end\"],\n",
+    "                        \"platform_and_product\": row[\"platform_and_product\"],\n",
+    "                        \"facet\": row[\"facet\"],\n",
+    "                        \"level\": row[\"level\"],\n",
+    "                        \"variable\": \"usage_tier\",\n",
+    "                        \"cluster_name\": \"Minimal\",\n",
+    "                        \"value\": 0,\n",
+    "                    }\n",
+    "                    tier_rows.append(tier_row)\n",
+    "\n",
+    "        if tier_rows:\n",
+    "            df_result = pd.concat(\n",
+    "                [df_result, pd.DataFrame(tier_rows)], ignore_index=True\n",
+    "            )\n",
+    "\n",
+    "    return df_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_automation_augmentation_metrics(\n",
+    "    df, filtered_countries=None, filtered_states=None\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Calculate automation vs augmentation percentages for collaboration patterns.\n",
+    "\n",
+    "    This function:\n",
+    "    1. Categorizes collaboration patterns as automation or augmentation\n",
+    "    2. Calculates percentages excluding 'none' and 'not_classified'\n",
+    "    3. Only calculates for filtered geographies at country/state level\n",
+    "\n",
+    "    Categorization:\n",
+    "    - Automation: directive, feedback loop (AI-centric patterns)\n",
+    "    - Augmentation: validation, task iteration, learning (human-centric patterns)\n",
+    "    - Excluded: none (no collaboration), not_classified (unknown)\n",
+    "\n",
+    "    Args:\n",
+    "        df: Dataframe with collaboration data\n",
+    "        filtered_countries: List of countries that meet MIN_OBSERVATIONS\n",
+    "        filtered_states: List of states that meet MIN_OBSERVATIONS\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with automation/augmentation percentage rows added\n",
+    "    \"\"\"\n",
+    "    if \"facet\" not in df.columns or \"cluster_name\" not in df.columns:\n",
+    "        return df\n",
+    "\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    # Get collaboration data\n",
+    "    collab_data = df_result[\n",
+    "        (df_result[\"facet\"] == \"collaboration\")\n",
+    "        & (df_result[\"variable\"] == \"collaboration_count\")\n",
+    "    ].copy()\n",
+    "\n",
+    "    if collab_data.empty:\n",
+    "        return df_result\n",
+    "\n",
+    "    # Define pattern categorization\n",
+    "    def categorize_pattern(pattern_name):\n",
+    "        if pd.isna(pattern_name):\n",
+    "            return None\n",
+    "\n",
+    "        pattern_clean = pattern_name.lower().replace(\"_\", \" \").replace(\"-\", \" \")\n",
+    "\n",
+    "        # Augmentation patterns (human-centric)\n",
+    "        if \"validation\" in pattern_clean:\n",
+    "            return \"augmentation\"\n",
+    "        elif \"task iteration\" in pattern_clean or \"task_iteration\" in pattern_clean:\n",
+    "            return \"augmentation\"\n",
+    "        elif \"learning\" in pattern_clean:\n",
+    "            return \"augmentation\"\n",
+    "        # Automation patterns (AI-centric)\n",
+    "        elif \"directive\" in pattern_clean:\n",
+    "            return \"automation\"\n",
+    "        elif \"feedback loop\" in pattern_clean or \"feedback_loop\" in pattern_clean:\n",
+    "            return \"automation\"\n",
+    "        # Excluded patterns - return None to exclude from calculations\n",
+    "        elif \"none\" in pattern_clean or \"not_classified\" in pattern_clean:\n",
+    "            return None\n",
+    "        else:\n",
+    "            return None  # Unknown patterns also excluded\n",
+    "\n",
+    "    # Add category column\n",
+    "    collab_data[\"category\"] = collab_data[\"cluster_name\"].apply(categorize_pattern)\n",
+    "\n",
+    "    # Filter to only patterns that have a category (excludes none, not_classified, etc.)\n",
+    "    collab_categorized = collab_data[collab_data[\"category\"].notna()].copy()\n",
+    "\n",
+    "    if collab_categorized.empty:\n",
+    "        return df_result\n",
+    "\n",
+    "    # Process by geography\n",
+    "    new_rows = []\n",
+    "\n",
+    "    # Group by geography and geo_id\n",
+    "    for (geography, geo_id), geo_data in collab_categorized.groupby(\n",
+    "        [\"geography\", \"geo_id\"]\n",
+    "    ):\n",
+    "        # Apply filtering based on geography level\n",
+    "        if geography == \"country\" and filtered_countries is not None:\n",
+    "            if geo_id not in filtered_countries:\n",
+    "                continue  # Skip countries that don't meet threshold\n",
+    "        elif geography == \"state_us\" and filtered_states is not None:\n",
+    "            if geo_id not in filtered_states:\n",
+    "                continue  # Skip states that don't meet threshold\n",
+    "        # global is always included (no filtering)\n",
+    "\n",
+    "        # Calculate totals by category\n",
+    "        automation_total = geo_data[geo_data[\"category\"] == \"automation\"][\"value\"].sum()\n",
+    "        augmentation_total = geo_data[geo_data[\"category\"] == \"augmentation\"][\n",
+    "            \"value\"\n",
+    "        ].sum()\n",
+    "\n",
+    "        # Total of categorized patterns (excluding none and not_classified)\n",
+    "        total_categorized = automation_total + augmentation_total\n",
+    "\n",
+    "        if total_categorized > 0:\n",
+    "            # Get a sample row for metadata\n",
+    "            sample_row = geo_data.iloc[0]\n",
+    "\n",
+    "            # Create automation percentage row\n",
+    "            automation_row = {\n",
+    "                \"geo_id\": geo_id,\n",
+    "                \"geography\": geography,\n",
+    "                \"date_start\": sample_row[\"date_start\"],\n",
+    "                \"date_end\": sample_row[\"date_end\"],\n",
+    "                \"platform_and_product\": sample_row[\"platform_and_product\"],\n",
+    "                \"facet\": \"collaboration_automation_augmentation\",\n",
+    "                \"level\": 0,\n",
+    "                \"variable\": \"automation_pct\",\n",
+    "                \"cluster_name\": \"automation\",\n",
+    "                \"value\": (automation_total / total_categorized) * 100,\n",
+    "            }\n",
+    "            new_rows.append(automation_row)\n",
+    "\n",
+    "            # Create augmentation percentage row\n",
+    "            augmentation_row = {\n",
+    "                \"geo_id\": geo_id,\n",
+    "                \"geography\": geography,\n",
+    "                \"date_start\": sample_row[\"date_start\"],\n",
+    "                \"date_end\": sample_row[\"date_end\"],\n",
+    "                \"platform_and_product\": sample_row[\"platform_and_product\"],\n",
+    "                \"facet\": \"collaboration_automation_augmentation\",\n",
+    "                \"level\": 0,\n",
+    "                \"variable\": \"augmentation_pct\",\n",
+    "                \"cluster_name\": \"augmentation\",\n",
+    "                \"value\": (augmentation_total / total_categorized) * 100,\n",
+    "            }\n",
+    "            new_rows.append(augmentation_row)\n",
+    "\n",
+    "    # Add all new rows to result\n",
+    "    if new_rows:\n",
+    "        df_new = pd.DataFrame(new_rows)\n",
+    "        df_result = pd.concat([df_result, df_new], ignore_index=True)\n",
+    "\n",
+    "    return df_result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_iso3_and_names(df):\n",
+    "    \"\"\"\n",
+    "    Replace ISO-2 codes with ISO-3 codes and add geographic names.\n",
+    "\n",
+    "    This function:\n",
+    "    1. Replaces geo_id from ISO-2 to ISO-3 for countries\n",
+    "    2. Adds geo_name column with human-readable names for all geographies\n",
+    "    3. Preserves special geo_ids (like 'not_classified') that aren't in ISO mapping\n",
+    "\n",
+    "    Args:\n",
+    "        df: Enriched dataframe with geo_id (ISO-2 for countries, state codes for US states)\n",
+    "\n",
+    "    Returns:\n",
+    "        Dataframe with ISO-3 codes in geo_id and geo_name column added\n",
+    "    \"\"\"\n",
+    "    df_result = df.copy()\n",
+    "\n",
+    "    # Initialize geo_name column\n",
+    "    df_result[\"geo_name\"] = \"\"\n",
+    "\n",
+    "    # Load ISO mapping data for countries\n",
+    "    iso_path = Path(DATA_INTERMEDIATE_DIR) / \"iso_country_codes.csv\"\n",
+    "    if iso_path.exists():\n",
+    "        df_iso = pd.read_csv(iso_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "        # Create ISO-2 to ISO-3 mapping\n",
+    "        iso2_to_iso3 = dict(zip(df_iso[\"iso_alpha_2\"], df_iso[\"iso_alpha_3\"]))\n",
+    "\n",
+    "        # Create ISO-2 to country name mapping\n",
+    "        iso2_to_name = dict(zip(df_iso[\"iso_alpha_2\"], df_iso[\"country_name\"]))\n",
+    "\n",
+    "        # For all rows where geography is 'country', add country names and convert codes\n",
+    "        # This includes content facets that are broken down by country\n",
+    "        country_mask = df_result[\"geography\"] == \"country\"\n",
+    "\n",
+    "        # First, identify which geo_ids don't have ISO mappings\n",
+    "        country_geo_ids = df_result.loc[country_mask, \"geo_id\"].unique()\n",
+    "        unmapped_geo_ids = [\n",
+    "            g for g in country_geo_ids if g not in iso2_to_iso3 and pd.notna(g)\n",
+    "        ]\n",
+    "\n",
+    "        if unmapped_geo_ids:\n",
+    "            print(\n",
+    "                f\"\\nWarning: The following geo_ids are not in ISO-2 mapping and will be kept as-is:\"\n",
+    "            )\n",
+    "            for geo_id in unmapped_geo_ids:\n",
+    "                # Count rows and usage for this geo_id\n",
+    "                geo_mask = (df_result[\"geography\"] == \"country\") & (\n",
+    "                    df_result[\"geo_id\"] == geo_id\n",
+    "                )\n",
+    "                row_count = geo_mask.sum()\n",
+    "                usage_mask = geo_mask & (df_result[\"variable\"] == \"usage_count\")\n",
+    "                usage_sum = (\n",
+    "                    df_result.loc[usage_mask, \"value\"].sum() if usage_mask.any() else 0\n",
+    "                )\n",
+    "                print(f\"  - '{geo_id}': {row_count} rows, {usage_sum:,.0f} usage count\")\n",
+    "\n",
+    "        # Check for geo_ids without country names\n",
+    "        unmapped_names = [g for g in unmapped_geo_ids if g not in iso2_to_name]\n",
+    "        if unmapped_names:\n",
+    "            print(\n",
+    "                f\"\\nWarning: The following geo_ids don't have country names and will use geo_id as name:\"\n",
+    "            )\n",
+    "            for geo_id in unmapped_names:\n",
+    "                print(f\"  - '{geo_id}'\")\n",
+    "\n",
+    "        # Apply country names BEFORE converting ISO-2 to ISO-3\n",
+    "        # The iso2_to_name dictionary uses ISO-2 codes as keys\n",
+    "        df_result.loc[country_mask, \"geo_name\"] = (\n",
+    "            df_result.loc[country_mask, \"geo_id\"]\n",
+    "            .map(iso2_to_name)\n",
+    "            .fillna(df_result.loc[country_mask, \"geo_id\"])\n",
+    "        )\n",
+    "\n",
+    "        # Convert ISO-2 to ISO-3 codes\n",
+    "        df_result.loc[country_mask, \"geo_id\"] = (\n",
+    "            df_result.loc[country_mask, \"geo_id\"]\n",
+    "            .map(iso2_to_iso3)\n",
+    "            .fillna(df_result.loc[country_mask, \"geo_id\"])\n",
+    "        )\n",
+    "    else:\n",
+    "        print(f\"Warning: ISO mapping file not found at {iso_path}\")\n",
+    "\n",
+    "    # Load state names from census data\n",
+    "    state_codes_path = Path(DATA_INPUT_DIR) / \"census_state_codes.txt\"\n",
+    "    if state_codes_path.exists():\n",
+    "        df_state_codes = pd.read_csv(state_codes_path, sep=\"|\")\n",
+    "        # Create state code to name mapping (STUSAB is the 2-letter code, STATE_NAME is the full name)\n",
+    "        state_code_to_name = dict(\n",
+    "            zip(df_state_codes[\"STUSAB\"], df_state_codes[\"STATE_NAME\"])\n",
+    "        )\n",
+    "\n",
+    "        # For all rows where geography is 'state_us', add state names\n",
+    "        state_mask = df_result[\"geography\"] == \"state_us\"\n",
+    "        df_result.loc[state_mask, \"geo_name\"] = df_result.loc[state_mask, \"geo_id\"].map(\n",
+    "            state_code_to_name\n",
+    "        )\n",
+    "    else:\n",
+    "        print(f\"Warning: State census file not found at {state_codes_path}\")\n",
+    "\n",
+    "    # For global entries\n",
+    "    global_mask = df_result[\"geography\"] == \"global\"\n",
+    "    df_result.loc[global_mask, \"geo_name\"] = \"global\"\n",
+    "\n",
+    "    # Fill any missing geo_names with geo_id as fallback\n",
+    "    df_result.loc[df_result[\"geo_name\"] == \"\", \"geo_name\"] = df_result.loc[\n",
+    "        df_result[\"geo_name\"] == \"\", \"geo_id\"\n",
+    "    ]\n",
+    "    df_result[\"geo_name\"] = df_result[\"geo_name\"].fillna(df_result[\"geo_id\"])\n",
+    "\n",
+    "    return df_result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Main Processing Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def enrich_clio_data(input_path, output_path, external_data=None):\n",
+    "    \"\"\"\n",
+    "    Enrich processed Clio data with external sources.\n",
+    "\n",
+    "    Args:\n",
+    "        input_path: Path to processed Clio data\n",
+    "        output_path: Path for enriched CSV output\n",
+    "        external_data: Pre-loaded external data (optional)\n",
+    "\n",
+    "    Returns:\n",
+    "        Path to enriched data file\n",
+    "    \"\"\"\n",
+    "    # Load processed Clio data - use keep_default_na=False to preserve \"NA\" (Namibia)\n",
+    "    df = pd.read_csv(input_path, keep_default_na=False, na_values=[\"\"])\n",
+    "\n",
+    "    # Load external data if not provided\n",
+    "    if external_data is None:\n",
+    "        external_data = load_external_data()\n",
+    "\n",
+    "    # Get filtered geographies (but keep all data in the dataframe)\n",
+    "    filtered_countries, filtered_states = get_filtered_geographies(df)\n",
+    "\n",
+    "    # Merge with population data\n",
+    "    df = merge_population_data(df, external_data[\"population\"])\n",
+    "\n",
+    "    # Merge with GDP data (pass population data for per capita calculation)\n",
+    "    df = merge_gdp_data(df, external_data[\"gdp\"], external_data[\"population\"])\n",
+    "\n",
+    "    # Calculate SOC occupation distribution from O*NET tasks\n",
+    "    # Only for geographies that meet MIN_OBSERVATIONS threshold\n",
+    "    df = calculate_soc_distribution(\n",
+    "        df,\n",
+    "        external_data[\"task_statements\"],\n",
+    "        external_data[\"soc_structure\"],\n",
+    "        filtered_countries=filtered_countries,\n",
+    "        filtered_states=filtered_states,\n",
+    "    )\n",
+    "\n",
+    "    # Calculate per capita metrics\n",
+    "    df = calculate_per_capita_metrics(df)\n",
+    "\n",
+    "    # Calculate usage index - pass filtered countries/states to only use them for baseline\n",
+    "    df = calculate_usage_per_capita_index(\n",
+    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
+    "    )\n",
+    "\n",
+    "    # Calculate category percentage index - pass filtered countries/states\n",
+    "    df = calculate_category_percentage_index(\n",
+    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
+    "    )\n",
+    "\n",
+    "    # Calculate usage tiers - pass filtered countries/states to only use them\n",
+    "    df = calculate_usage_tiers(\n",
+    "        df, filtered_countries=filtered_countries, filtered_states=filtered_states\n",
+    "    )\n",
+    "\n",
+    "    # Add collaboration categorization\n",
+    "    df = calculate_automation_augmentation_metrics(df)\n",
+    "\n",
+    "    # Add ISO-3 codes and geographic names\n",
+    "    df = add_iso3_and_names(df)\n",
+    "\n",
+    "    # Sort for consistent output ordering\n",
+    "    df = df.sort_values(\n",
+    "        [\"geography\", \"geo_id\", \"facet\", \"level\", \"cluster_name\", \"variable\"]\n",
+    "    )\n",
+    "\n",
+    "    # Save enriched data as CSV\n",
+    "    df.to_csv(output_path, index=False)\n",
+    "\n",
+    "    return str(output_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Merge External Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_path = \"../data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
+    "output_path = \"../data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv\"\n",
+    "\n",
+    "enrich_clio_data(input_path, output_path)\n",
+    "print(f\"\\n✅ Enrichment complete! Output: {output_path}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py311",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

release_2025_09_15/code/preprocess_gdp.py

@@ -0,0 +1,364 @@
+"""
+Preprocess GDP data for economic analysis.
+
+This script downloads and processes GDP data from:
+1. IMF API for country-level GDP data
+2. BEA (Bureau of Economic Analysis) for US state-level GDP data
+
+Output files:
+- gdp_YYYY_country.csv (e.g., gdp_2024_country.csv): Country-level total GDP
+- gdp_YYYY_us_state.csv (e.g., gdp_2024_us_state.csv): US state-level total GDP
+"""
+
+import io
+import json
+import warnings
+from pathlib import Path
+
+import httpx
+import pandas as pd
+
+# Global configuration
+YEAR = 2024
+DATA_INPUT_DIR = Path("../data/input")
+DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
+
+
+# Countries where Claude AI service is not available
+# These will be excluded from all GDP data
+EXCLUDED_COUNTRIES = [
+    "AFG",
+    "BLR",
+    "COD",
+    "CAF",
+    "CHN",
+    "CUB",
+    "ERI",
+    "ETH",
+    "HKG",
+    "IRN",
+    "PRK",
+    "LBY",
+    "MLI",
+    "MMR",
+    "MAC",
+    "NIC",
+    "RUS",
+    "SDN",
+    "SOM",
+    "SSD",
+    "SYR",
+    "VEN",
+    "YEM",
+]
+
+
+def check_existing_files():
+    """Check if processed GDP files already exist."""
+    gdp_country_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_country.csv"
+    gdp_state_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_us_state.csv"
+
+    if gdp_country_path.exists() and gdp_state_path.exists():
+        print("✅ GDP files already exist:")
+        print(f"  - {gdp_country_path}")
+        print(f"  - {gdp_state_path}")
+        print("Skipping GDP preprocessing. Delete these files if you want to re-run.")
+        return True
+    return False
+
+
+def load_country_gdp_data():
+    """
+    Load country-level GDP data from cache or IMF API.
+
+    Returns:
+        dict: Raw GDP data from IMF API, or None if fetch fails
+    """
+    # Check if raw data already exists
+    raw_gdp_path = DATA_INPUT_DIR / f"imf_gdp_raw_{YEAR}.json"
+    if raw_gdp_path.exists():
+        print("Loading cached IMF GDP data...")
+        with open(raw_gdp_path) as f:
+            return json.load(f)
+
+    # Download if not cached
+    imf_total_gdp_url = "https://www.imf.org/external/datamapper/api/v1/NGDPD"  # IMF returns GDP in billions USD
+
+    print("Fetching GDP data from IMF API...")
+    try:
+        with httpx.Client() as client:
+            response = client.get(imf_total_gdp_url, timeout=30)
+            response.raise_for_status()
+            gdp_data = response.json()
+            print("✓ Successfully fetched total GDP data from IMF API")
+
+            # Save raw data for future use
+            with open(raw_gdp_path, "w") as f:
+                json.dump(gdp_data, f, indent=2)
+            print(f"✓ Saved raw GDP data to {raw_gdp_path}")
+
+            return gdp_data
+    except Exception as e:
+        raise ConnectionError(f"Failed to fetch data from IMF API: {e}") from e
+
+
+def process_country_gdp_data(gdp_data):
+    """
+    Process IMF GDP data into standardized format.
+
+    Args:
+        gdp_data: Raw IMF API response
+
+    Returns:
+        pd.DataFrame: Processed country GDP data (excluding countries where service is not available)
+    """
+    # Extract GDP data for target year
+    # Structure: {"values": {"NGDPD": {"countryiso3code": {"year": value}}}}
+    gdp_values = gdp_data.get("values", {}).get("NGDPD", {})
+
+    # Build records for target year data only
+    gdp_records = []
+    target_year = str(YEAR)
+    missing_countries = []
+
+    for countryiso3code, years_data in gdp_values.items():
+        if isinstance(years_data, dict):
+            if target_year in years_data and years_data[target_year]:
+                gdp_value = years_data[target_year]
+                # Convert from billions to actual dollars
+                gdp_records.append(
+                    {
+                        "iso_alpha_3": countryiso3code,
+                        "gdp_total": float(gdp_value)
+                        * 1e9,  # Convert billions to dollars
+                        "year": YEAR,
+                    }
+                )
+            else:
+                missing_countries.append(countryiso3code)
+
+    if missing_countries:
+        warnings.warn(
+            f"{len(missing_countries)} countries missing {YEAR} GDP data. "
+            f"Examples: {missing_countries[:5]}",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    df_gdp = pd.DataFrame(gdp_records)
+
+    if df_gdp.empty:
+        raise ValueError(f"No GDP data available for year {YEAR}")
+
+    # Apply country code mappings for mismatches between IMF and ISO3
+    country_code_mappings = {
+        "UVK": "XKX",  # Kosovo
+        # Add more mappings as needed
+    }
+
+    for imf_code, iso3_code in country_code_mappings.items():
+        df_gdp.loc[df_gdp["iso_alpha_3"] == imf_code, "iso_alpha_3"] = iso3_code
+
+    # Filter to only keep countries with valid ISO-3 codes
+    # This removes regional aggregates like ADVEC, AFQ, etc.
+    iso_codes_path = DATA_INTERMEDIATE_DIR / "iso_country_codes.csv"
+    df_iso = pd.read_csv(iso_codes_path, keep_default_na=False, na_values=[""])
+    valid_iso3_codes = set(df_iso["iso_alpha_3"].unique())
+
+    initial_aggregate_count = len(df_gdp)
+    df_gdp = df_gdp[df_gdp["iso_alpha_3"].isin(valid_iso3_codes)]
+    filtered_aggregates = initial_aggregate_count - len(df_gdp)
+
+    if filtered_aggregates > 0:
+        print(
+            f"  Filtered out {filtered_aggregates} non-country codes (regional aggregates)"
+        )
+
+    # Filter out excluded countries (now using 3-letter codes directly)
+    initial_count = len(df_gdp)
+    df_gdp = df_gdp[~df_gdp["iso_alpha_3"].isin(EXCLUDED_COUNTRIES)]
+    excluded_count = initial_count - len(df_gdp)
+
+    if excluded_count > 0:
+        print(f"  Excluded {excluded_count} countries where service is not available")
+
+    # Save processed GDP data
+    processed_gdp_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_country.csv"
+    df_gdp.to_csv(processed_gdp_path, index=False)
+
+    print(f"✓ Saved processed GDP data to {processed_gdp_path}")
+    print(f"  Countries with {YEAR} GDP data: {len(df_gdp)}")
+    print(f"  Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
+    print(f"  Total global GDP: ${df_gdp['gdp_total'].sum() / 1e12:.2f} trillion")
+
+    return df_gdp
+
+
+def load_state_gdp_data():
+    """
+    Load US state GDP data from BEA file.
+
+    Returns:
+        pd.DataFrame: Raw state GDP data, or None if file not found
+    """
+    state_gdp_raw_path = DATA_INPUT_DIR / f"bea_us_state_gdp_{YEAR}.csv"
+
+    if not state_gdp_raw_path.exists():
+        error_msg = f"""
+State GDP data not found at: {state_gdp_raw_path}
+
+To obtain this data:
+1. Go to: https://apps.bea.gov/itable/?ReqID=70&step=1
+2. Select: SASUMMARY State annual summary statistics (area = "United States", statistic = Gross domestic product (GDP), unit of measure = "Levels")
+3. Download the CSV file for year {YEAR}
+4. Save it as: bea_us_state_gdp_{YEAR}.csv
+5. Place it in your data input directory
+"""
+        raise FileNotFoundError(error_msg)
+
+    print("Loading US state GDP data...")
+    # Parse CSV skipping the first 3 rows (BEA metadata)
+    df_state_gdp_raw = pd.read_csv(state_gdp_raw_path, skiprows=3)
+    df_state_gdp_raw.columns = ["GeoFips", "State", f"gdp_{YEAR}_millions"]
+
+    return df_state_gdp_raw
+
+
+def process_state_gdp_data(df_state_gdp_raw):
+    """
+    Process BEA state GDP data into standardized format.
+
+    Args:
+        df_state_gdp_raw: Raw BEA data
+
+    Returns:
+        pd.DataFrame: Processed state GDP data
+    """
+
+    # Remove the US total row (GeoFips = "00000")
+    df_state_gdp = df_state_gdp_raw[df_state_gdp_raw["GeoFips"] != "00000"].copy()
+
+    # Remove all rows starting from empty line before "Legend/Footnotes" marker
+    # BEA files have footer information after the data, with an empty line before
+    legend_index = (
+        df_state_gdp[
+            df_state_gdp["GeoFips"].str.contains("Legend", case=False, na=False)
+        ].index[0]
+        - 1
+    )
+    df_state_gdp = df_state_gdp.iloc[:legend_index].copy()
+    print(f"  Removed footer rows starting from 'Legend/Footnotes'")
+
+    # Convert GDP from millions to actual dollars
+    df_state_gdp["gdp_total"] = df_state_gdp[f"gdp_{YEAR}_millions"] * 1e6
+
+    # Clean state names
+    df_state_gdp["State"] = df_state_gdp["State"].str.strip()
+
+    # Get state codes
+    state_code_dict = get_state_codes()
+    df_state_gdp["state_code"] = df_state_gdp["State"].map(state_code_dict)
+
+    # Check for missing state codes
+    missing_codes = df_state_gdp[df_state_gdp["state_code"].isna()]
+    if not missing_codes.empty:
+        raise ValueError(
+            f"Could not find state codes for: {missing_codes['State'].tolist()}\n"
+            f"All BEA state names should match Census state codes after filtering."
+        )
+
+    # Select and rename columns
+    df_state_gdp_final = df_state_gdp[
+        ["state_code", "State", "gdp_total", f"gdp_{YEAR}_millions"]
+    ].copy()
+    df_state_gdp_final.columns = [
+        "state_code",
+        "state_name",
+        "gdp_total",
+        "gdp_millions",
+    ]
+    df_state_gdp_final["year"] = YEAR
+
+    # Save processed state GDP data
+    processed_state_gdp_path = DATA_INTERMEDIATE_DIR / f"gdp_{YEAR}_us_state.csv"
+    df_state_gdp_final.to_csv(processed_state_gdp_path, index=False)
+
+    print(
+        f"✓ Processed state GDP data for {len(df_state_gdp_final)} states/territories"
+    )
+    print(
+        f"  Total US GDP: ${df_state_gdp_final['gdp_total'].sum() / 1e12:.2f} trillion"
+    )
+    print(f"✓ Saved to {processed_state_gdp_path}")
+
+    return df_state_gdp_final
+
+
+def get_state_codes():
+    """
+    Get US state codes from Census Bureau.
+
+    Returns:
+        dict: Mapping of state names to abbreviations
+    """
+    state_codes_path = DATA_INPUT_DIR / "census_state_codes.txt"
+
+    if state_codes_path.exists():
+        print("  Loading cached state codes...")
+        df_state_codes = pd.read_csv(state_codes_path, sep="|")
+    else:
+        print("  Downloading state codes from Census Bureau...")
+        response = httpx.get("https://www2.census.gov/geo/docs/reference/state.txt")
+        response.raise_for_status()
+
+        # Save for future use
+        with open(state_codes_path, "w") as f:
+            f.write(response.text)
+        print(f"  Cached state codes to {state_codes_path}")
+
+        df_state_codes = pd.read_csv(io.StringIO(response.text), sep="|")
+
+    # Create mapping dictionary
+    state_code_dict = dict(
+        zip(df_state_codes["STATE_NAME"], df_state_codes["STUSAB"], strict=True)
+    )
+
+    return state_code_dict
+
+
+def main():
+    """Main function to run GDP preprocessing."""
+    # Check if files already exist
+    if check_existing_files():
+        return
+
+    print("=" * 60)
+    print(f"PROCESSING {YEAR} GDP DATA")
+    print("=" * 60)
+
+    # Process country-level GDP from IMF
+    print(f"\n=== Country-Level GDP (IMF) - Year {YEAR} ===")
+    gdp_data = load_country_gdp_data()
+    df_gdp_country = process_country_gdp_data(gdp_data)
+
+    # Process US state-level GDP from BEA
+    print(f"\n=== US State-Level GDP (BEA) - Year {YEAR} ===")
+    df_state_gdp_raw = load_state_gdp_data()
+    df_gdp_state = process_state_gdp_data(df_state_gdp_raw)
+
+    # Final status
+    print(f"\n✅ {YEAR} GDP data preprocessing complete!")
+    print("\n=== Summary Statistics ===")
+    if df_gdp_country is not None:
+        print(f"Countries processed: {len(df_gdp_country)}")
+        print(f"Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
+        print(
+            f"Total global GDP: ${df_gdp_country['gdp_total'].sum() / 1e12:.2f} trillion"
+        )
+    if df_gdp_state is not None:
+        print(f"US states processed: {len(df_gdp_state)}")
+        print(f"Total US GDP: ${df_gdp_state['gdp_total'].sum() / 1e12:.2f} trillion")
+
+
+if __name__ == "__main__":
+    main()

release_2025_09_15/code/preprocess_iso_codes.py

@@ -0,0 +1,111 @@
+"""
+Fetch ISO country code mappings from GeoNames.
+
+This script fetches comprehensive country data from GeoNames countryInfo.txt
+and saves it as a CSV file for use in data preprocessing pipelines.
+"""
+
+import io
+from pathlib import Path
+
+import httpx
+import pandas as pd
+
+
+def fetch_country_mappings(save_raw=True):
+    """
+    Fetch country code mappings from GeoNames.
+
+    Args:
+        save_raw: Whether to save raw data file to data/input
+
+    Returns:
+        pd.DataFrame: DataFrame with country information from GeoNames
+    """
+    # Fetch countryInfo.txt from GeoNames
+    geonames_url = "https://download.geonames.org/export/dump/countryInfo.txt"
+
+    with httpx.Client() as client:
+        response = client.get(geonames_url)
+        response.raise_for_status()
+        content = response.text
+
+    # Save raw file to data/input for reference
+    if save_raw:
+        input_dir = Path("../data/input")
+        input_dir.mkdir(parents=True, exist_ok=True)
+
+        raw_path = input_dir / "geonames_countryInfo.txt"
+        with open(raw_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    # Extract column names from the last comment line
+    lines = content.split("\n")
+    header_line = [line for line in lines if line.startswith("#")][-1]
+    column_names = header_line[1:].split("\t")  # Remove # and split by tab
+
+    # Parse the tab-separated file
+    # keep_default_na=False to prevent "NA" (Namibia) from becoming NaN
+    df = pd.read_csv(
+        io.StringIO(content),
+        sep="\t",
+        comment="#",
+        header=None,  # No header row in the data
+        keep_default_na=False,  # Don't interpret "NA" as NaN (needed for Namibia)
+        na_values=[""],  # Only treat empty strings as NaN
+        names=column_names,  # Use the column names from the comment
+    )
+
+    # Rename columns to our standard format
+    df = df.rename(
+        columns={"ISO": "iso_alpha_2", "ISO3": "iso_alpha_3", "Country": "country_name"}
+    )
+
+    return df
+
+
+def create_country_dataframe(geonames_df):
+    """
+    Create a cleaned DataFrame with country codes and names.
+
+    Args:
+        geonames_df: DataFrame from GeoNames with all country information
+
+    Returns:
+        pd.DataFrame: DataFrame with columns [iso_alpha_2, iso_alpha_3, country_name]
+    """
+    # Select only the columns we need
+    df = geonames_df[["iso_alpha_2", "iso_alpha_3", "country_name"]].copy()
+
+    # Sort by country name for consistency
+    df = df.sort_values("country_name").reset_index(drop=True)
+
+    return df
+
+
+def save_country_codes(output_path="../data/intermediate/iso_country_codes.csv"):
+    """
+    Fetch country codes from GeoNames and save to CSV.
+
+    Args:
+        output_path: Path to save the CSV file
+    """
+    # Fetch full GeoNames data
+    geonames_df = fetch_country_mappings()
+
+    # Create cleaned DataFrame with just the columns we need
+    df = create_country_dataframe(geonames_df)
+
+    # Ensure output directory exists
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Save to CSV
+    df.to_csv(output_file, index=False)
+
+    return df
+
+
+if __name__ == "__main__":
+    # Fetch and save country codes
+    df = save_country_codes()

release_2025_09_15/code/preprocess_onet.py

@@ -0,0 +1,179 @@
+"""
+Preprocess O*NET and SOC data for economic analysis.
+
+This script downloads and processes occupational data from:
+1. O*NET Resource Center for task statements
+2. O*NET Resource Center for SOC structure
+
+Output files:
+- onet_task_statements.csv: O*NET task statements with SOC major groups
+- soc_structure.csv: SOC occupational classification structure
+"""
+
+import io
+import os
+import tempfile
+from pathlib import Path
+
+import httpx
+import pandas as pd
+
+# Global configuration
+DATA_INPUT_DIR = Path("../data/input")
+DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
+
+
+def check_existing_files():
+    """Check if processed O*NET/SOC files already exist."""
+    onet_task_statements_path = DATA_INTERMEDIATE_DIR / "onet_task_statements.csv"
+    soc_structure_path = DATA_INTERMEDIATE_DIR / "soc_structure.csv"
+
+    if onet_task_statements_path.exists() and soc_structure_path.exists():
+        print("✅ SOC/O*NET files already exist:")
+        print(f"  - {onet_task_statements_path}")
+        print(f"  - {soc_structure_path}")
+        print("Skipping SOC preprocessing. Delete these files if you want to re-run.")
+        return True
+    return False
+
+
+def load_task_data():
+    """
+    Load O*NET Task Statements from cache or O*NET Resource Center.
+
+    Returns:
+        pd.DataFrame: O*NET task statements data
+    """
+    # Check if raw data already exists
+    raw_onet_path = DATA_INPUT_DIR / "onet_task_statements_raw.xlsx"
+    if raw_onet_path.exists():
+        df_onet = pd.read_excel(raw_onet_path)
+        return df_onet
+
+    # Download if not cached
+    # O*NET Database version 20.1
+    onet_url = "https://www.onetcenter.org/dl_files/database/db_20_1_excel/Task%20Statements.xlsx"
+
+    print("Downloading O*NET task statements...")
+    try:
+        with httpx.Client(follow_redirects=True) as client:
+            response = client.get(onet_url, timeout=60)
+            response.raise_for_status()
+            excel_content = response.content
+            # Save raw data for future use
+            with open(raw_onet_path, "wb") as f:
+                f.write(excel_content)
+
+            # Save to temporary file for pandas to read
+            with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp_file:
+                tmp_file.write(excel_content)
+                tmp_path = tmp_file.name
+
+            try:
+                df_onet = pd.read_excel(tmp_path)
+                return df_onet
+            finally:
+                os.unlink(tmp_path)
+
+    except Exception as e:
+        raise ConnectionError(f"Failed to download O*NET data: {e}") from e
+
+
+def process_task_data(df_tasks):
+    """
+    Process task statements data.
+
+    Args:
+        df_tasks: Raw task data
+
+    Returns:
+        pd.DataFrame: Processed O*NET data with SOC major groups
+    """
+    # Extract SOC major group from O*NET-SOC Code (first 2 digits)
+    df_tasks["soc_major_group"] = df_tasks["O*NET-SOC Code"].str[:2]
+
+    # Save processed task data
+    processed_tasks_path = DATA_INTERMEDIATE_DIR / "onet_task_statements.csv"
+    df_tasks.to_csv(processed_tasks_path, index=False)
+
+    print(
+        f"✓ Processed {len(df_tasks):,} task statements from {df_tasks['O*NET-SOC Code'].nunique()} occupations"
+    )
+
+    return df_tasks
+
+
+def load_soc_data():
+    """
+    Load SOC Structure from cache or O*NET Resource Center.
+
+    Returns:
+        pd.DataFrame: SOC structure data
+    """
+    # Check if raw data already exists
+    raw_soc_path = DATA_INPUT_DIR / "soc_structure_raw.csv"
+    if raw_soc_path.exists():
+        return pd.read_csv(raw_soc_path)
+
+    # Download if not cached
+    soc_url = "https://www.onetcenter.org/taxonomy/2019/structure/?fmt=csv"
+
+    print("Downloading SOC structure...")
+    try:
+        with httpx.Client(follow_redirects=True) as client:
+            response = client.get(soc_url, timeout=30)
+            response.raise_for_status()
+            soc_content = response.text
+            # Save raw data for future use
+            with open(raw_soc_path, "w") as f:
+                f.write(soc_content)
+
+            # Parse the CSV
+            df_soc = pd.read_csv(io.StringIO(soc_content))
+            return df_soc
+
+    except Exception as e:
+        raise ConnectionError(f"Failed to download SOC structure: {e}") from e
+
+
+def process_soc_data(df_soc):
+    """
+    Process SOC structure data.
+
+    Args:
+        df_soc: Raw SOC structure data
+
+    Returns:
+        pd.DataFrame: Processed SOC structure
+    """
+    # Extract the 2-digit code from Major Group (e.g., "11-0000" -> "11")
+    df_soc["soc_major_group"] = df_soc["Major Group"].str[:2]
+
+    # Save processed SOC structure
+    processed_soc_path = DATA_INTERMEDIATE_DIR / "soc_structure.csv"
+    df_soc.to_csv(processed_soc_path, index=False)
+
+    print(f"✓ Processed {len(df_soc):,} SOC entries")
+
+    return df_soc
+
+
+def main():
+    """Main function to run O*NET/SOC preprocessing."""
+    # Check if files already exist
+    if check_existing_files():
+        return
+
+    # Process Task Statements
+    df_tasks_raw = load_task_data()
+    process_task_data(df_tasks_raw)
+
+    # Process SOC Structure
+    df_soc_raw = load_soc_data()
+    process_soc_data(df_soc_raw)
+
+    print("\n✅ O*NET/SOC data preprocessing complete!")
+
+
+if __name__ == "__main__":
+    main()

release_2025_09_15/code/preprocess_population.py

@@ -0,0 +1,407 @@
+"""
+Preprocess population data for economic analysis.
+
+This script downloads and processes working-age population data (ages 15-64) from:
+1. World Bank API for country-level data
+2. Taiwan National Development Council for Taiwan data (not in World Bank)
+3. US Census Bureau for US state-level data
+
+Output files:
+- working_age_pop_YYYY_country.csv (e.g., working_age_pop_2024_country.csv): Country-level working age population
+- working_age_pop_YYYY_us_state.csv (e.g., working_age_pop_2024_us_state.csv): US state-level working age population
+"""
+
+import io
+import warnings
+from pathlib import Path
+
+import httpx
+import pandas as pd
+
+# Global configuration
+YEAR = 2024
+DATA_INPUT_DIR = Path("../data/input")
+DATA_INTERMEDIATE_DIR = Path("../data/intermediate")
+
+# Countries where Claude AI service is not available
+# These will be excluded from all population data
+EXCLUDED_COUNTRIES = [
+    "AF",  # Afghanistan
+    "BY",  # Belarus
+    "CD",  # Democratic Republic of the Congo
+    "CF",  # Central African Republic
+    "CN",  # China
+    "CU",  # Cuba
+    "ER",  # Eritrea
+    "ET",  # Ethiopia
+    "HK",  # Hong Kong
+    "IR",  # Iran
+    "KP",  # North Korea
+    "LY",  # Libya
+    "ML",  # Mali
+    "MM",  # Myanmar
+    "MO",  # Macau
+    "NI",  # Nicaragua
+    "RU",  # Russia
+    "SD",  # Sudan
+    "SO",  # Somalia
+    "SS",  # South Sudan
+    "SY",  # Syria
+    "VE",  # Venezuela
+    "YE",  # Yemen
+]
+
+
+def check_existing_files():
+    """Check if processed population files already exist."""
+    processed_country_pop_path = (
+        DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_country.csv"
+    )
+    processed_state_pop_path = (
+        DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_us_state.csv"
+    )
+
+    if processed_country_pop_path.exists() and processed_state_pop_path.exists():
+        print("✅ Population files already exist:")
+        print(f"  - {processed_country_pop_path}")
+        print(f"  - {processed_state_pop_path}")
+        print(
+            "Skipping population preprocessing. Delete these files if you want to re-run."
+        )
+        return True
+    return False
+
+
+def load_world_bank_population_data():
+    """
+    Load country-level working age population data from cache or World Bank API.
+
+    Returns:
+        pd.DataFrame: Raw population data from World Bank
+    """
+    # Check if raw data already exists
+    raw_country_pop_path = DATA_INPUT_DIR / f"working_age_pop_{YEAR}_country_raw.csv"
+    if raw_country_pop_path.exists():
+        print("Loading cached country population data...")
+        return pd.read_csv(raw_country_pop_path, keep_default_na=False, na_values=[""])
+
+    # Download if not cached
+    url = "https://api.worldbank.org/v2/country/all/indicator/SP.POP.1564.TO"
+    params = {"format": "json", "date": str(YEAR), "per_page": "1000"}
+
+    print("Downloading country population data from World Bank API...")
+    response = httpx.get(url, params=params)
+    response.raise_for_status()
+
+    # World Bank API returns [metadata, data] structure
+    data = response.json()[1]
+    df_raw = pd.json_normalize(data)
+
+    return df_raw
+
+
+def filter_to_country_level_data(df_raw):
+    """
+    Filter World Bank data to exclude regional aggregates and keep only countries.
+
+    The World Bank data starts with regional aggregates (Arab World, Caribbean small states, etc.)
+    followed by actual countries starting with Afghanistan (AFG).
+
+    Args:
+        df_raw: Raw World Bank data
+
+    Returns:
+        pd.DataFrame: Filtered data with only country-level records
+    """
+    # Find Afghanistan (AFG) - the first real country after aggregates
+    afg_index = df_raw[df_raw["countryiso3code"] == "AFG"].index[0]
+
+    # Keep everything from AFG onwards
+    df_filtered = df_raw.iloc[afg_index:].copy()
+    print(f"Filtered to {len(df_filtered)} countries (excluding regional aggregates)")
+
+    return df_filtered
+
+
+def process_country_population_data(df_raw):
+    """
+    Process raw World Bank population data.
+
+    Args:
+        df_raw: Raw data from World Bank API
+
+    Returns:
+        pd.DataFrame: Processed country population data (excluding countries where service is not available)
+    """
+    # Filter to country level only
+    df_country = filter_to_country_level_data(df_raw)
+
+    # Select and rename columns
+    df_processed = df_country[
+        ["countryiso3code", "date", "value", "country.id", "country.value"]
+    ].copy()
+
+    df_processed.columns = [
+        "iso_alpha_3",
+        "year",
+        "working_age_pop",
+        "country_code",
+        "country_name",
+    ]
+
+    # Convert year to int
+    df_processed["year"] = pd.to_numeric(df_processed["year"])
+    df_processed = df_processed.dropna(subset=["working_age_pop"])
+
+    # Remove Channel Islands entry with invalid JG code
+    channel_islands_mask = df_processed["country_code"] == "JG"
+    if channel_islands_mask.any():
+        print(f"Removing Channel Islands entry with invalid code 'JG'")
+        df_processed = df_processed[~channel_islands_mask].copy()
+
+    # Exclude countries where service is not available
+    initial_count = len(df_processed)
+    df_processed = df_processed[~df_processed["country_code"].isin(EXCLUDED_COUNTRIES)]
+    excluded_count = initial_count - len(df_processed)
+
+    if excluded_count > 0:
+        print(f"Excluded {excluded_count} countries where service is not available")
+
+    return df_processed
+
+
+def add_taiwan_population(df_country):
+    """
+    Add Taiwan population data from National Development Council.
+
+    The World Bank API excludes Taiwan, so we use data directly from Taiwan's NDC.
+    Source: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx
+
+    Args:
+        df_country: Country population dataframe
+
+    Returns:
+        pd.DataFrame: Country data with Taiwan added
+    """
+    taiwan_file = DATA_INPUT_DIR / "Population by single age _20250903072924.csv"
+
+    if not taiwan_file.exists():
+        error_msg = f"""
+Taiwan population data not found at: {taiwan_file}
+
+To obtain this data:
+1. Go to: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx?n=175&_Query=258170a1-1394-49fe-8d21-dc80562b72fb&page=1&PageSize=10&ToggleType=
+2. The following options should have been selected:
+   - Estimate type: Medium variant
+   - Gender: Total
+   - Year: {YEAR}
+   - Age: Single age (ages 15-64)
+   - Data attribute: data value
+3. Download the CSV file
+4. Save it as: "Population by single age _20250903072924.csv"
+5. Place it in your data input directory
+
+Note: Taiwan data is not available from World Bank API and must be obtained separately.
+"""
+        raise FileNotFoundError(error_msg)
+
+    print("Adding Taiwan population data from NDC...")
+
+    # Load the NDC data (skip metadata rows)
+    df_taiwan = pd.read_csv(taiwan_file, skiprows=10)
+
+    # Clean the age column and sum population
+    df_taiwan["Age"] = df_taiwan["Age"].str.replace("'", "")
+    df_taiwan["Age"] = pd.to_numeric(df_taiwan["Age"])
+
+    # The data is pre-filtered to ages 15-64, so sum all values
+    taiwan_working_age_pop = df_taiwan["Data value (persons)"].sum()
+
+    # Create Taiwan row
+    taiwan_row = pd.DataFrame(
+        {
+            "iso_alpha_3": ["TWN"],
+            "year": [YEAR],
+            "working_age_pop": [taiwan_working_age_pop],
+            "country_code": ["TW"],
+            "country_name": ["Taiwan"],
+        }
+    )
+
+    # Add Taiwan to the country data
+    df_with_taiwan = pd.concat([df_country, taiwan_row], ignore_index=True)
+    print(f"Added Taiwan: {taiwan_working_age_pop:,.0f} working age population")
+
+    return df_with_taiwan
+
+
+def load_us_state_population_data():
+    """
+    Load US state population data from cache or Census Bureau.
+
+    Returns:
+        pd.DataFrame: Raw US state population data
+    """
+    # Check if raw data already exists
+    raw_state_pop_path = DATA_INPUT_DIR / f"sc-est{YEAR}-agesex-civ.csv"
+    if raw_state_pop_path.exists():
+        print("Loading cached state population data...")
+        return pd.read_csv(raw_state_pop_path)
+
+    # Download if not cached
+    url = f"https://www2.census.gov/programs-surveys/popest/datasets/2020-{YEAR}/state/asrh/sc-est{YEAR}-agesex-civ.csv"
+
+    print("Downloading US state population data from Census Bureau...")
+    response = httpx.get(url)
+    response.raise_for_status()
+
+    df_raw = pd.read_csv(io.StringIO(response.text))
+    return df_raw
+
+
+def process_state_population_data(df_raw):
+    """
+    Process US state population data to get working age population.
+
+    Args:
+        df_raw: Raw Census Bureau data
+
+    Returns:
+        pd.DataFrame: Processed state population data with state codes
+    """
+    # Filter for working age (15-64) and sum by state
+    # SEX=0 means "Both sexes" to avoid double counting
+    df_working_age = df_raw[
+        (df_raw["AGE"] >= 15) & (df_raw["AGE"] <= 64) & (df_raw["SEX"] == 0)
+    ]
+
+    # Sum by state
+    working_age_by_state = (
+        df_working_age.groupby("NAME")[f"POPEST{YEAR}_CIV"].sum().reset_index()
+    )
+    working_age_by_state.columns = ["state", "working_age_pop"]
+
+    # Get state codes
+    state_code_dict = get_state_codes()
+
+    # Filter out "United States" row (national total, not a state)
+    working_age_by_state = working_age_by_state[
+        working_age_by_state["state"] != "United States"
+    ]
+
+    # Map state names to abbreviations
+    working_age_by_state["state_code"] = working_age_by_state["state"].map(
+        state_code_dict
+    )
+
+    # Check for missing state codes (should be none after filtering United States)
+    missing_codes = working_age_by_state[working_age_by_state["state_code"].isna()]
+    if not missing_codes.empty:
+        warnings.warn(
+            f"Could not find state codes for: {missing_codes['state'].tolist()}",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    return working_age_by_state
+
+
+def get_state_codes():
+    """
+    Get US state codes from Census Bureau.
+
+    Returns:
+        dict: Mapping of state names to abbreviations
+    """
+    state_codes_path = DATA_INPUT_DIR / "census_state_codes.txt"
+
+    if state_codes_path.exists():
+        print("Loading cached state codes...")
+        df_state_codes = pd.read_csv(state_codes_path, sep="|")
+    else:
+        print("Downloading state codes from Census Bureau...")
+        response = httpx.get("https://www2.census.gov/geo/docs/reference/state.txt")
+        response.raise_for_status()
+
+        # Save for future use
+        with open(state_codes_path, "w") as f:
+            f.write(response.text)
+        print(f"Cached state codes to {state_codes_path}")
+
+        df_state_codes = pd.read_csv(io.StringIO(response.text), sep="|")
+
+    # Create mapping dictionary
+    state_code_dict = dict(
+        zip(df_state_codes["STATE_NAME"], df_state_codes["STUSAB"], strict=True)
+    )
+
+    return state_code_dict
+
+
+def save_data(df_country, df_state, df_world_bank_raw, df_state_raw):
+    """
+    Save raw and processed population data.
+
+    Args:
+        df_country: Processed country population data
+        df_state: Processed state population data
+        df_world_bank_raw: Raw World Bank data
+        df_state_raw: Raw Census Bureau data
+    """
+    # Save raw data (only if doesn't exist)
+    raw_country_pop_path = DATA_INPUT_DIR / f"working_age_pop_{YEAR}_country_raw.csv"
+    if not raw_country_pop_path.exists():
+        df_world_bank_raw.to_csv(raw_country_pop_path, index=False)
+        print(f"Saved raw country data to {raw_country_pop_path}")
+
+    raw_state_pop_path = DATA_INPUT_DIR / f"sc-est{YEAR}-agesex-civ.csv"
+    if not raw_state_pop_path.exists():
+        df_state_raw.to_csv(raw_state_pop_path, index=False)
+        print(f"Saved raw state data to {raw_state_pop_path}")
+
+    # Save processed data
+    country_output_path = DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_country.csv"
+    df_country.to_csv(country_output_path, index=False)
+    print(f"Saved processed country population data to {country_output_path}")
+
+    state_output_path = DATA_INTERMEDIATE_DIR / f"working_age_pop_{YEAR}_us_state.csv"
+    df_state.to_csv(state_output_path, index=False)
+    print(f"Saved processed US state population data to {state_output_path}")
+
+
+def main():
+    """Main function to run population preprocessing."""
+    # Check if files already exist
+    if check_existing_files():
+        return
+
+    # Process country-level data
+    print("\n=== Processing Country-Level Population Data ===")
+    df_world_bank_raw = load_world_bank_population_data()
+    df_country = process_country_population_data(df_world_bank_raw)
+    df_country = add_taiwan_population(df_country)
+
+    # Process US state-level data
+    print("\n=== Processing US State-Level Population Data ===")
+    df_state_raw = load_us_state_population_data()
+    df_state = process_state_population_data(df_state_raw)
+
+    # Save all data (raw and processed)
+    print("\n=== Saving Data ===")
+    save_data(df_country, df_state, df_world_bank_raw, df_state_raw)
+
+    print("\n✅ Population data preprocessing complete!")
+
+    # Print summary statistics
+    print("\n=== Summary Statistics ===")
+    print(f"Countries processed: {len(df_country)}")
+    print(f"Countries excluded (service not available): {len(EXCLUDED_COUNTRIES)}")
+    print(
+        f"Total global working age population: {df_country['working_age_pop'].sum():,.0f}"
+    )
+    print(f"US states processed: {len(df_state)}")
+    print(f"Total US working age population: {df_state['working_age_pop'].sum():,.0f}")
+
+
+if __name__ == "__main__":
+    main()

release_2025_09_15/data/input/BTOS_National.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c55e2fc6892941a1a536e87445de0bee8ea327526081389b93b85c54a8d69761
+size 63052

release_2025_09_15/data/input/Population by single age _20250903072924.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89c1e953dbab481760a966c40bdb121ed4e301b4cd0cbaea8a44990caa91ce8e
+size 2176

release_2025_09_15/data/input/automation_vs_augmentation_v1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1e264882b17618db4f4a00b6f87f48134222bc5c15eefb3d46aae9519e89d11
+size 197

release_2025_09_15/data/input/automation_vs_augmentation_v2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d7d8b1666f3d942d728f9b2177681ca6756edfe01fb8fc130e29264d41a391e
+size 198

release_2025_09_15/data/input/bea_us_state_gdp_2024.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:913bc0d017570e711c71bc838016b3b52cbf49e717d0cabc4cc2d70306acfa5a
+size 1663

release_2025_09_15/data/input/census_state_codes.txt

@@ -0,0 +1,58 @@
+STATE|STUSAB|STATE_NAME|STATENS
+01|AL|Alabama|01779775
+02|AK|Alaska|01785533
+04|AZ|Arizona|01779777
+05|AR|Arkansas|00068085
+06|CA|California|01779778
+08|CO|Colorado|01779779
+09|CT|Connecticut|01779780
+10|DE|Delaware|01779781
+11|DC|District of Columbia|01702382
+12|FL|Florida|00294478
+13|GA|Georgia|01705317
+15|HI|Hawaii|01779782
+16|ID|Idaho|01779783
+17|IL|Illinois|01779784
+18|IN|Indiana|00448508
+19|IA|Iowa|01779785
+20|KS|Kansas|00481813
+21|KY|Kentucky|01779786
+22|LA|Louisiana|01629543
+23|ME|Maine|01779787
+24|MD|Maryland|01714934
+25|MA|Massachusetts|00606926
+26|MI|Michigan|01779789
+27|MN|Minnesota|00662849
+28|MS|Mississippi|01779790
+29|MO|Missouri|01779791
+30|MT|Montana|00767982
+31|NE|Nebraska|01779792
+32|NV|Nevada|01779793
+33|NH|New Hampshire|01779794
+34|NJ|New Jersey|01779795
+35|NM|New Mexico|00897535
+36|NY|New York|01779796
+37|NC|North Carolina|01027616
+38|ND|North Dakota|01779797
+39|OH|Ohio|01085497
+40|OK|Oklahoma|01102857
+41|OR|Oregon|01155107
+42|PA|Pennsylvania|01779798
+44|RI|Rhode Island|01219835
+45|SC|South Carolina|01779799
+46|SD|South Dakota|01785534
+47|TN|Tennessee|01325873
+48|TX|Texas|01779801
+49|UT|Utah|01455989
+50|VT|Vermont|01779802
+51|VA|Virginia|01779803
+53|WA|Washington|01779804
+54|WV|West Virginia|01779805
+55|WI|Wisconsin|01779806
+56|WY|Wyoming|01779807
+60|AS|American Samoa|01802701
+66|GU|Guam|01802705
+69|MP|Northern Mariana Islands|01779809
+72|PR|Puerto Rico|01779808
+74|UM|U.S. Minor Outlying Islands|01878752
+78|VI|U.S. Virgin Islands|01802710

release_2025_09_15/data/input/geonames_countryInfo.txt

@@ -0,0 +1,302 @@
+# ================================
+#
+#
+# CountryCodes:
+# ============
+#
+# The official ISO country code for the United Kingdom is 'GB'. The code 'UK' is reserved.
+#
+# A list of dependent countries is available here:
+# https://spreadsheets.google.com/ccc?key=pJpyPy-J5JSNhe7F_KxwiCA&hl=en
+#
+#
+# The countrycode XK temporarily stands for Kosvo:
+# http://geonames.wordpress.com/2010/03/08/xk-country-code-for-kosovo/								
+#
+#
+# CS (Serbia and Montenegro) with geonameId = 8505033 no longer exists.
+# AN (the Netherlands Antilles) with geonameId = 8505032 was dissolved on 10 October 2010.
+#
+#
+# Currencies :
+# ============
+#
+# A number of territories are not included in ISO 4217, because their currencies are not per se an independent currency,															
+# but a variant of another currency. These currencies are:
+#
+# 1. FO : Faroese krona (1:1 pegged to the Danish krone)				
+# 2. GG : Guernsey pound (1:1 pegged to the pound sterling)
+# 3. JE : Jersey pound (1:1 pegged to the pound sterling)			
+# 4. IM : Isle of Man pound (1:1 pegged to the pound sterling)																		
+# 5. TV : Tuvaluan dollar (1:1 pegged to the Australian dollar).											
+# 6. CK : Cook Islands dollar (1:1 pegged to the New Zealand dollar).				
+#	
+# The following non-ISO codes are, however, sometimes used: GGP for the Guernsey pound, 																		
+# JEP for the Jersey pound and IMP for the Isle of Man pound (http://en.wikipedia.org/wiki/ISO_4217)																		
+#	
+#																		
+# A list of currency symbols is available here : http://forum.geonames.org/gforum/posts/list/437.page																		
+# another list with fractional units is here: http://forum.geonames.org/gforum/posts/list/1961.page																		
+#																		
+#																		
+# Languages :																		
+# ===========																		
+#																		
+# The column 'languages' lists the languages spoken in a country ordered by the number of speakers. The language code is a 'locale' 																		
+# where any two-letter primary-tag is an ISO-639 language abbreviation and any two-letter initial subtag is an ISO-3166 country code.																		
+#																		
+# Example : es-AR is the Spanish variant spoken in Argentina.																		
+#																		
+#ISO	ISO3	ISO-Numeric	fips	Country	Capital	Area(in sq km)	Population	Continent	tld	CurrencyCode	CurrencyName	Phone	Postal Code Format	Postal Code Regex	Languages	geonameid	neighbours	EquivalentFipsCode
+AD	AND	020	AN	Andorra	Andorra la Vella	468	77006	EU	.ad	EUR	Euro	376	AD###	^(?:AD)*(\d{3})$	ca	3041565	ES,FR	
+AE	ARE	784	AE	United Arab Emirates	Abu Dhabi	82880	9630959	AS	.ae	AED	Dirham	971	##### #####	^\d{5}-\d{5}$	ar-AE,fa,en,hi,ur	290557	SA,OM	
+AF	AFG	004	AF	Afghanistan	Kabul	647500	37172386	AS	.af	AFN	Afghani	93			fa-AF,ps,uz-AF,tk	1149361	TM,CN,IR,TJ,PK,UZ	
+AG	ATG	028	AC	Antigua and Barbuda	St. John's	443	96286	NA	.ag	XCD	Dollar	+1-268			en-AG	3576396		
+AI	AIA	660	AV	Anguilla	The Valley	102	13254	NA	.ai	XCD	Dollar	+1-264	AI-####	^(?:AZ)*(\d{4})$	en-AI	3573511		
+AL	ALB	008	AL	Albania	Tirana	28748	2866376	EU	.al	ALL	Lek	355	####	^(\d{4})$	sq,el	783754	MK,GR,ME,RS,XK	
+AM	ARM	051	AM	Armenia	Yerevan	29800	3076200	AS	.am	AMD	Dram	374	######	^(\d{6})$	hy	174982	GE,IR,AZ,TR	
+AO	AGO	024	AO	Angola	Luanda	1246700	30809762	AF	.ao	AOA	Kwanza	244			pt-AO	3351879	CD,NA,ZM,CG	
+AQ	ATA	010	AY	Antarctica		14000000	0	AN	.aq							6697173		
+AR	ARG	032	AR	Argentina	Buenos Aires	2766890	44494502	SA	.ar	ARS	Peso	54	@####@@@	^[A-Z]?\d{4}[A-Z]{0,3}$	es-AR,en,it,de,fr,gn	3865483	CL,BO,UY,PY,BR	
+AS	ASM	016	AQ	American Samoa	Pago Pago	199	55465	OC	.as	USD	Dollar	+1-684	#####-####	96799	en-AS,sm,to	5880801		
+AT	AUT	040	AU	Austria	Vienna	83858	8847037	EU	.at	EUR	Euro	43	####	^(\d{4})$	de-AT,hr,hu,sl	2782113	CH,DE,HU,SK,CZ,IT,SI,LI	
+AU	AUS	036	AS	Australia	Canberra	7686850	24992369	OC	.au	AUD	Dollar	61	####	^(\d{4})$	en-AU	2077456		
+AW	ABW	533	AA	Aruba	Oranjestad	193	105845	NA	.aw	AWG	Guilder	297			nl-AW,pap,es,en	3577279		
+AX	ALA	248		Aland Islands	Mariehamn	1580	26711	EU	.ax	EUR	Euro	+358-18	#####	^(?:FI)*(\d{5})$	sv-AX	661882		FI
+AZ	AZE	031	AJ	Azerbaijan	Baku	86600	9942334	AS	.az	AZN	Manat	994	AZ ####	^(?:AZ )*(\d{4})$	az,ru,hy	587116	GE,IR,AM,TR,RU	
+BA	BIH	070	BK	Bosnia and Herzegovina	Sarajevo	51129	3323929	EU	.ba	BAM	Marka	387	#####	^(\d{5})$	bs,hr-BA,sr-BA	3277605	HR,ME,RS	
+BB	BRB	052	BB	Barbados	Bridgetown	431	286641	NA	.bb	BBD	Dollar	+1-246	BB#####	^(?:BB)*(\d{5})$	en-BB	3374084		
+BD	BGD	050	BG	Bangladesh	Dhaka	144000	161356039	AS	.bd	BDT	Taka	880	####	^(\d{4})$	bn-BD,en	1210997	MM,IN	
+BE	BEL	056	BE	Belgium	Brussels	30510	11422068	EU	.be	EUR	Euro	32	####	^(\d{4})$	nl-BE,fr-BE,de-BE	2802361	DE,NL,LU,FR	
+BF	BFA	854	UV	Burkina Faso	Ouagadougou	274200	19751535	AF	.bf	XOF	Franc	226			fr-BF,mos	2361809	NE,BJ,GH,CI,TG,ML	
+BG	BGR	100	BU	Bulgaria	Sofia	110910	7000039	EU	.bg	BGN	Lev	359	####	^(\d{4})$	bg,tr-BG,rom	732800	MK,GR,RO,TR,RS	
+BH	BHR	048	BA	Bahrain	Manama	665	1569439	AS	.bh	BHD	Dinar	973	####|###	^(\d{3}\d?)$	ar-BH,en,fa,ur	290291		
+BI	BDI	108	BY	Burundi	Gitega	27830	11175378	AF	.bi	BIF	Franc	257			fr-BI,rn	433561	TZ,CD,RW	
+BJ	BEN	204	BN	Benin	Porto-Novo	112620	11485048	AF	.bj	XOF	Franc	229			fr-BJ	2395170	NE,TG,BF,NG	
+BL	BLM	652	TB	Saint Barthelemy	Gustavia	21	8450	NA	.gp	EUR	Euro	590	#####	^(\d{5})$	fr	3578476		
+BM	BMU	060	BD	Bermuda	Hamilton	53	63968	NA	.bm	BMD	Dollar	+1-441	@@ ##	^([A-Z]{2}\d{2})$	en-BM,pt	3573345		
+BN	BRN	096	BX	Brunei	Bandar Seri Begawan	5770	428962	AS	.bn	BND	Dollar	673	@@####	^([A-Z]{2}\d{4})$	ms-BN,en-BN	1820814	MY	
+BO	BOL	068	BL	Bolivia	Sucre	1098580	11353142	SA	.bo	BOB	Boliviano	591			es-BO,qu,ay	3923057	PE,CL,PY,BR,AR	
+BQ	BES	535		Bonaire, Saint Eustatius and Saba 		328	18012	NA	.bq	USD	Dollar	599			nl,pap,en	7626844		
+BR	BRA	076	BR	Brazil	Brasilia	8511965	209469333	SA	.br	BRL	Real	55	#####-###	^\d{5}-\d{3}$	pt-BR,es,en,fr	3469034	SR,PE,BO,UY,GY,PY,GF,VE,CO,AR	
+BS	BHS	044	BF	Bahamas	Nassau	13940	385640	NA	.bs	BSD	Dollar	+1-242			en-BS	3572887		
+BT	BTN	064	BT	Bhutan	Thimphu	47000	754394	AS	.bt	BTN	Ngultrum	975			dz	1252634	CN,IN	
+BV	BVT	074	BV	Bouvet Island		49	0	AN	.bv	NOK	Krone					3371123		
+BW	BWA	072	BC	Botswana	Gaborone	600370	2254126	AF	.bw	BWP	Pula	267			en-BW,tn-BW	933860	ZW,ZA,NA	
+BY	BLR	112	BO	Belarus	Minsk	207600	9485386	EU	.by	BYN	Belarusian ruble	375	######	^(\d{6})$	be,ru	630336	PL,LT,UA,RU,LV	
+BZ	BLZ	084	BH	Belize	Belmopan	22966	383071	NA	.bz	BZD	Dollar	501			en-BZ,es	3582678	GT,MX	
+CA	CAN	124	CA	Canada	Ottawa	9984670	37058856	NA	.ca	CAD	Dollar	1	@#@ #@#	^([ABCEGHJKLMNPRSTVXY]\d[ABCEGHJKLMNPRSTVWXYZ]) ?(\d[ABCEGHJKLMNPRSTVWXYZ]\d)$ 	en-CA,fr-CA,iu	6251999	US	
+CC	CCK	166	CK	Cocos Islands	West Island	14	628	AS	.cc	AUD	Dollar	61	####	^(\d{4})$	ms-CC,en	1547376		
+CD	COD	180	CG	Democratic Republic of the Congo	Kinshasa	2345410	84068091	AF	.cd	CDF	Franc	243			fr-CD,ln,ktu,kg,sw,lua	203312	TZ,CF,SS,RW,ZM,BI,UG,CG,AO	
+CF	CAF	140	CT	Central African Republic	Bangui	622984	4666377	AF	.cf	XAF	Franc	236			fr-CF,sg,ln,kg	239880	TD,SD,CD,SS,CM,CG	
+CG	COG	178	CF	Republic of the Congo	Brazzaville	342000	5244363	AF	.cg	XAF	Franc	242			fr-CG,kg,ln-CG	2260494	CF,GA,CD,CM,AO	
+CH	CHE	756	SZ	Switzerland	Bern	41290	8516543	EU	.ch	CHF	Franc	41	####	^(\d{4})$	de-CH,fr-CH,it-CH,rm	2658434	DE,IT,LI,FR,AT	
+CI	CIV	384	IV	Ivory Coast	Yamoussoukro	322460	25069229	AF	.ci	XOF	Franc	225			fr-CI	2287781	LR,GH,GN,BF,ML	
+CK	COK	184	CW	Cook Islands	Avarua	240	21388	OC	.ck	NZD	Dollar	682			en-CK,mi	1899402		
+CL	CHL	152	CI	Chile	Santiago	756950	18729160	SA	.cl	CLP	Peso	56	#######	^(\d{7})$	es-CL	3895114	PE,BO,AR	
+CM	CMR	120	CM	Cameroon	Yaounde	475440	25216237	AF	.cm	XAF	Franc	237			en-CM,fr-CM	2233387	TD,CF,GA,GQ,CG,NG	
+CN	CHN	156	CH	China	Beijing	9596960	1411778724	AS	.cn	CNY	Yuan Renminbi	86	######	^(\d{6})$	zh-CN,yue,wuu,dta,ug,za	1814991	LA,BT,TJ,KZ,MN,AF,NP,MM,KG,PK,KP,RU,VN,IN	
+CO	COL	170	CO	Colombia	Bogota	1138910	49648685	SA	.co	COP	Peso	57	######	^(\d{6})$	es-CO	3686110	EC,PE,PA,BR,VE	
+CR	CRI	188	CS	Costa Rica	San Jose	51100	4999441	NA	.cr	CRC	Colon	506	#####	^(\d{5})$	es-CR,en	3624060	PA,NI	
+CU	CUB	192	CU	Cuba	Havana	110860	11338138	NA	.cu	CUP	Peso	53	CP #####	^(?:CP)*(\d{5})$	es-CU,pap	3562981	US	
+CV	CPV	132	CV	Cabo Verde	Praia	4033	543767	AF	.cv	CVE	Escudo	238	####	^(\d{4})$	pt-CV	3374766		
+CW	CUW	531	UC	Curacao	 Willemstad	444	159849	NA	.cw	ANG	Guilder	599			nl,pap	7626836		
+CX	CXR	162	KT	Christmas Island	Flying Fish Cove	135	1500	OC	.cx	AUD	Dollar	61	####	^(\d{4})$	en,zh,ms-CX	2078138		
+CY	CYP	196	CY	Cyprus	Nicosia	9250	1189265	EU	.cy	EUR	Euro	357	####	^(\d{4})$	el-CY,tr-CY,en	146669		
+CZ	CZE	203	EZ	Czechia	Prague	78866	10625695	EU	.cz	CZK	Koruna	420	### ##	^\d{3}\s?\d{2}$	cs,sk	3077311	PL,DE,SK,AT	
+DE	DEU	276	GM	Germany	Berlin	357021	82927922	EU	.de	EUR	Euro	49	#####	^(\d{5})$	de	2921044	CH,PL,NL,DK,BE,CZ,LU,FR,AT	
+DJ	DJI	262	DJ	Djibouti	Djibouti	23000	958920	AF	.dj	DJF	Franc	253			fr-DJ,ar,so-DJ,aa	223816	ER,ET,SO	
+DK	DNK	208	DA	Denmark	Copenhagen	43094	5797446	EU	.dk	DKK	Krone	45	####	^(\d{4})$	da-DK,en,fo,de-DK	2623032	DE	
+DM	DMA	212	DO	Dominica	Roseau	754	71625	NA	.dm	XCD	Dollar	+1-767			en-DM	3575830		
+DO	DOM	214	DR	Dominican Republic	Santo Domingo	48730	10627165	NA	.do	DOP	Peso	+1-809 and 1-829	#####	^(\d{5})$	es-DO	3508796	HT	
+DZ	DZA	012	AG	Algeria	Algiers	2381740	42228429	AF	.dz	DZD	Dinar	213	#####	^(\d{5})$	ar-DZ	2589581	NE,EH,LY,MR,TN,MA,ML	
+EC	ECU	218	EC	Ecuador	Quito	283560	17084357	SA	.ec	USD	Dollar	593	@####@	^([a-zA-Z]\d{4}[a-zA-Z])$	es-EC	3658394	PE,CO	
+EE	EST	233	EN	Estonia	Tallinn	45226	1320884	EU	.ee	EUR	Euro	372	#####	^(\d{5})$	et,ru	453733	RU,LV	
+EG	EGY	818	EG	Egypt	Cairo	1001450	98423595	AF	.eg	EGP	Pound	20	#####	^(\d{5})$	ar-EG,en,fr	357994	LY,SD,IL,PS	
+EH	ESH	732	WI	Western Sahara	El-Aaiun	266000	273008	AF	.eh	MAD	Dirham	212			ar,mey	2461445	DZ,MR,MA	
+ER	ERI	232	ER	Eritrea	Asmara	121320	6209262	AF	.er	ERN	Nakfa	291			aa-ER,ar,tig,kun,ti-ER	338010	ET,SD,DJ	
+ES	ESP	724	SP	Spain	Madrid	504782	46723749	EU	.es	EUR	Euro	34	#####	^(\d{5})$	es-ES,ca,gl,eu,oc	2510769	AD,PT,GI,FR,MA	
+ET	ETH	231	ET	Ethiopia	Addis Ababa	1127127	109224559	AF	.et	ETB	Birr	251	####	^(\d{4})$	am,en-ET,om-ET,ti-ET,so-ET,sid	337996	ER,KE,SD,SS,SO,DJ	
+FI	FIN	246	FI	Finland	Helsinki	337030	5518050	EU	.fi	EUR	Euro	358	#####	^(?:FI)*(\d{5})$	fi-FI,sv-FI,smn	660013	NO,RU,SE	
+FJ	FJI	242	FJ	Fiji	Suva	18270	883483	OC	.fj	FJD	Dollar	679			en-FJ,fj	2205218		
+FK	FLK	238	FK	Falkland Islands	Stanley	12173	2638	SA	.fk	FKP	Pound	500	FIQQ 1ZZ	FIQQ 1ZZ	en-FK	3474414		
+FM	FSM	583	FM	Micronesia	Palikir	702	112640	OC	.fm	USD	Dollar	691	#####	^(\d{5})$	en-FM,chk,pon,yap,kos,uli,woe,nkr,kpg	2081918		
+FO	FRO	234	FO	Faroe Islands	Torshavn	1399	48497	EU	.fo	DKK	Krone	298	###	^(?:FO)*(\d{3})$	fo,da-FO	2622320		
+FR	FRA	250	FR	France	Paris	547030	66987244	EU	.fr	EUR	Euro	33	#####	^(\d{5})$	fr-FR,frp,br,co,ca,eu,oc	3017382	CH,DE,BE,LU,IT,AD,MC,ES	
+GA	GAB	266	GB	Gabon	Libreville	267667	2119275	AF	.ga	XAF	Franc	241			fr-GA	2400553	CM,GQ,CG	
+GB	GBR	826	UK	United Kingdom	London	244820	66488991	EU	.uk	GBP	Pound	44	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^([Gg][Ii][Rr]\s?0[Aa]{2})|((([A-Za-z][0-9]{1,2})|(([A-Za-z][A-Ha-hJ-Yj-y][0-9]{1,2})|(([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-Ha-hJ-Yj-y][0-9]?[A-Za-z]))))\s?[0-9][A-Za-z]{2})$	en-GB,cy-GB,gd	2635167	IE	
+GD	GRD	308	GJ	Grenada	St. George's	344	111454	NA	.gd	XCD	Dollar	+1-473			en-GD	3580239		
+GE	GEO	268	GG	Georgia	Tbilisi	69700	3731000	AS	.ge	GEL	Lari	995	####	^(\d{4})$	ka,ru,hy,az	614540	AM,AZ,TR,RU	
+GF	GUF	254	FG	French Guiana	Cayenne	91000	195506	SA	.gf	EUR	Euro	594	#####	^((97|98)3\d{2})$	fr-GF	3381670	SR,BR	
+GG	GGY	831	GK	Guernsey	St Peter Port	78	65228	EU	.gg	GBP	Pound	+44-1481	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,nrf	3042362		
+GH	GHA	288	GH	Ghana	Accra	239460	29767108	AF	.gh	GHS	Cedi	233			en-GH,ak,ee,tw	2300660	CI,TG,BF	
+GI	GIB	292	GI	Gibraltar	Gibraltar	6.5	33718	EU	.gi	GIP	Pound	350	GX11 1AA	GX11 1AA	en-GI,es,it,pt	2411586	ES	
+GL	GRL	304	GL	Greenland	Nuuk	2166086	56025	NA	.gl	DKK	Krone	299	####	^(\d{4})$	kl,da-GL,en	3425505		
+GM	GMB	270	GA	Gambia	Banjul	11300	2280102	AF	.gm	GMD	Dalasi	220			en-GM,mnk,wof,wo,ff	2413451	SN	
+GN	GIN	324	GV	Guinea	Conakry	245857	12414318	AF	.gn	GNF	Franc	224			fr-GN	2420477	LR,SN,SL,CI,GW,ML	
+GP	GLP	312	GP	Guadeloupe	Basse-Terre	1780	443000	NA	.gp	EUR	Euro	590	#####	^((97|98)\d{3})$	fr-GP	3579143		
+GQ	GNQ	226	EK	Equatorial Guinea	Malabo	28051	1308974	AF	.gq	XAF	Franc	240			es-GQ,fr,pt	2309096	GA,CM	
+GR	GRC	300	GR	Greece	Athens	131940	10727668	EU	.gr	EUR	Euro	30	### ##	^(\d{5})$	el-GR,en,fr	390903	AL,MK,TR,BG	
+GS	SGS	239	SX	South Georgia and the South Sandwich Islands	Grytviken	3903	30	AN	.gs	GBP	Pound		SIQQ 1ZZ	SIQQ 1ZZ	en	3474415		
+GT	GTM	320	GT	Guatemala	Guatemala City	108890	17247807	NA	.gt	GTQ	Quetzal	502	#####	^(\d{5})$	es-GT	3595528	MX,HN,BZ,SV	
+GU	GUM	316	GQ	Guam	Hagatna	549	165768	OC	.gu	USD	Dollar	+1-671	969##	^(969\d{2})$	en-GU,ch-GU	4043988		
+GW	GNB	624	PU	Guinea-Bissau	Bissau	36120	1874309	AF	.gw	XOF	Franc	245	####	^(\d{4})$	pt-GW,pov	2372248	SN,GN	
+GY	GUY	328	GY	Guyana	Georgetown	214970	779004	SA	.gy	GYD	Dollar	592			en-GY	3378535	SR,BR,VE	
+HK	HKG	344	HK	Hong Kong	Hong Kong	1092	7396076	AS	.hk	HKD	Dollar	852	######	^(\d{6})$	zh-HK,yue,zh,en	1819730		
+HM	HMD	334	HM	Heard Island and McDonald Islands		412	0	AN	.hm	AUD	Dollar	 	####	^(\d{4})$		1547314		
+HN	HND	340	HO	Honduras	Tegucigalpa	112090	9587522	NA	.hn	HNL	Lempira	504	#####	^(\d{6})$	es-HN,cab,miq	3608932	GT,NI,SV	
+HR	HRV	191	HR	Croatia	Zagreb	56542	3871833	EU	.hr	EUR	Euro	385	#####	^(?:HR)*(\d{5})$	hr-HR,sr	3202326	HU,SI,BA,ME,RS	
+HT	HTI	332	HA	Haiti	Port-au-Prince	27750	11123176	NA	.ht	HTG	Gourde	509	HT####	^(?:HT)*(\d{4})$	ht,fr-HT	3723988	DO	
+HU	HUN	348	HU	Hungary	Budapest	93030	9768785	EU	.hu	HUF	Forint	36	####	^(\d{4})$	hu-HU	719819	SK,SI,RO,UA,HR,AT,RS	
+ID	IDN	360	ID	Indonesia	Jakarta	1919440	267663435	AS	.id	IDR	Rupiah	62	#####	^(\d{5})$	id,en,nl,jv	1643084	PG,TL,MY	
+IE	IRL	372	EI	Ireland	Dublin	70280	4853506	EU	.ie	EUR	Euro	353	@@@ @@@@	^(D6W|[AC-FHKNPRTV-Y][0-9]{2})\s?([AC-FHKNPRTV-Y0-9]{4})	en-IE,ga-IE	2963597	GB	
+IL	ISR	376	IS	Israel	Jerusalem	20770	8883800	AS	.il	ILS	Shekel	972	#######	^(\d{7}|\d{5})$	he,ar-IL,en-IL,	294640	SY,JO,LB,EG,PS	
+IM	IMN	833	IM	Isle of Man	Douglas	572	84077	EU	.im	GBP	Pound	+44-1624	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,gv	3042225		
+IN	IND	356	IN	India	New Delhi	3287590	1352617328	AS	.in	INR	Rupee	91	######	^(\d{6})$	en-IN,hi,bn,te,mr,ta,ur,gu,kn,ml,or,pa,as,bh,sat,ks,ne,sd,kok,doi,mni,sit,sa,fr,lus,inc	1269750	CN,NP,MM,BT,PK,BD	
+IO	IOT	086	IO	British Indian Ocean Territory	Diego Garcia	60	4000	AS	.io	USD	Dollar	246	BBND 1ZZ	BBND 1ZZ	en-IO	1282588		
+IQ	IRQ	368	IZ	Iraq	Baghdad	437072	38433600	AS	.iq	IQD	Dinar	964	#####	^(\d{5})$	ar-IQ,ku,hy	99237	SY,SA,IR,JO,TR,KW	
+IR	IRN	364	IR	Iran	Tehran	1648000	81800269	AS	.ir	IRR	Rial	98	##########	^(\d{10})$	fa-IR,ku	130758	TM,AF,IQ,AM,PK,AZ,TR	
+IS	ISL	352	IC	Iceland	Reykjavik	103000	353574	EU	.is	ISK	Krona	354	###	^(\d{3})$	is,en,de,da,sv,no	2629691		
+IT	ITA	380	IT	Italy	Rome	301230	60431283	EU	.it	EUR	Euro	39	#####	^(\d{5})$	it-IT,de-IT,fr-IT,sc,ca,co,sl	3175395	CH,VA,SI,SM,FR,AT	
+JE	JEY	832	JE	Jersey	Saint Helier	116	90812	EU	.je	GBP	Pound	+44-1534	@# #@@|@## #@@|@@# #@@|@@## #@@|@#@ #@@|@@#@ #@@|GIR0AA	^((?:(?:[A-PR-UWYZ][A-HK-Y]\d[ABEHMNPRV-Y0-9]|[A-PR-UWYZ]\d[A-HJKPS-UW0-9])\s\d[ABD-HJLNP-UW-Z]{2})|GIR\s?0AA)$	en,fr,nrf	3042142		
+JM	JAM	388	JM	Jamaica	Kingston	10991	2934855	NA	.jm	JMD	Dollar	+1-876			en-JM	3489940		
+JO	JOR	400	JO	Jordan	Amman	92300	9956011	AS	.jo	JOD	Dinar	962	#####	^(\d{5})$	ar-JO,en	248816	SY,SA,IQ,IL,PS	
+JP	JPN	392	JA	Japan	Tokyo	377835	126529100	AS	.jp	JPY	Yen	81	###-####	^\d{3}-\d{4}$	ja	1861060		
+KE	KEN	404	KE	Kenya	Nairobi	582650	51393010	AF	.ke	KES	Shilling	254	#####	^(\d{5})$	en-KE,sw-KE	192950	ET,TZ,SS,SO,UG	
+KG	KGZ	417	KG	Kyrgyzstan	Bishkek	198500	6315800	AS	.kg	KGS	Som	996	######	^(\d{6})$	ky,uz,ru	1527747	CN,TJ,UZ,KZ	
+KH	KHM	116	CB	Cambodia	Phnom Penh	181040	16249798	AS	.kh	KHR	Riels	855	#####	^(\d{5})$	km,fr,en	1831722	LA,TH,VN	
+KI	KIR	296	KR	Kiribati	Tarawa	811	115847	OC	.ki	AUD	Dollar	686			en-KI,gil	4030945		
+KM	COM	174	CN	Comoros	Moroni	2170	832322	AF	.km	KMF	Franc	269			ar,fr-KM	921929		
+KN	KNA	659	SC	Saint Kitts and Nevis	Basseterre	261	52441	NA	.kn	XCD	Dollar	+1-869			en-KN	3575174		
+KP	PRK	408	KN	North Korea	Pyongyang	120540	25549819	AS	.kp	KPW	Won	850	###-###	^(\d{6})$	ko-KP	1873107	CN,KR,RU	
+KR	KOR	410	KS	South Korea	Seoul	98480	51635256	AS	.kr	KRW	Won	82	#####	^(\d{5})$	ko-KR,en	1835841	KP	
+XK	XKX	0	KV	Kosovo	Pristina	10908	1845300	EU		EUR	Euro				sq,sr	831053	RS,AL,MK,ME	
+KW	KWT	414	KU	Kuwait	Kuwait City	17820	4137309	AS	.kw	KWD	Dinar	965	#####	^(\d{5})$	ar-KW,en	285570	SA,IQ	
+KY	CYM	136	CJ	Cayman Islands	George Town	262	64174	NA	.ky	KYD	Dollar	+1-345			en-KY	3580718		
+KZ	KAZ	398	KZ	Kazakhstan	Nur-Sultan	2717300	18276499	AS	.kz	KZT	Tenge	7	######	^(\d{6})$	kk,ru	1522867	TM,CN,KG,UZ,RU	
+LA	LAO	418	LA	Laos	Vientiane	236800	7061507	AS	.la	LAK	Kip	856	#####	^(\d{5})$	lo,fr,en	1655842	CN,MM,KH,TH,VN	
+LB	LBN	422	LE	Lebanon	Beirut	10400	6848925	AS	.lb	LBP	Pound	961	#### ####|####	^(\d{4}(\d{4})?)$	ar-LB,fr-LB,en,hy	272103	SY,IL	
+LC	LCA	662	ST	Saint Lucia	Castries	616	181889	NA	.lc	XCD	Dollar	+1-758			en-LC	3576468		
+LI	LIE	438	LS	Liechtenstein	Vaduz	160	37910	EU	.li	CHF	Franc	423	####	^(\d{4})$	de-LI	3042058	CH,AT	
+LK	LKA	144	CE	Sri Lanka	Colombo	65610	21670000	AS	.lk	LKR	Rupee	94	#####	^(\d{5})$	si,ta,en	1227603		
+LR	LBR	430	LI	Liberia	Monrovia	111370	4818977	AF	.lr	LRD	Dollar	231	####	^(\d{4})$	en-LR	2275384	SL,CI,GN	
+LS	LSO	426	LT	Lesotho	Maseru	30355	2108132	AF	.ls	LSL	Loti	266	###	^(\d{3})$	en-LS,st,zu,xh	932692	ZA	
+LT	LTU	440	LH	Lithuania	Vilnius	65200	2789533	EU	.lt	EUR	Euro	370	LT-#####	^(?:LT)*(\d{5})$	lt,ru,pl	597427	PL,BY,RU,LV	
+LU	LUX	442	LU	Luxembourg	Luxembourg	2586	607728	EU	.lu	EUR	Euro	352	L-####	^(?:L-)?\d{4}$	lb,de-LU,fr-LU	2960313	DE,BE,FR	
+LV	LVA	428	LG	Latvia	Riga	64589	1926542	EU	.lv	EUR	Euro	371	LV-####	^(?:LV)*(\d{4})$	lv,ru,lt	458258	LT,EE,BY,RU	
+LY	LBY	434	LY	Libya	Tripoli	1759540	6678567	AF	.ly	LYD	Dinar	218			ar-LY,it,en	2215636	TD,NE,DZ,SD,TN,EG	
+MA	MAR	504	MO	Morocco	Rabat	446550	36029138	AF	.ma	MAD	Dirham	212	#####	^(\d{5})$	ar-MA,ber,fr	2542007	DZ,EH,ES	
+MC	MCO	492	MN	Monaco	Monaco	1.95	38682	EU	.mc	EUR	Euro	377	#####	^(\d{5})$	fr-MC,en,it	2993457	FR	
+MD	MDA	498	MD	Moldova	Chisinau	33843	3545883	EU	.md	MDL	Leu	373	MD-####	^MD-\d{4}$	ro,ru,gag,tr	617790	RO,UA	
+ME	MNE	499	MJ	Montenegro	Podgorica	14026	622345	EU	.me	EUR	Euro	382	#####	^(\d{5})$	sr,hu,bs,sq,hr,rom	3194884	AL,HR,BA,RS,XK	
+MF	MAF	663	RN	Saint Martin	Marigot	53	37264	NA	.gp	EUR	Euro	590	#####	^(\d{5})$	fr	3578421	SX	
+MG	MDG	450	MA	Madagascar	Antananarivo	587040	26262368	AF	.mg	MGA	Ariary	261	###	^(\d{3})$	fr-MG,mg	1062947		
+MH	MHL	584	RM	Marshall Islands	Majuro	181.3	58413	OC	.mh	USD	Dollar	692	#####-####	^969\d{2}(-\d{4})$	mh,en-MH	2080185		
+MK	MKD	807	MK	North Macedonia	Skopje	25333	2082958	EU	.mk	MKD	Denar	389	####	^(\d{4})$	mk,sq,tr,rmm,sr	718075	AL,GR,BG,RS,XK	
+ML	MLI	466	ML	Mali	Bamako	1240000	19077690	AF	.ml	XOF	Franc	223			fr-ML,bm	2453866	SN,NE,DZ,CI,GN,MR,BF	
+MM	MMR	104	BM	Myanmar	Nay Pyi Taw	678500	53708395	AS	.mm	MMK	Kyat	95	#####	^(\d{5})$	my	1327865	CN,LA,TH,BD,IN	
+MN	MNG	496	MG	Mongolia	Ulaanbaatar	1565000	3170208	AS	.mn	MNT	Tugrik	976	######	^(\d{6})$	mn,ru	2029969	CN,RU	
+MO	MAC	446	MC	Macao	Macao	254	631636	AS	.mo	MOP	Pataca	853	######	^(\d{6})$	zh,zh-MO,pt	1821275		
+MP	MNP	580	CQ	Northern Mariana Islands	Saipan	477	56882	OC	.mp	USD	Dollar	+1-670	#####	^9695\d{1}$	fil,tl,zh,ch-MP,en-MP	4041468		
+MQ	MTQ	474	MB	Martinique	Fort-de-France	1100	432900	NA	.mq	EUR	Euro	596	#####	^(\d{5})$	fr-MQ	3570311		
+MR	MRT	478	MR	Mauritania	Nouakchott	1030700	4403319	AF	.mr	MRU	Ouguiya	222			ar-MR,fuc,snk,fr,mey,wo	2378080	SN,DZ,EH,ML	
+MS	MSR	500	MH	Montserrat	Plymouth	102	9341	NA	.ms	XCD	Dollar	+1-664			en-MS	3578097		
+MT	MLT	470	MT	Malta	Valletta	316	483530	EU	.mt	EUR	Euro	356	@@@ ####	^[A-Z]{3}\s?\d{4}$	mt,en-MT	2562770		
+MU	MUS	480	MP	Mauritius	Port Louis	2040	1265303	AF	.mu	MUR	Rupee	230			en-MU,bho,fr	934292		
+MV	MDV	462	MV	Maldives	Male	300	515696	AS	.mv	MVR	Rufiyaa	960	#####	^(\d{5})$	dv,en	1282028		
+MW	MWI	454	MI	Malawi	Lilongwe	118480	17563749	AF	.mw	MWK	Kwacha	265	######	^(\d{6})$	ny,yao,tum,swk	927384	TZ,MZ,ZM	
+MX	MEX	484	MX	Mexico	Mexico City	1972550	126190788	NA	.mx	MXN	Peso	52	#####	^(\d{5})$	es-MX	3996063	GT,US,BZ	
+MY	MYS	458	MY	Malaysia	Kuala Lumpur	329750	31528585	AS	.my	MYR	Ringgit	60	#####	^(\d{5})$	ms-MY,en,zh,ta,te,ml,pa,th	1733045	BN,TH,ID	
+MZ	MOZ	508	MZ	Mozambique	Maputo	801590	29495962	AF	.mz	MZN	Metical	258	####	^(\d{4})$	pt-MZ,vmw	1036973	ZW,TZ,SZ,ZA,ZM,MW	
+NA	NAM	516	WA	Namibia	Windhoek	825418	2448255	AF	.na	NAD	Dollar	264			en-NA,af,de,hz,naq	3355338	ZA,BW,ZM,AO	
+NC	NCL	540	NC	New Caledonia	Noumea	19060	284060	OC	.nc	XPF	Franc	687	#####	^(\d{5})$	fr-NC	2139685		
+NE	NER	562	NG	Niger	Niamey	1267000	22442948	AF	.ne	XOF	Franc	227	####	^(\d{4})$	fr-NE,ha,kr,dje	2440476	TD,BJ,DZ,LY,BF,NG,ML	
+NF	NFK	574	NF	Norfolk Island	Kingston	34.6	1828	OC	.nf	AUD	Dollar	672	####	^(\d{4})$	en-NF	2155115		
+NG	NGA	566	NI	Nigeria	Abuja	923768	195874740	AF	.ng	NGN	Naira	234	######	^(\d{6})$	en-NG,ha,yo,ig,ff	2328926	TD,NE,BJ,CM	
+NI	NIC	558	NU	Nicaragua	Managua	129494	6465513	NA	.ni	NIO	Cordoba	505	###-###-#	^(\d{7})$	es-NI,en	3617476	CR,HN	
+NL	NLD	528	NL	The Netherlands	Amsterdam	41526	17231017	EU	.nl	EUR	Euro	31	#### @@	^(\d{4}\s?[a-zA-Z]{2})$	nl-NL,fy-NL	2750405	DE,BE	
+NO	NOR	578	NO	Norway	Oslo	324220	5314336	EU	.no	NOK	Krone	47	####	^(\d{4})$	no,nb,nn,se,fi	3144096	FI,RU,SE	
+NP	NPL	524	NP	Nepal	Kathmandu	140800	28087871	AS	.np	NPR	Rupee	977	#####	^(\d{5})$	ne,en	1282988	CN,IN	
+NR	NRU	520	NR	Nauru	Yaren	21	12704	OC	.nr	AUD	Dollar	674	NRU68	NRU68	na,en-NR	2110425		
+NU	NIU	570	NE	Niue	Alofi	260	2166	OC	.nu	NZD	Dollar	683	####	^(\d{4})$	niu,en-NU	4036232		
+NZ	NZL	554	NZ	New Zealand	Wellington	268680	4885500	OC	.nz	NZD	Dollar	64	####	^(\d{4})$	en-NZ,mi	2186224		
+OM	OMN	512	MU	Oman	Muscat	212460	4829483	AS	.om	OMR	Rial	968	###	^(\d{3})$	ar-OM,en,bal,ur	286963	SA,YE,AE	
+PA	PAN	591	PM	Panama	Panama City	78200	4176873	NA	.pa	PAB	Balboa	507	#####	^(\d{5})$	es-PA,en	3703430	CR,CO	
+PE	PER	604	PE	Peru	Lima	1285220	31989256	SA	.pe	PEN	Sol	51	#####	^(\d{5})$	es-PE,qu,ay	3932488	EC,CL,BO,BR,CO	
+PF	PYF	258	FP	French Polynesia	Papeete	4167	277679	OC	.pf	XPF	Franc	689	#####	^((97|98)7\d{2})$	fr-PF,ty	4030656		
+PG	PNG	598	PP	Papua New Guinea	Port Moresby	462840	8606316	OC	.pg	PGK	Kina	675	###	^(\d{3})$	en-PG,ho,meu,tpi	2088628	ID	
+PH	PHL	608	RP	Philippines	Manila	300000	106651922	AS	.ph	PHP	Peso	63	####	^(\d{4})$	tl,en-PH,fil,ceb,ilo,hil,war,pam,bik,bcl,pag,mrw,tsg,mdh,cbk,krj,sgd,msb,akl,ibg,yka,mta,abx	1694008		
+PK	PAK	586	PK	Pakistan	Islamabad	803940	212215030	AS	.pk	PKR	Rupee	92	#####	^(\d{5})$	ur-PK,en-PK,pa,sd,ps,brh	1168579	CN,AF,IR,IN	
+PL	POL	616	PL	Poland	Warsaw	312685	37978548	EU	.pl	PLN	Zloty	48	##-###	^\d{2}-\d{3}$	pl	798544	DE,LT,SK,CZ,BY,UA,RU	
+PM	SPM	666	SB	Saint Pierre and Miquelon	Saint-Pierre	242	7012	NA	.pm	EUR	Euro	508	#####	^(97500)$	fr-PM	3424932		
+PN	PCN	612	PC	Pitcairn	Adamstown	47	46	OC	.pn	NZD	Dollar	870	PCRN 1ZZ	PCRN 1ZZ	en-PN	4030699		
+PR	PRI	630	RQ	Puerto Rico	San Juan	9104	3195153	NA	.pr	USD	Dollar	+1-787 and 1-939	#####-####	^00[679]\d{2}(?:-\d{4})?$	en-PR,es-PR	4566966		
+PS	PSE	275	WE	Palestinian Territory	East Jerusalem	5970	4569087	AS	.ps	ILS	Shekel	970			ar-PS	6254930	JO,IL,EG	
+PT	PRT	620	PO	Portugal	Lisbon	92391	10281762	EU	.pt	EUR	Euro	351	####-###	^\d{4}-\d{3}\s?[a-zA-Z]{0,25}$	pt-PT,mwl	2264397	ES	
+PW	PLW	585	PS	Palau	Melekeok	458	17907	OC	.pw	USD	Dollar	680	96940	^(96940)$	pau,sov,en-PW,tox,ja,fil,zh	1559582		
+PY	PRY	600	PA	Paraguay	Asuncion	406750	6956071	SA	.py	PYG	Guarani	595	####	^(\d{4})$	es-PY,gn	3437598	BO,BR,AR	
+QA	QAT	634	QA	Qatar	Doha	11437	2781677	AS	.qa	QAR	Rial	974			ar-QA,es	289688	SA	
+RE	REU	638	RE	Reunion	Saint-Denis	2517	776948	AF	.re	EUR	Euro	262	#####	^((97|98)(4|7|8)\d{2})$	fr-RE	935317		
+RO	ROU	642	RO	Romania	Bucharest	237500	19473936	EU	.ro	RON	Leu	40	######	^(\d{6})$	ro,hu,rom	798549	MD,HU,UA,BG,RS	
+RS	SRB	688	RI	Serbia	Belgrade	88361	6982084	EU	.rs	RSD	Dinar	381	#####	^(\d{5})$	sr,hu,bs,rom	6290252	AL,HU,MK,RO,HR,BA,BG,ME,XK	
+RU	RUS	643	RS	Russia	Moscow	17100000	144478050	EU	.ru	RUB	Ruble	7	######	^(\d{6})$	ru,tt,xal,cau,ady,kv,ce,tyv,cv,udm,tut,mns,bua,myv,mdf,chm,ba,inh,kbd,krc,av,sah,nog	2017370	GE,CN,BY,UA,KZ,LV,PL,EE,LT,FI,MN,NO,AZ,KP	
+RW	RWA	646	RW	Rwanda	Kigali	26338	12301939	AF	.rw	RWF	Franc	250			rw,en-RW,fr-RW,sw	49518	TZ,CD,BI,UG	
+SA	SAU	682	SA	Saudi Arabia	Riyadh	1960582	33699947	AS	.sa	SAR	Rial	966	#####	^(\d{5})$	ar-SA	102358	QA,OM,IQ,YE,JO,AE,KW	
+SB	SLB	090	BP	Solomon Islands	Honiara	28450	652858	OC	.sb	SBD	Dollar	677			en-SB,tpi	2103350		
+SC	SYC	690	SE	Seychelles	Victoria	455	96762	AF	.sc	SCR	Rupee	248			en-SC,fr-SC	241170		
+SD	SDN	729	SU	Sudan	Khartoum	1861484	41801533	AF	.sd	SDG	Pound	249	#####	^(\d{5})$	ar-SD,en,fia	366755	SS,TD,EG,ET,ER,LY,CF	
+SS	SSD	728	OD	South Sudan	Juba	644329	8260490	AF	.ss	SSP	Pound	211			en	7909807	CD,CF,ET,KE,SD,UG	
+SE	SWE	752	SW	Sweden	Stockholm	449964	10183175	EU	.se	SEK	Krona	46	### ##	^(?:SE)?\d{3}\s\d{2}$	sv-SE,se,sma,fi-SE	2661886	NO,FI	
+SG	SGP	702	SN	Singapore	Singapore	692.7	5638676	AS	.sg	SGD	Dollar	65	######	^(\d{6})$	cmn,en-SG,ms-SG,ta-SG,zh-SG	1880251		
+SH	SHN	654	SH	Saint Helena	Jamestown	410	7460	AF	.sh	SHP	Pound	290	STHL 1ZZ	^(STHL1ZZ)$	en-SH	3370751		
+SI	SVN	705	SI	Slovenia	Ljubljana	20273	2067372	EU	.si	EUR	Euro	386	####	^(?:SI)*(\d{4})$	sl,sh	3190538	HU,IT,HR,AT	
+SJ	SJM	744	SV	Svalbard and Jan Mayen	Longyearbyen	62049	2550	EU	.sj	NOK	Krone	47	####	^(\d{4})$	no,ru	607072		
+SK	SVK	703	LO	Slovakia	Bratislava	48845	5447011	EU	.sk	EUR	Euro	421	### ##	^\d{3}\s?\d{2}$	sk,hu	3057568	PL,HU,CZ,UA,AT	
+SL	SLE	694	SL	Sierra Leone	Freetown	71740	7650154	AF	.sl	SLE	Leone	232			en-SL,men,tem	2403846	LR,GN	
+SM	SMR	674	SM	San Marino	San Marino	61.2	33785	EU	.sm	EUR	Euro	378	4789#	^(4789\d)$	it-SM	3168068	IT	
+SN	SEN	686	SG	Senegal	Dakar	196190	15854360	AF	.sn	XOF	Franc	221	#####	^(\d{5})$	fr-SN,wo,fuc,mnk	2245662	GN,MR,GW,GM,ML	
+SO	SOM	706	SO	Somalia	Mogadishu	637657	15008154	AF	.so	SOS	Shilling	252	@@  #####	^([A-Z]{2}\d{5})$	so-SO,ar-SO,it,en-SO	51537	ET,KE,DJ	
+SR	SUR	740	NS	Suriname	Paramaribo	163270	575991	SA	.sr	SRD	Dollar	597			nl-SR,en,srn,hns,jv	3382998	GY,BR,GF	
+ST	STP	678	TP	Sao Tome and Principe	Sao Tome	1001	197700	AF	.st	STN	Dobra	239			pt-ST	2410758		
+SV	SLV	222	ES	El Salvador	San Salvador	21040	6420744	NA	.sv	USD	Dollar	503	CP ####	^(?:CP)*(\d{4})$	es-SV	3585968	GT,HN	
+SX	SXM	534	NN	Sint Maarten	Philipsburg	21	40654	NA	.sx	ANG	Guilder	599			nl,en	7609695	MF	
+SY	SYR	760	SY	Syria	Damascus	185180	16906283	AS	.sy	SYP	Pound	963			ar-SY,ku,hy,arc,fr,en	163843	IQ,JO,IL,TR,LB	
+SZ	SWZ	748	WZ	Eswatini	Mbabane	17363	1136191	AF	.sz	SZL	Lilangeni	268	@###	^([A-Z]\d{3})$	en-SZ,ss-SZ	934841	ZA,MZ	
+TC	TCA	796	TK	Turks and Caicos Islands	Cockburn Town	430	37665	NA	.tc	USD	Dollar	+1-649	TKCA 1ZZ	^(TKCA 1ZZ)$	en-TC	3576916		
+TD	TCD	148	CD	Chad	N'Djamena	1284000	15477751	AF	.td	XAF	Franc	235	TKCA 1ZZ	^(TKCA 1ZZ)$	fr-TD,ar-TD,sre	2434508	NE,LY,CF,SD,CM,NG	
+TF	ATF	260	FS	French Southern Territories	Port-aux-Francais	7829	140	AN	.tf	EUR	Euro				fr	1546748		
+TG	TGO	768	TO	Togo	Lome	56785	7889094	AF	.tg	XOF	Franc	228			fr-TG,ee,hna,kbp,dag,ha	2363686	BJ,GH,BF	
+TH	THA	764	TH	Thailand	Bangkok	514000	69428524	AS	.th	THB	Baht	66	#####	^(\d{5})$	th,en	1605651	LA,MM,KH,MY	
+TJ	TJK	762	TI	Tajikistan	Dushanbe	143100	9100837	AS	.tj	TJS	Somoni	992	######	^(\d{6})$	tg,ru	1220409	CN,AF,KG,UZ	
+TK	TKL	772	TL	Tokelau		10	1466	OC	.tk	NZD	Dollar	690			tkl,en-TK	4031074		
+TL	TLS	626	TT	Timor Leste	Dili	15007	1267972	OC	.tl	USD	Dollar	670			tet,pt-TL,id,en	1966436	ID	
+TM	TKM	795	TX	Turkmenistan	Ashgabat	488100	5850908	AS	.tm	TMT	Manat	993	######	^(\d{6})$	tk,ru,uz	1218197	AF,IR,UZ,KZ	
+TN	TUN	788	TS	Tunisia	Tunis	163610	11565204	AF	.tn	TND	Dinar	216	####	^(\d{4})$	ar-TN,fr	2464461	DZ,LY	
+TO	TON	776	TN	Tonga	Nuku'alofa	748	103197	OC	.to	TOP	Pa'anga	676			to,en-TO	4032283		
+TR	TUR	792	TU	Turkey	Ankara	780580	82319724	AS	.tr	TRY	Lira	90	#####	^(\d{5})$	tr-TR,ku,diq,az,av	298795	SY,GE,IQ,IR,GR,AM,AZ,BG	
+TT	TTO	780	TD	Trinidad and Tobago	Port of Spain	5128	1389858	NA	.tt	TTD	Dollar	+1-868			en-TT,hns,fr,es,zh	3573591		
+TV	TUV	798	TV	Tuvalu	Funafuti	26	11508	OC	.tv	AUD	Dollar	688			tvl,en,sm,gil	2110297		
+TW	TWN	158	TW	Taiwan	Taipei	35980	23451837	AS	.tw	TWD	Dollar	886	#####	^(\d{5})$	zh-TW,zh,nan,hak	1668284		
+TZ	TZA	834	TZ	Tanzania	Dodoma	945087	56318348	AF	.tz	TZS	Shilling	255			sw-TZ,en,ar	149590	MZ,KE,CD,RW,ZM,BI,UG,MW	
+UA	UKR	804	UP	Ukraine	Kyiv	603700	44622516	EU	.ua	UAH	Hryvnia	380	#####	^(\d{5})$	uk,ru-UA,rom,pl,hu	690791	PL,MD,HU,SK,BY,RO,RU	
+UG	UGA	800	UG	Uganda	Kampala	236040	42723139	AF	.ug	UGX	Shilling	256			en-UG,lg,sw,ar	226074	TZ,KE,SS,CD,RW	
+UM	UMI	581		United States Minor Outlying Islands		0	0	OC	.um	USD	Dollar	1			en-UM	5854968		
+US	USA	840	US	United States	Washington	9629091	327167434	NA	.us	USD	Dollar	1	#####-####	^\d{5}(-\d{4})?$	en-US,es-US,haw,fr	6252001	CA,MX,CU	
+UY	URY	858	UY	Uruguay	Montevideo	176220	3449299	SA	.uy	UYU	Peso	598	#####	^(\d{5})$	es-UY	3439705	BR,AR	
+UZ	UZB	860	UZ	Uzbekistan	Tashkent	447400	32955400	AS	.uz	UZS	Som	998	######	^(\d{6})$	uz,ru,tg	1512440	TM,AF,KG,TJ,KZ	
+VA	VAT	336	VT	Vatican	Vatican City	0.44	921	EU	.va	EUR	Euro	379	#####	^(\d{5})$	la,it,fr	3164670	IT	
+VC	VCT	670	VC	Saint Vincent and the Grenadines	Kingstown	389	110211	NA	.vc	XCD	Dollar	+1-784			en-VC,fr	3577815		
+VE	VEN	862	VE	Venezuela	Caracas	912050	28870195	SA	.ve	VES	Bolivar Soberano	58	####	^(\d{4})$	es-VE	3625428	GY,BR,CO	
+VG	VGB	092	VI	British Virgin Islands	Road Town	153	29802	NA	.vg	USD	Dollar	+1-284			en-VG	3577718		
+VI	VIR	850	VQ	U.S. Virgin Islands	Charlotte Amalie	352	106977	NA	.vi	USD	Dollar	+1-340	#####-####	^008\d{2}(?:-\d{4})?$	en-VI	4796775		
+VN	VNM	704	VM	Vietnam	Hanoi	329560	95540395	AS	.vn	VND	Dong	84	######	^(\d{6})$	vi,en,fr,zh,km	1562822	CN,LA,KH	
+VU	VUT	548	NH	Vanuatu	Port Vila	12200	292680	OC	.vu	VUV	Vatu	678			bi,en-VU,fr-VU	2134431		
+WF	WLF	876	WF	Wallis and Futuna	Mata Utu	274	16025	OC	.wf	XPF	Franc	681	#####	^(986\d{2})$	wls,fud,fr-WF	4034749		
+WS	WSM	882	WS	Samoa	Apia	2944	196130	OC	.ws	WST	Tala	685	AS 96799	AS 96799	sm,en-WS	4034894		
+YE	YEM	887	YM	Yemen	Sanaa	527970	28498687	AS	.ye	YER	Rial	967			ar-YE	69543	SA,OM	
+YT	MYT	175	MF	Mayotte	Mamoudzou	374	279471	AF	.yt	EUR	Euro	262	#####	^(\d{5})$	fr-YT	1024031		
+ZA	ZAF	710	SF	South Africa	Pretoria	1219912	57779622	AF	.za	ZAR	Rand	27	####	^(\d{4})$	zu,xh,af,nso,en-ZA,tn,st,ts,ss,ve,nr	953987	ZW,SZ,MZ,BW,NA,LS	
+ZM	ZMB	894	ZA	Zambia	Lusaka	752614	17351822	AF	.zm	ZMW	Kwacha	260	#####	^(\d{5})$	en-ZM,bem,loz,lun,lue,ny,toi	895949	ZW,TZ,MZ,CD,NA,MW,AO	
+ZW	ZWE	716	ZI	Zimbabwe	Harare	390580	16868409	AF	.zw	ZWG	Zimbabwe Gold	263			en-ZW,sn,nr,nd	878675	ZA,MZ,BW,ZM	
+CS	SCG	891	YI	Serbia and Montenegro	Belgrade	102350	10829175	EU	.cs	RSD	Dinar	381	#####	^(\d{5})$	cu,hu,sq,sr	8505033	AL,HU,MK,RO,HR,BA,BG	
+AN	ANT	530	NT	Netherlands Antilles	Willemstad	960	300000	NA	.an	ANG	Guilder	599			nl-AN,en,es	8505032	GP	

release_2025_09_15/data/input/imf_gdp_raw_2024.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8583c093381da17225f57ee69ab39285f4c9557d53fa1ce5a8ce1160950c509
+size 265358

release_2025_09_15/data/input/onet_task_statements_raw.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:373cdc961891d04bcd29db66c43c7cf412d61fe3ef1f49e634dd979f4d5a3a95
+size 1204658

release_2025_09_15/data/input/sc-est2024-agesex-civ.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:334210a5080a6e470db22e42346ba7e6d0d43490887e08c5ed3ece62a7adfa9c
+size 818707

release_2025_09_15/data/input/soc_structure_raw.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05eb5e689fb471b7a66962b57bba6666dee2c3e6a6854f0f84faf423af68dd17
+size 77176

release_2025_09_15/data/input/task_pct_v1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8de89c99f762146c9e46b2202c3501e2a14f11c5b44c61c8007021127b6c676e
+size 461306

release_2025_09_15/data/input/task_pct_v2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c20f184cd4a1e3d8ef3d77f500b32b62431ce61a3c2f133c3af7fa8429f97db
+size 435372

release_2025_09_15/data/input/working_age_pop_2024_country_raw.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c86dcb133a3f9f54f5f22e74683f5d6c5cc97faa9ddc2cdd466a4422cd4124c
+size 22974

release_2025_09_15/data/intermediate/aei_raw_1p_api_2025-08-04_to_2025-08-11.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0fc061ea7d4feb71a7bd88c528d54e2d3a11e2045574f1e1fb2d594eebffd0f
+size 7027019

release_2025_09_15/data/intermediate/aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8ef9c5eee0c42febc73e358ecc7d2358e0a0ce3b50122c0c15ae8ec569aceff
+size 18894517

release_2025_09_15/data/intermediate/gdp_2024_country.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0618d6ba634a612b97b1c82f521ab38a387216069818a86f50c9aaf8e2bda6c
+size 4115

release_2025_09_15/data/intermediate/gdp_2024_us_state.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb1573e8143bd407c2ea7c43f5a6822852568c596dbde843fc5d8692c9e967ec
+size 2179

release_2025_09_15/data/intermediate/iso_country_codes.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eee318d4ab2c2c30f5a7da11f2bc7e0e36c246f6be5bb9b323fdb12b8e4809e0
+size 4564

release_2025_09_15/data/intermediate/onet_task_statements.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88427f8d2a9f37a7c08b5420c6c66a01cdae6467b716bbbd31989128504b8ebb
+size 3650862

release_2025_09_15/data/intermediate/soc_structure.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97dee70470182ac642872839f71a4a938c03677829aadca9bfbf250cb4021863
+size 78834

release_2025_09_15/data/intermediate/working_age_pop_2024_country.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a9e0edc0453702e8efb63d7cab57e5b1a689bc09e070626bbf513e37edd5dd3
+size 6321

release_2025_09_15/data/intermediate/working_age_pop_2024_us_state.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2d0fb7239934f4f6d0ae3444ab12ad8ff1dd323b71ccfc4295d074b537f17ec
+size 1079

release_2025_09_15/data/output/aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48a2c39f8a98ce7c2ba72767cbe3760fd55ba4a64a193abfecefc76d19852c09
+size 26840881

release_2025_09_15/data/output/request_hierarchy_tree_1p_api.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c0ef84206a84df500387d7139e333081aea27e67c6b51162f42d17f418c045d
+size 304162

release_2025_09_15/data/output/request_hierarchy_tree_claude_ai.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79f9f7939ba8c2dda1a5e52967dd9c6def3238e9fe024772330a411c849de7e0
+size 438531

release_2025_09_15/data_documentation.md

@@ -0,0 +1,373 @@
+# Data Documentation
+
+This document describes the data sources and variables used in the third Anthropic Economic Index (AEI) report.
+
+## Claude.ai Usage Data
+
+### Overview
+The core dataset contains Claude AI usage metrics aggregated by geography and analysis dimensions (facets).
+
+**Source files**:
+- `aei_raw_claude_ai_2025-08-04_to_2025-08-11.csv` (pre-enrichment data in data/intermediate/)
+- `aei_enriched_claude_ai_2025-08-04_to_2025-08-11.csv` (enriched data in data/output/)
+
+**Note on data sources**: The AEI raw file contains raw counts and percentages. Derived metrics (indices, tiers, per capita calculations, automation/augmentation percentages) are calculated during the enrichment process in `aei_report_v3_preprocessing_claude_ai.ipynb`.
+
+### Data Schema
+Each row represents one metric value for a specific geography and facet combination:
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `geo_id` | string | Geographic identifier (ISO-2 country code for countries, US state code, or "GLOBAL", ISO-3 country codes in enriched data) |
+| `geography` | string | Geographic level: "country", "state_us", or "global" |
+| `date_start` | date | Start of data collection period |
+| `date_end` | date | End of data collection period |
+| `platform_and_product` | string | "Claude AI (Free and Pro)" |
+| `facet` | string | Analysis dimension (see Facets below) |
+| `level` | integer | Sub-level within facet (0-2) |
+| `variable` | string | Metric name (see Variables below) |
+| `cluster_name` | string | Specific entity within facet (task, pattern, etc.). For intersections, format is "base::category" |
+| `value` | float | Numeric metric value |
+
+### Facets
+- **country**: Country-level aggregations
+- **state_us**: US state-level aggregations
+- **onet_task**: O*NET occupational tasks
+- **collaboration**: Human-AI collaboration patterns
+- **request**: Request complexity levels (0=highest granularity, 1=middle granularity, 2=lowest granularity)
+- **onet_task::collaboration**: Intersection of tasks and collaboration patterns
+- **request::collaboration**: Intersection of request categories and collaboration patterns
+
+### Core Variables
+
+Variables follow the pattern `{prefix}_{suffix}` with specific meanings:
+
+**From AEI processing**: `*_count`, `*_pct`
+**From enrichment**: `*_per_capita`, `*_per_capita_index`, `*_pct_index`, `*_tier`, `automation_pct`, `augmentation_pct`, `soc_pct`
+
+#### Usage Metrics
+- **usage_count**: Total number of conversations/interactions in a geography
+- **usage_pct**: Percentage of total usage (relative to parent geography - gobal for countries, US for states)
+- **usage_per_capita**: Usage count divided by working age population
+- **usage_per_capita_index**: Concentration index showing if a geography has more/less usage than expected based on population share (1.0 = proportional, >1.0 = over-representation, <1.0 = under-representation)
+- **usage_tier**: Usage adoption tier (0 = no/little adoption, 1-4 = quartiles of adoption among geographies with sufficient usage)
+
+#### Content Facet Metrics
+**O*NET Task Metrics**:
+- **onet_task_count**: Number of conversations using this specific O*NET task
+- **onet_task_pct**: Percentage of geographic total using this task
+- **onet_task_pct_index**: Specialization index comparing task usage to baseline (global for countries, US for states)
+- **onet_task_collaboration_count**: Number of conversations with both this task and collaboration pattern (intersection)
+- **onet_task_collaboration_pct**: Percentage of the base task's total that has this collaboration pattern (sums to 100% within each task)
+
+#### Occupation Metrics
+- **soc_pct**: Percentage of classified O*NET tasks associated with this SOC major occupation group (e.g., Management, Computer and Mathematical)
+
+**Request Metrics**:
+- **request_count**: Number of conversations in this request category level
+- **request_pct**: Percentage of geographic total in this category
+- **request_pct_index**: Specialization index comparing request usage to baseline
+- **request_collaboration_count**: Number of conversations with both this request category and collaboration pattern (intersection)
+- **request_collaboration_pct**: Percentage of the base request's total that has this collaboration pattern (sums to 100% within each request)
+
+**Collaboration Pattern Metrics**:
+- **collaboration_count**: Number of conversations with this collaboration pattern
+- **collaboration_pct**: Percentage of geographic total with this pattern
+- **collaboration_pct_index**: Specialization index comparing pattern to baseline
+- **automation_pct**: Percentage of classifiable collaboration that is automation-focused (directive, feedback loop patterns)
+- **augmentation_pct**: Percentage of classifiable collaboration that is augmentation-focused (validation, task iteration, learning patterns)
+
+#### Demographic & Economic Metrics
+- **working_age_pop**: Population aged 15-64 (working age definition used by World Bank)
+- **gdp_per_working_age_capita**: Total GDP divided by working age population (in USD)
+
+#### Special Values
+- **not_classified**: Indicates data that was filtered for privacy protection or could not be classified
+- **none**: Indicates the absence of the attribute (e.g., no collaboration, no task selected)
+
+### Data Processing Notes
+- **Minimum Observations**: 200 conversations per country, 100 per US state (applied in enrichment step, not raw preprocessing)
+- **Population Base**: Working-age population (ages 15-64)
+- **not_classified**:
+  - For regular facets: Captures filtered/unclassified conversations
+  - For intersection facets: Each base cluster has its own not_classified (e.g., "task1::not_classified")
+- **Intersection Percentages**: Calculated relative to base cluster totals, ensuring each base cluster's percentages sum to 100%
+- **Percentage Index Calculations**:
+  - Exclude `not_classified` and `none` categories from index calculations as they are not meaningful
+- **Country Codes**: ISO-2 format (e.g., "US" in raw data), ISO-3 (e.g., "USA", "GBR", "FRA") for countries after enrichment
+- **Variable Definitions**: See Core Variables section above
+
+## 1P API Usage Data
+
+### Overview
+Dataset containing first-party API usage metrics along various dimensions based on a sample of 1P API traffic and analyzed using privacy-preserving methods.
+
+**Source file**: `aei_raw_1p_api_2025-08-04_to_2025-08-11.csv` (in data/intermediate/)
+
+### Data Schema
+Each row represents one metric value for a specific facet combination at global level:
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `geo_id` | string | Geographic identifier (always "GLOBAL" for API data) |
+| `geography` | string | Geographic level (always "global" for API data) |
+| `date_start` | date | Start of data collection period |
+| `date_end` | date | End of data collection period |
+| `platform_and_product` | string | "1P API" |
+| `facet` | string | Analysis dimension (see Facets below) |
+| `level` | integer | Sub-level within facet (0-2) |
+| `variable` | string | Metric name (see Variables below) |
+| `cluster_name` | string | Specific entity within facet. For intersections, format is "base::category" or "base::index"/"base::count" for mean value metrics |
+| `value` | float | Numeric metric value |
+
+### Facets
+- **onet_task**: O*NET occupational tasks
+- **collaboration**: Human-AI collaboration patterns
+- **request**: Request categories (hierarchical levels 0-2 from bottom-up taxonomy)
+- **onet_task::collaboration**: Intersection of tasks and collaboration patterns
+- **onet_task::prompt_tokens**: Mean prompt tokens per task (normalized, average = 1.0)
+- **onet_task::completion_tokens**: Mean completion tokens per task (normalized, average = 1.0)
+- **onet_task::cost**: Mean cost per task (normalized, average = 1.0)
+- **request::collaboration**: Intersection of request categories and collaboration patterns
+
+### Core Variables
+
+#### Usage Metrics
+- **collaboration_count**: Number of 1P API records with this collaboration pattern
+- **collaboration_pct**: Percentage of total with this pattern
+
+#### Content Facet Metrics
+**O*NET Task Metrics**:
+- **onet_task_count**: Number of 1P API records using this specific O*NET task
+- **onet_task_pct**: Percentage of total using this task
+- **onet_task_collaboration_count**: Records with both this task and collaboration pattern
+- **onet_task_collaboration_pct**: Percentage of the task's total with this collaboration pattern
+
+**Mean Value Intersection Metrics** (unique to API data):
+- **prompt_tokens_index**: Re-indexed mean prompt tokens (1.0 = average across all tasks)
+- **prompt_tokens_count**: Number of records for this metric
+- **completion_tokens_index**: Re-indexed mean completion tokens (1.0 = average across all tasks)
+- **completion_tokens_count**: Number of records for this metric
+- **cost_index**: Re-indexed mean cost (1.0 = average across all tasks)
+- **cost_count**: Number of records for this metric
+
+**Request Metrics**:
+- **request_count**: Number of 1P API records in this request category
+- **request_pct**: Percentage of total in this category
+- **request_collaboration_count**: Records with both this request category and collaboration pattern
+- **request_collaboration_pct**: Percentage of the request's total with this collaboration pattern
+
+## Claude.ai Request Hierarchy
+
+Contains the hierarchy of request clusters for Claude.ai usage with their names and descriptions.
+
+**Source file**: `request_hierarchy_tree_claude_ai.json` (in data/output/)
+
+## 1P API Request Hierarchy
+
+Contains the hierarchy of request clusters for 1P API usage with their names and descriptions.
+
+**Source file**: `request_hierarchy_tree_1p_api.json` (in data/output/)
+
+## Claude.ai Usage Data from Prior Anthropic Economic Index Releases
+
+Data on task usage and automation/augmentation patterns from the first and second Anthropic Economic Index reports.
+
+- **Source**: Anthropic/EconomicIndex dataset on Hugging Face
+- **URL**: https://huggingface.co/datasets/Anthropic/EconomicIndex/tree/main/release_2025_03_27
+- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
+- **Files**:
+  - `automation_vs_augmentation_v1.csv`
+  - `automation_vs_augmentation_v2.csv`
+  - `task_pct_v1.csv`
+  - `task_pct_v2.csv`
+
+## External Data Sources
+
+We use external data to enrich Claude usage data with external economic and demographic sources.
+
+### ISO Country Codes
+
+**ISO 3166 Country Codes**
+
+International standard codes for representing countries and territories, used for mapping IP-based geolocation data to standardized country identifiers.
+
+- **Standard**: ISO 3166-1
+- **Source**: GeoNames geographical database
+- **URL**: https://download.geonames.org/export/dump/countryInfo.txt
+- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
+- **Attribution note**: Data in the data/intermediate and data/output folders have been processed and modified from original source; modifications to data in data/intermediate include extracting only tabular data, selecting a subset of columns, and renaming columns; modifications to data in data/output include transforming data to long format
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `geonames_countryInfo.txt` (raw GeoNames data in data/input/)
+  - `iso_country_codes.csv` (processed country codes in data/intermediate/)
+- **Key fields**:
+  - `iso_alpha_2`: Two-letter country code (e.g., "US", "GB", "FR")
+  - `iso_alpha_3`: Three-letter country code (e.g., "USA", "GBR", "FRA")
+  - `country_name`: Country name from GeoNames
+- **Usage**: Maps IP-based country identification to standardized ISO codes for consistent geographic aggregation
+
+### US State Codes
+
+**State FIPS Codes and USPS Abbreviations**
+
+Official state and territory codes including FIPS codes and two-letter USPS abbreviations for all U.S. states, territories, and the District of Columbia.
+
+- **Series**: State FIPS Codes
+- **Source**: U.S. Census Bureau, Geography Division
+- **URL**: https://www2.census.gov/geo/docs/reference/state.txt
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `census_state_codes.txt` (raw pipe-delimited text file in data/input/)
+- **Usage**: Maps state names to two-letter abbreviations (e.g., "California" → "CA")
+
+### Population Data
+
+### US State Population
+
+**State Characteristics Estimates - Age and Sex - Civilian Population**
+
+Annual estimates of the civilian population by single year of age, sex, race, and Hispanic origin for states and the District of Columbia.
+
+- **Series**: SC-EST2024-AGESEX-CIV
+- **Source**: U.S. Census Bureau, Population Division
+- **URL**: https://www2.census.gov/programs-surveys/popest/datasets/2020-2024/state/asrh/sc-est2024-agesex-civ.csv
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `sc-est2024-agesex-civ.csv` (raw Census data in data/input/)
+  - `working_age_pop_2024_us_state.csv` (processed data summed for ages 15-64 by state in data/intermediate/)
+- **Documentation**: https://www2.census.gov/programs-surveys/popest/technical-documentation/file-layouts/2020-2024/SC-EST2024-AGESEX-CIV.pdf
+
+### Country Population
+
+**Population ages 15-64, total**
+
+Total population between the ages 15 to 64. Population is based on the de facto definition of population, which counts all residents regardless of legal status or citizenship.
+
+- **Series**: SP.POP.1564.TO
+- **Source**: World Population Prospects, United Nations (UN), publisher: UN Population Division; Staff estimates, World Bank (WB)
+- **URL**: https://api.worldbank.org/v2/country/all/indicator/SP.POP.1564.TO?format=json&date=2024&per_page=1000
+- **License**: Creative Commons Attribution 4.0 License (https://creativecommons.org/licenses/by/4.0/)
+- **Attribution note**: Data in the data/intermediate folder have been processed and modified from original source; modifications to data in data/input include changing the file format; modifications to data/intermediate include adding Taiwan population data, removing non-country aggregates, removing invalid country codes, removing excluded countries, and renaming columns; modifications to data in data/output include transforming data to long format
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `working_age_pop_2024_country_raw.csv` (raw World Bank data in data/input/)
+  - `working_age_pop_2024_country.csv` (processed country-level data including Taiwan in data/intermediate/)
+
+### Taiwan Population
+
+**Population by single age**
+
+Population projections by single year of age for Taiwan (Republic of China). This data supplements the World Bank country data which excludes Taiwan.
+
+- **Series**: Population by single age (Medium variant, Total gender)
+- **Source**: National Development Council, Population Projections for the R.O.C (Taiwan)
+- **URL**: https://pop-proj.ndc.gov.tw/main_en/Custom_Detail_Statistics_Search.aspx?n=175&_Query=258170a1-1394-49fe-8d21-dc80562b72fb&page=1&PageSize=10&ToggleType=
+- **License**: Open Government Data License (Taiwan) (https://data.gov.tw/en/license)
+- **Update date**: 2025.06.17
+- **Download date**: September 2, 2025
+- **Reference year**: 2024
+- **Variable name in script**: `df_taiwan` (raw data), added to `df_working_age_pop_country`
+- **Output files**:
+  - `Population by single age _20250802235608.csv` (raw data in data/input/, pre-filtered to ages 15-64)
+  - Merged into `working_age_pop_2024_country.csv` (processed country-level data in data/intermediate/)
+
+## GDP Data
+
+### Country GDP
+
+**Gross Domestic Product, Current Prices (Billions of U.S. Dollars)**
+
+Total gross domestic product at current market prices for all countries and territories.
+
+- **Series**: NGDPD
+- **Source**: International Monetary Fund (IMF), World Economic Outlook Database
+- **URL**: https://www.imf.org/external/datamapper/api/v1/NGDPD
+- **License**: IMF Data Terms and Conditions (https://www.imf.org/en/About/copyright-and-terms#data)
+- **Reference year**: 2024
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `imf_gdp_raw_2024.json` (raw API response in data/input/)
+  - `gdp_2024_country.csv` (processed country GDP data in data/intermediate/)
+
+### US State GDP
+
+**SASUMMARY State Annual Summary Statistics: Personal Income, GDP, Consumer Spending, Price Indexes, and Employment**
+
+Gross domestic product by state in millions of current U.S. dollars.
+
+- **Series**: SASUMMARY (Gross Domestic Product by State)
+- **Source**: U.S. Bureau of Economic Analysis (BEA)
+- **URL**: https://apps.bea.gov/itable/?ReqID=70&step=1
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 2, 2025
+- **Reference year**: 2024
+- **Output files**:
+  - `bea_us_state_gdp_2024.csv` (raw data in data/input/, manually downloaded from BEA)
+  - `gdp_2024_us_state.csv` (processed state GDP data in data/intermediate/)
+- **Citation**: U.S. Bureau of Economic Analysis, "SASUMMARY State annual summary statistics: personal income, GDP, consumer spending, price indexes, and employment" (accessed September 2, 2025)
+
+## SOC and O*NET Data
+
+### O*NET Task Statements
+
+**O*NET Task Statements Dataset**
+
+Comprehensive database of task statements associated with occupations in the O*NET-SOC taxonomy, providing detailed work activities for each occupation.
+
+- **Database Version**: O*NET Database 20.1
+- **Source**: O*NET Resource Center, U.S. Department of Labor
+- **URL**: https://www.onetcenter.org/dl_files/database/db_20_1_excel/Task%20Statements.xlsx
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 2, 2025
+- **Output files**:
+  - `onet_task_statements_raw.xlsx` (raw Excel file in data/input/)
+  - `onet_task_statements.csv` (processed data with soc_major_group in data/intermediate/)
+- **Key fields**:
+  - `O*NET-SOC Code`: Full occupation code (e.g., "11-1011.00")
+  - `Title`: Occupation title
+  - `Task ID`: Unique task identifier
+  - `Task`: Description of work task
+  - `Task Type`: Core or Supplemental
+  - `soc_major_group`: First 2 digits of SOC code (e.g., "11" for Management)
+- **Notes**:
+  - SOC major group codes extracted from O*NET-SOC codes for aggregation
+  - Used to map Claude usage patterns to occupational categories
+
+### SOC Structure
+
+**Standard Occupational Classification (SOC) Structure**
+
+Hierarchical classification system for occupations, providing standardized occupation titles and codes.
+
+- **SOC Version**: 2019
+- **Source**: O*NET Resource Center (SOC taxonomy)
+- **URL**: https://www.onetcenter.org/taxonomy/2019/structure/?fmt=csv
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 2, 2025
+- **Variable name in script**: `df_soc` (SOC structure dataframe)
+- **Output files**:
+  - `soc_structure_raw.csv` (raw data in data/input/)
+  - `soc_structure.csv` (processed SOC structure in data/intermediate/)
+- **Key fields**:
+  - `Major Group`: SOC major group code (e.g., "11-0000")
+  - `Minor Group`: SOC minor group code
+  - `Broad Occupation`: Broad occupation code
+  - `Detailed Occupation`: Detailed occupation code
+  - `soc_major_group`: 2-digit major group code (e.g., "11")
+  - `SOC or O*NET-SOC 2019 Title`: Occupation group title
+- **Notes**:
+  - Provides hierarchical structure for occupational classification
+
+### Business Trends and Outlook Survey
+
+Core questions, National.
+
+- **Source**: U.S. Census Bureau
+- **URL**: https://www.census.gov/hfp/btos/downloads/National.xlsx
+- **License**: Public Domain (U.S. Government Work)
+- **Download date**: September 5, 2025
+- **Reference periods**: Ending in September 2023 and August 2025
+- **Input file**: `BTOS_National.xlsx`