gh-interactome - GitHub Author Interaction Network

Overview

Maps the interactome (interaction network) of GitHub contributors across discovered repos. Finds cobordisms - shared boundaries where different research communities meet.

┌─────────────────────────────────────────────────────────────────────────────┐
│                         INTERACTOME STRUCTURE                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   BlockScience ◄────── olynch ──────► ToposInstitute                        │
│        │                  │                  │                               │
│        ▼                  ▼                  ▼                               │
│     cadCAD         AlgebraicJulia        poly                               │
│        │                  │                  │                               │
│        └──── jpfairbanks ─┴── epatters ─────┘                               │
│                                                                              │
│   HoTT/Coq-HoTT ◄─── abooij ───► mortberg/cubicaltt                         │
│        │                                     │                               │
│        └────── mikeshulman ──────────────────┘                               │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Discovered Cobordisms

Cobordism 1: AlgebraicJulia ↔ Topos Institute ↔ BlockScience

Shared contributors:

• epatters (Evan Patterson) - Catlab.jl, ACSets.jl, Topos Institute
• olynch (Owen Lynch) - poly, ACSets.jl, Catlab.jl, Topos Institute
• jpfairbanks (James Fairbanks) - Catlab.jl, ACSets.jl, U Florida
• kris-brown - Catlab.jl, ACSets.jl, Topos Institute
• slibkind (Sophie Libkind) - Catlab.jl, Stanford/Topos

Bridge repos:

Cobordism 2: HoTT ↔ Cubical Type Theory

Shared contributors:

• abooij - HoTT/Coq-HoTT, mortberg/cubicaltt
• mikeshulman (Mike Shulman) - HoTT, real cohesion
• andrejbauer (Andrej Bauer) - HoTT, constructive math
• DanGrayson - HoTT, cubicaltt, Agda

Bridge insight: HoTT contributors often work on multiple proof assistants.

Cobordism 3: DisCoPy ↔ Oxford Quantum Group

Key contributors:

• toumix (1213 commits) - DisCoPy core
• giodefelice (354 commits) - DisCoPy
• y-richie-y (173 commits) - DisCoPy
• oxford-quantum-group - Organizational account

Bridge insight: QNLP (Quantum NLP) research connects quantum computing to linguistics via categorical semantics.

Cobordism 4: GFlowNets ↔ Mila (Bengio's Lab)

Key contributors:

• zdhNarsil (94 commits) - Awesome-GFlowNets curator
• bengioe (Emmanuel Bengio) - GFlowNet contributor
• Connection to Yoshua Bengio's lab at Mila

Bridge insight: GFlowNets for molecular design connects to chemistry/synthesis domains.

Author Profiles

Core AlgebraicJulia

Core HoTT

Core BlockScience

Core DisCoPy

Key Bridge Authors

Network Metrics

Centrality (Bridge Authors)

# Authors who connect multiple communities
BRIDGE_AUTHORS = {
    "olynch": ["ToposInstitute/poly", "AlgebraicJulia/Catlab.jl", "AlgebraicJulia/ACSets.jl"],
    "epatters": ["AlgebraicJulia/Catlab.jl", "AlgebraicJulia/ACSets.jl", "ToposInstitute/*"],
    "abooij": ["HoTT/Coq-HoTT", "mortberg/cubicaltt"],
    "jpfairbanks": ["AlgebraicJulia/Catlab.jl", "AlgebraicJulia/ACSets.jl"],
    "mikeshulman": ["HoTT/Coq-HoTT", "HoTT/book"],
}

Community Clusters

Cluster 1: Applied Category Theory
  - AlgebraicJulia (epatters, olynch, jpfairbanks, kris-brown)
  - Topos Institute (dspivak, olynch, epatters)
  - DisCoPy (toumix, giodefelice)

Cluster 2: Type Theory / Foundations
  - HoTT (Alizter, jdchristensen, mikeshulman)
  - Cubical (mortberg, simhu, coquand)
  - Rzk (fizruk)

Cluster 3: Complex Systems / Token Engineering
  - BlockScience (mzargham, JEJodesty)
  - cadCAD ecosystem

Cluster 4: Haskell Categorical
  - connections (cmk)
  - lattices (phadej)
  - haskerwaul (sellout)

Implementation

#!/usr/bin/env python3
"""
GitHub Interactome: Map author interactions across repos.
"""
# /// script
# requires-python = ">=3.11"
# dependencies = ["rich", "networkx"]
# ///

import subprocess
import json
from collections import defaultdict

def get_contributors(repo: str) -> list[dict]:
    """Get contributors for a repo via gh CLI."""
    cmd = f"gh api repos/{repo}/contributors --jq '.[] | {{login, contributions}}'"
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    contributors = []
    for line in result.stdout.strip().split('\n'):
        if line:
            contributors.append(json.loads(line))
    return contributors

def build_interactome(repos: list[str]) -> dict:
    """Build author-repo bipartite graph."""
    author_repos = defaultdict(list)
    repo_authors = defaultdict(list)
    
    for repo in repos:
        contributors = get_contributors(repo)
        for c in contributors:
            author = c['login']
            author_repos[author].append({
                'repo': repo,
                'contributions': c['contributions']
            })
            repo_authors[repo].append(author)
    
    return {
        'author_repos': dict(author_repos),
        'repo_authors': dict(repo_authors),
    }

def find_bridges(interactome: dict, min_repos: int = 2) -> list[dict]:
    """Find authors who contribute to multiple repos (bridges)."""
    bridges = []
    for author, repos in interactome['author_repos'].items():
        if len(repos) >= min_repos:
            bridges.append({
                'author': author,
                'repos': [r['repo'] for r in repos],
                'total_contributions': sum(r['contributions'] for r in repos),
            })
    return sorted(bridges, key=lambda x: len(x['repos']), reverse=True)

def find_cobordisms(interactome: dict) -> list[dict]:
    """Find shared boundaries between repo communities."""
    cobordisms = []
    repos = list(interactome['repo_authors'].keys())
    
    for i, repo_a in enumerate(repos):
        for repo_b in repos[i+1:]:
            shared = set(interactome['repo_authors'][repo_a]) & \
                     set(interactome['repo_authors'][repo_b])
            if shared:
                cobordisms.append({
                    'repos': (repo_a, repo_b),
                    'shared_authors': list(shared),
                    'strength': len(shared),
                })
    
    return sorted(cobordisms, key=lambda x: x['strength'], reverse=True)

Justfile Recipes

# Build interactome
gh-interactome-build:
    @echo "🕸️ Building GitHub Interactome..."
    python3 interactome.py build

# Find bridge authors
gh-interactome-bridges:
    @echo "🌉 Finding bridge authors..."
    python3 interactome.py bridges

# Find cobordisms
gh-interactome-cobordisms:
    @echo "🔗 Finding cobordisms..."
    python3 interactome.py cobordisms

# Author lookup
gh-interactome-author login:
    @echo "👤 Author: {{login}}"
    gh api users/{{login}} --jq '{name, company, blog, bio}'
    gh api users/{{login}}/repos --jq '.[].name' | head -10

Key Cobordism: AlgebraicJulia → BlockScience

The compositional systems approach connects:

┌─────────────────────────────────────────────────────────────────────────────┐
│                    COMPOSITIONAL SYSTEMS COBORDISM                           │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   UC Riverside ──── John Baez ────► AlgebraicJulia ◄─── Topos Institute     │
│       │                │                   │                  │              │
│       │                ▼                   ▼                  ▼              │
│       │         Stock & Flow        Catlab.jl, ACSets      poly            │
│       │         Diagrams                   │               (Spivak)         │
│       │                │                   │                  │              │
│       └────────────────┼───────────────────┼──────────────────┘              │
│                        │                   │                                 │
│                        ▼                   ▼                                 │
│                 Compositional      AlgebraicPetri.jl                        │
│                   Epidemiology     AlgebraicDynamics.jl                     │
│                        │                   │                                 │
│                        └─────────┬─────────┘                                │
│                                  │                                          │
│                                  ▼                                          │
│                           BlockScience                                      │
│                           (cadCAD, Token Engineering)                       │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Key Papers Bridging Communities

1. "Compositional Scientific Computing with Catlab and SemanticModels" (2020)

- Halter, Patterson, Baas, Fairbanks - ArXiv: 2005.04831

1. "Compositional Modeling with Stock and Flow Diagrams" (2022)

- Baez, Li, Libkind, Osgood - ArXiv: 2205.08373 (COVID epidemiology application)

1. "AlgebraicRL.jl: Compositional Reinforcement Learning"

- Uses Catlab.jl for MDP composition

Shared Methodology

Bridge Authors

Conceptual Bridge: Both communities use category theory for compositional modeling of complex systems - AlgebraicJulia in scientific computing, BlockScience in cryptoeconomics/token engineering.

See Also

• gh-skill-explorer - Discovery skill that feeds into this
• galois-connections - Adjunctions between domains
• acsets-algebraic-databases - ACSets patterns
• discopy - String diagrams

End-of-Skill Interface

r2con Speaker Resources

Target organizations for interactome mapping:

Commands

# Build interactome for discovered repos
just gh-interactome build

# Find bridge authors
just gh-interactome bridges

# Find cobordisms between communities
just gh-interactome cobordisms

# Show author profile
just gh-interactome author olynch

# Visualize network
just gh-interactome viz

# NEW: Map r2con speaker orgs
just gh-interactome orgs radareorg rizinorg frida

SDF Interleaving

This skill connects to Software Design for Flexibility (Hanson & Sussman, 2021):

Primary Chapter: 3. Variations on an Arithmetic Theme

Concepts: generic arithmetic, coercion, symbolic, numeric

GF(3) Balanced Triad

gh-interactome (−) + SDF.Ch3 (○) + [balancer] (+) = 0

Skill Trit: -1 (MINUS - verification)

Secondary Chapters

• Ch4: Pattern Matching
• Ch6: Layering
• Ch1: Flexibility through Abstraction

Connection Pattern

Generic arithmetic crosses type boundaries. This skill handles heterogeneous data.