tmc-pbp 0.1.0__tar.gz

tmc_pbp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tendai Mapungwana Chikake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tmc_pbp-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: tmc-pbp
+Version: 0.1.0
+Summary: Pseudo-Boolean Polynomial decomposition for data analysis
+Author-email: Tendai Mapungwana Chikake <tendaichikake@phystech.edu>
+License: MIT
+Project-URL: Repository, https://github.com/Tenfleques/tmc-pbp
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: bitarray
+Requires-Dist: scikit-learn
+Provides-Extra: viz
+Requires-Dist: matplotlib; extra == "viz"
+Provides-Extra: images
+Requires-Dist: opencv-python; extra == "images"
+Requires-Dist: Pillow; extra == "images"
+Provides-Extra: server
+Requires-Dist: flask; extra == "server"
+Provides-Extra: all
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
+Requires-Dist: Pillow; extra == "all"
+Requires-Dist: flask; extra == "all"
+Dynamic: license-file
+
+# tmc-pbp
+
+Pseudo-Boolean Polynomial (PBP) decomposition for data analysis. Training-free, deterministic algebraic decomposition of data matrices into multilinear polynomials over binary variables.
+
+## What it does
+
+Given a data matrix (rows = variables, columns = observations), PBP decomposes it into a multilinear polynomial where each term represents a specific combination of variables and its coefficient quantifies the interaction strength. The decomposition is:
+
+- **Training-free** -- no learned parameters, no optimization
+- **Deterministic** -- same input always produces the same output
+- **Fast** -- sub-millisecond per sample, 15K genes in 1.7 seconds
+- **Interpretable** -- each coefficient names a specific variable interaction
+- **Mathematically equivalent** to the Walsh-Hadamard spectral transform
+
+## Install
+
+```bash
+pip install tmc-pbp            # core (numpy, pandas, scipy, bitarray, scikit-learn)
+pip install "tmc-pbp[all]"     # plus matplotlib, OpenCV, Pillow and Flask for the viz, image and server modules
+```
+
+The package is imported as `pbp`. A pure-Python core is always available (`pbp.core`).
+The optional C backend (`pbp.core_c`) is shipped as source; compile it once in the installed
+package directory to enable it:
+
+```bash
+bash "$(python -c 'import pbp, os; print(os.path.dirname(pbp.__file__))')/build_pbp.sh"
+```
+
+## Quick start
+
+### Python API
+
+```python
+from pbp.core import create_pbp, pbp_vector
+
+import numpy as np
+matrix = np.array([
+    [5.2, 4.8, 3.1, 2.0],  # Gene A
+    [3.0, 3.5, 4.2, 4.8],  # Gene B
+    [1.0, 1.5, 2.8, 4.5],  # Gene C
+])
+
+# Full decomposition -> DataFrame with (y, coeffs, degree)
+pbp = create_pbp(matrix)
+
+# Fixed-length vector representation (2^m - 1 elements)
+vec = pbp_vector(matrix)
+```
+
+### CLI
+
+```bash
+pbp analyze matrix.csv --output results/   # Full decomposition + energy profile
+pbp vector matrix.csv                       # Fixed-length PBP vector
+pbp hasse matrix.csv --format dot           # Hasse diagram (Graphviz DOT)
+pbp info matrix.csv                         # Matrix stats
+pbp version                                 # Package version
+```
+
+### Web application
+
+```bash
+bash pbp/webapp/run.sh
+# Open http://localhost:8430
+```
+
+6-tab interface covering decomposition, epistasis, quorum sensing, sequential inference, structural comparison, and anomaly detection. 25 API endpoints. OpenAPI docs at `/docs`.
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `core.py` | Canonical PBP decomposition. `create_pbp()`, `pbp_vector()`, permutation/coefficient/variable matrices. Bitarray-based, no size limit. |
+| `inference.py` | PBP-DAG sequential inference. Autoregressive sampling through the Hasse diagram using PBP coefficients as Boltzmann energies. Greedy, stochastic, and beam search modes. |
+| `evaluate.py` | Evaluation metrics (Spearman, Kendall, NDE), bootstrap CIs, and baseline predictors (expression magnitude, PCA order, random). |
+| `pertpy_integration.py` | Pertpy/scverse-compatible functions: `pbp_distance()`, `pbp_score()`, `pbp_classify_type()`. Works with AnnData objects or plain numpy arrays. |
+| `cli.py` | Command-line interface. `pbp analyze\|vector\|hasse\|info\|version`. |
+| `pipeline.py` | High-level pipeline utilities. |
+| `server.py` | Legacy Flask server for DAG inference visualization. |
+| `webapp/` | FastAPI web application (25 endpoints, single-page frontend with Chart.js + D3.js). |
+
+## Applications
+
+### Genetic epistasis (Perturb-seq)
+PBP spectral profiles characterize interaction structure in combinatorial perturbation screens. Degree-wise energy separates interaction type from magnitude. Validated on 4 datasets from 4 labs (Norman, Wessels, Dixit, Joung).
+
+```python
+from pbp.pertpy_integration import pbp_score, pbp_classify_type
+scores = pbp_score(adata, groupby='perturbation', reference='control')
+```
+
+### Quorum sensing signal integration
+Decompose factorial QS experiments into main effects (a1, a2) and interaction (a12) per gene. Gate classification: AND, OR, antagonistic, mixed.
+
+### Sequential inference
+Predict activation order from expression matrices using greedy sampling through the PBP Hasse diagram.
+
+```python
+from pbp.inference import pbp_dag_sample
+result = pbp_dag_sample(pbp_df, m, mode='greedy')
+print(result['sequence'])  # Predicted activation order
+```
+
+### Anomaly detection
+PBP total energy flags samples with disrupted interaction structure. Interpretable: identifies which specific interactions are affected.
+
+### Structural comparison
+Pairwise Hasse diagram distance compares interaction architectures across samples, conditions, or organisms.
+
+## Key functions
+
+| Function | What it does |
+|----------|-------------|
+| `create_pbp(matrix)` | Full PBP decomposition -> DataFrame with monomial index, coefficient, degree |
+| `pbp_vector(matrix)` | Fixed-length vector (2^m - 1 coefficients) for machine learning |
+| `pbp_dag_sample(pbp, m)` | Greedy/stochastic/beam sequential inference through Hasse diagram |
+| `evaluate_sequence(pred, gt)` | Spearman rho, Kendall tau, top-k accuracy, NDE |
+| `pbp_distance(adata, groupby)` | Pairwise structural distance (Pertpy-compatible) |
+| `pbp_score(adata, groupby)` | Spectral profile + interaction fraction per group |
+| `pbp_classify_type(adata, groupby)` | Synergistic/antagonistic/additive classification |
+
+## Mathematical identity
+
+PBP decomposition is mathematically identical to:
+- **Walsh-Hadamard spectral transform** (Fourier analysis on {0,1}^m)
+- **Epistatic interaction coefficients** (Poelwijk et al. 2019)
+- **Multilinear extension** of pseudo-Boolean functions (Hammer & Rudeanu 1968, Boros & Hammer 2002)
+
+## Citation
+
+```bibtex
+@article{chikake2025compoptics,
+  author  = {Chikake, Tendai M. and Goldengorin, Boris I. and Pardalos, Panos M.},
+  title   = {Pseudo-Boolean Polynomial Approach to Solving Computer Vision Tasks},
+  journal = {Computer Optics},
+  volume  = {49},
+  number  = {6},
+  pages   = {1191--1201},
+  year    = {2025},
+  doi     = {10.18287/COJ1815},
+}
+```
+
+## License
+
+MIT

tmc_pbp-0.1.0/README.md

@@ -0,0 +1,147 @@
+# tmc-pbp
+
+Pseudo-Boolean Polynomial (PBP) decomposition for data analysis. Training-free, deterministic algebraic decomposition of data matrices into multilinear polynomials over binary variables.
+
+## What it does
+
+Given a data matrix (rows = variables, columns = observations), PBP decomposes it into a multilinear polynomial where each term represents a specific combination of variables and its coefficient quantifies the interaction strength. The decomposition is:
+
+- **Training-free** -- no learned parameters, no optimization
+- **Deterministic** -- same input always produces the same output
+- **Fast** -- sub-millisecond per sample, 15K genes in 1.7 seconds
+- **Interpretable** -- each coefficient names a specific variable interaction
+- **Mathematically equivalent** to the Walsh-Hadamard spectral transform
+
+## Install
+
+```bash
+pip install tmc-pbp            # core (numpy, pandas, scipy, bitarray, scikit-learn)
+pip install "tmc-pbp[all]"     # plus matplotlib, OpenCV, Pillow and Flask for the viz, image and server modules
+```
+
+The package is imported as `pbp`. A pure-Python core is always available (`pbp.core`).
+The optional C backend (`pbp.core_c`) is shipped as source; compile it once in the installed
+package directory to enable it:
+
+```bash
+bash "$(python -c 'import pbp, os; print(os.path.dirname(pbp.__file__))')/build_pbp.sh"
+```
+
+## Quick start
+
+### Python API
+
+```python
+from pbp.core import create_pbp, pbp_vector
+
+import numpy as np
+matrix = np.array([
+    [5.2, 4.8, 3.1, 2.0],  # Gene A
+    [3.0, 3.5, 4.2, 4.8],  # Gene B
+    [1.0, 1.5, 2.8, 4.5],  # Gene C
+])
+
+# Full decomposition -> DataFrame with (y, coeffs, degree)
+pbp = create_pbp(matrix)
+
+# Fixed-length vector representation (2^m - 1 elements)
+vec = pbp_vector(matrix)
+```
+
+### CLI
+
+```bash
+pbp analyze matrix.csv --output results/   # Full decomposition + energy profile
+pbp vector matrix.csv                       # Fixed-length PBP vector
+pbp hasse matrix.csv --format dot           # Hasse diagram (Graphviz DOT)
+pbp info matrix.csv                         # Matrix stats
+pbp version                                 # Package version
+```
+
+### Web application
+
+```bash
+bash pbp/webapp/run.sh
+# Open http://localhost:8430
+```
+
+6-tab interface covering decomposition, epistasis, quorum sensing, sequential inference, structural comparison, and anomaly detection. 25 API endpoints. OpenAPI docs at `/docs`.
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `core.py` | Canonical PBP decomposition. `create_pbp()`, `pbp_vector()`, permutation/coefficient/variable matrices. Bitarray-based, no size limit. |
+| `inference.py` | PBP-DAG sequential inference. Autoregressive sampling through the Hasse diagram using PBP coefficients as Boltzmann energies. Greedy, stochastic, and beam search modes. |
+| `evaluate.py` | Evaluation metrics (Spearman, Kendall, NDE), bootstrap CIs, and baseline predictors (expression magnitude, PCA order, random). |
+| `pertpy_integration.py` | Pertpy/scverse-compatible functions: `pbp_distance()`, `pbp_score()`, `pbp_classify_type()`. Works with AnnData objects or plain numpy arrays. |
+| `cli.py` | Command-line interface. `pbp analyze\|vector\|hasse\|info\|version`. |
+| `pipeline.py` | High-level pipeline utilities. |
+| `server.py` | Legacy Flask server for DAG inference visualization. |
+| `webapp/` | FastAPI web application (25 endpoints, single-page frontend with Chart.js + D3.js). |
+
+## Applications
+
+### Genetic epistasis (Perturb-seq)
+PBP spectral profiles characterize interaction structure in combinatorial perturbation screens. Degree-wise energy separates interaction type from magnitude. Validated on 4 datasets from 4 labs (Norman, Wessels, Dixit, Joung).
+
+```python
+from pbp.pertpy_integration import pbp_score, pbp_classify_type
+scores = pbp_score(adata, groupby='perturbation', reference='control')
+```
+
+### Quorum sensing signal integration
+Decompose factorial QS experiments into main effects (a1, a2) and interaction (a12) per gene. Gate classification: AND, OR, antagonistic, mixed.
+
+### Sequential inference
+Predict activation order from expression matrices using greedy sampling through the PBP Hasse diagram.
+
+```python
+from pbp.inference import pbp_dag_sample
+result = pbp_dag_sample(pbp_df, m, mode='greedy')
+print(result['sequence'])  # Predicted activation order
+```
+
+### Anomaly detection
+PBP total energy flags samples with disrupted interaction structure. Interpretable: identifies which specific interactions are affected.
+
+### Structural comparison
+Pairwise Hasse diagram distance compares interaction architectures across samples, conditions, or organisms.
+
+## Key functions
+
+| Function | What it does |
+|----------|-------------|
+| `create_pbp(matrix)` | Full PBP decomposition -> DataFrame with monomial index, coefficient, degree |
+| `pbp_vector(matrix)` | Fixed-length vector (2^m - 1 coefficients) for machine learning |
+| `pbp_dag_sample(pbp, m)` | Greedy/stochastic/beam sequential inference through Hasse diagram |
+| `evaluate_sequence(pred, gt)` | Spearman rho, Kendall tau, top-k accuracy, NDE |
+| `pbp_distance(adata, groupby)` | Pairwise structural distance (Pertpy-compatible) |
+| `pbp_score(adata, groupby)` | Spectral profile + interaction fraction per group |
+| `pbp_classify_type(adata, groupby)` | Synergistic/antagonistic/additive classification |
+
+## Mathematical identity
+
+PBP decomposition is mathematically identical to:
+- **Walsh-Hadamard spectral transform** (Fourier analysis on {0,1}^m)
+- **Epistatic interaction coefficients** (Poelwijk et al. 2019)
+- **Multilinear extension** of pseudo-Boolean functions (Hammer & Rudeanu 1968, Boros & Hammer 2002)
+
+## Citation
+
+```bibtex
+@article{chikake2025compoptics,
+  author  = {Chikake, Tendai M. and Goldengorin, Boris I. and Pardalos, Panos M.},
+  title   = {Pseudo-Boolean Polynomial Approach to Solving Computer Vision Tasks},
+  journal = {Computer Optics},
+  volume  = {49},
+  number  = {6},
+  pages   = {1191--1201},
+  year    = {2025},
+  doi     = {10.18287/COJ1815},
+}
+```
+
+## License
+
+MIT

tmc_pbp-0.1.0/__init__.py

@@ -0,0 +1,24 @@
+"""
+pbp-polynomials: Pseudo-Boolean Polynomial decomposition for data analysis.
+
+Training-free, deterministic algebraic decomposition of data matrices into
+multilinear polynomials over binary variables. Applications: genetic epistasis
+characterization, quorum sensing signal decomposition, sequential inference,
+anomaly detection.
+
+Usage:
+    from pbp.core import create_pbp, pbp_vector
+    from pbp.inference import pbp_dag_sample
+    from pbp.evaluate import evaluate_sequence
+    from pbp.pertpy_integration import pbp_distance, pbp_score, pbp_classify_type
+
+CLI:
+    pbp analyze matrix.csv --output results/
+    pbp vector matrix.csv
+    pbp hasse matrix.csv --output diagram.json
+"""
+
+__version__ = "0.1.0"
+__author__ = "Tendai Chikake"
+
+from pbp.core import create_pbp, pbp_vector

tmc_pbp-0.1.0/build_pbp.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Build PBP shared libraries (core + codec)
+# Usage: bash pbp/build_pbp.sh
+
+set -e
+cd "$(dirname "$0")"
+
+CC="${CC:-cc}"
+CFLAGS="-O2 -Wall -Wextra -std=c99 -fPIC"
+
+case "$(uname -s)" in
+    Darwin)
+        SOEXT="dylib"
+        SOFLAGS="-dynamiclib"
+        ;;
+    *)
+        SOEXT="so"
+        SOFLAGS="-shared"
+        ;;
+esac
+
+echo "Compiling pbp_core.c -> libpbp_core.${SOEXT}"
+$CC $CFLAGS $SOFLAGS -o "libpbp_core.${SOEXT}" pbp_core.c -lm
+echo "Done: pbp/libpbp_core.${SOEXT}"
+
+echo "Compiling pbp_codec.c -> libpbp_codec.${SOEXT}"
+$CC $CFLAGS $SOFLAGS -o "libpbp_codec.${SOEXT}" pbp_codec.c -lm
+echo "Done: pbp/libpbp_codec.${SOEXT}"

tmc_pbp-0.1.0/cli.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""
+pbp — Command-line interface for pseudo-Boolean polynomial analysis.
+
+Usage:
+    pbp analyze matrix.csv [--output DIR] [--format csv|json]
+    pbp vector matrix.csv [--output FILE]
+    pbp hasse matrix.csv [--output FILE] [--format json|dot]
+    pbp info matrix.csv
+    pbp version
+"""
+
+import argparse
+import sys
+import os
+import io
+import json
+import time
+
+import numpy as np
+import pandas as pd
+
+
+def _quiet_pbp(matrix, **kwargs):
+    """Run create_pbp without stdout noise."""
+    from pbp.core import create_pbp
+    old = sys.stdout
+    sys.stdout = io.StringIO()
+    try:
+        return create_pbp(matrix, **kwargs)
+    finally:
+        sys.stdout = old
+
+
+def _load_matrix(path):
+    """Load a matrix from CSV/TSV. Rows = variables, columns = conditions."""
+    if path.endswith('.tsv') or path.endswith('.txt'):
+        df = pd.read_csv(path, sep='\t')
+    else:
+        df = pd.read_csv(path)
+
+    # If first column is non-numeric (labels), use as index
+    if df.iloc[:, 0].dtype == object:
+        df = df.set_index(df.columns[0])
+
+    return df.values.astype(float), df.index.tolist(), df.columns.tolist()
+
+
+def cmd_analyze(args):
+    """Full PBP analysis: decomposition + spectral profile + summary."""
+    matrix, row_labels, col_labels = _load_matrix(args.input)
+    m, n = matrix.shape
+
+    print(f"Matrix: {m} variables x {n} conditions")
+    print(f"Variables: {row_labels[:5]}{'...' if m > 5 else ''}")
+
+    t0 = time.time()
+    pbp = _quiet_pbp(matrix)
+    elapsed = time.time() - t0
+
+    print(f"PBP computed in {elapsed*1000:.1f} ms")
+    print(f"  Monomials: {len(pbp)}")
+    print(f"  Max degree: {int(pbp['degree'].max())}")
+    print(f"  Non-zero coefficients: {(pbp['coeffs'] != 0).sum()}")
+
+    # Degree-wise energy
+    energy = pbp.groupby('degree')['coeffs'].apply(lambda x: (x**2).sum())
+    total_energy = energy.sum()
+    print(f"\n  Degree-wise energy:")
+    for d, e in energy.items():
+        pct = 100 * e / total_energy if total_energy > 0 else 0
+        print(f"    d={int(d)}: {e:.4f} ({pct:.1f}%)")
+
+    # PBP vector
+    from pbp.core import pbp_vector
+    vec = pbp_vector(matrix)
+    print(f"\n  PBP vector: {len(vec)} elements")
+
+    # Save output
+    outdir = args.output or '.'
+    os.makedirs(outdir, exist_ok=True)
+
+    if args.format == 'json':
+        result = {
+            'matrix_shape': [m, n],
+            'row_labels': row_labels,
+            'col_labels': col_labels,
+            'n_monomials': len(pbp),
+            'max_degree': int(pbp['degree'].max()),
+            'elapsed_ms': round(elapsed * 1000, 1),
+            'degree_energy': {int(k): round(float(v), 6) for k, v in energy.items()},
+            'total_energy': round(float(total_energy), 6),
+            'pbp_vector': vec.tolist(),
+        }
+        outpath = os.path.join(outdir, 'pbp_analysis.json')
+        with open(outpath, 'w') as f:
+            json.dump(result, f, indent=2)
+    else:
+        # Save decomposition
+        outpath = os.path.join(outdir, 'pbp_decomposition.csv')
+        pbp.to_csv(outpath, index=False)
+
+        # Save vector
+        vecpath = os.path.join(outdir, 'pbp_vector.csv')
+        pd.DataFrame({'index': range(len(vec)), 'coefficient': vec}).to_csv(vecpath, index=False)
+
+        # Save energy
+        epath = os.path.join(outdir, 'pbp_energy.csv')
+        energy_df = pd.DataFrame({
+            'degree': energy.index.astype(int),
+            'energy': energy.values,
+            'fraction': energy.values / total_energy if total_energy > 0 else 0,
+        })
+        energy_df.to_csv(epath, index=False)
+
+    print(f"\n  Output saved to {outdir}/")
+
+
+def cmd_vector(args):
+    """Compute and output the PBP vector (fixed-length representation)."""
+    matrix, row_labels, _ = _load_matrix(args.input)
+    from pbp.core import pbp_vector
+    vec = pbp_vector(matrix)
+
+    if args.output:
+        pd.DataFrame({'index': range(len(vec)), 'coefficient': vec}).to_csv(args.output, index=False)
+        print(f"PBP vector ({len(vec)} elements) saved to {args.output}")
+    else:
+        for i, v in enumerate(vec):
+            if v != 0:
+                print(f"  [{i}] = {v:.6f}")
+        print(f"\n  {len(vec)} elements, {(vec != 0).sum()} non-zero")
+
+
+def cmd_hasse(args):
+    """Export Hasse diagram structure."""
+    matrix, row_labels, _ = _load_matrix(args.input)
+    m = matrix.shape[0]
+
+    pbp = _quiet_pbp(matrix)
+
+    # Build Hasse structure
+    nodes = []
+    for _, row in pbp.iterrows():
+        y = int(row['y'])
+        d = int(row['degree'])
+        c = float(row['coeffs'])
+        bits = []
+        val = y
+        i = 0
+        while val:
+            if val & 1:
+                bits.append(i)
+            val >>= 1
+            i += 1
+        label = ','.join(str(b) for b in bits) if bits else '∅'
+        if row_labels and all(isinstance(r, str) for r in row_labels):
+            named = ','.join(row_labels[b] for b in bits) if bits else '∅'
+        else:
+            named = label
+        nodes.append({
+            'id': y, 'degree': d, 'coefficient': c,
+            'variables': bits, 'label': label, 'named': named,
+        })
+
+    # Build edges (subset relations between adjacent degrees)
+    edges = []
+    by_degree = {}
+    for node in nodes:
+        by_degree.setdefault(node['degree'], []).append(node)
+
+    max_d = max(by_degree.keys()) if by_degree else 0
+    for d in range(max_d):
+        for lo in by_degree.get(d, []):
+            for hi in by_degree.get(d + 1, []):
+                if (lo['id'] & hi['id']) == lo['id']:
+                    edges.append({'from': lo['id'], 'to': hi['id']})
+
+    result = {'nodes': nodes, 'edges': edges, 'm': m, 'labels': row_labels}
+
+    if args.format == 'dot':
+        # Graphviz DOT format
+        lines = ['digraph Hasse {', '  rankdir=TB;']
+        for node in nodes:
+            color = '#D55E00' if node['coefficient'] > 0 else '#0072B2'
+            lines.append(f'  n{node["id"]} [label="{node["named"]}\\n{node["coefficient"]:.2f}" '
+                        f'style=filled fillcolor="{color}40"];')
+        for edge in edges:
+            lines.append(f'  n{edge["from"]} -> n{edge["to"]};')
+        lines.append('}')
+        out = '\n'.join(lines)
+    else:
+        out = json.dumps(result, indent=2)
+
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(out)
+        print(f"Hasse diagram ({len(nodes)} nodes, {len(edges)} edges) saved to {args.output}")
+    else:
+        print(out)
+
+
+def cmd_info(args):
+    """Quick matrix info without full decomposition."""
+    matrix, row_labels, col_labels = _load_matrix(args.input)
+    m, n = matrix.shape
+    print(f"Matrix: {m} variables x {n} conditions")
+    print(f"Variables: {row_labels}")
+    print(f"Conditions: {col_labels}")
+    print(f"PBP vector length: {2**m - 1}")
+    print(f"Max monomials: {2**m}")
+    print(f"Value range: [{matrix.min():.4f}, {matrix.max():.4f}]")
+    print(f"Mean: {matrix.mean():.4f}, Std: {matrix.std():.4f}")
+    if m > 20:
+        print(f"WARNING: m={m} will produce {2**m:,} monomials. Consider reshaping.")
+
+
+def cmd_version(args):
+    from pbp import __version__
+    print(f"pbp-polynomials {__version__}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='pbp',
+        description='Pseudo-Boolean Polynomial analysis of data matrices',
+    )
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+    # analyze
+    p_analyze = subparsers.add_parser('analyze', help='Full PBP analysis')
+    p_analyze.add_argument('input', help='Input matrix (CSV/TSV)')
+    p_analyze.add_argument('--output', '-o', help='Output directory')
+    p_analyze.add_argument('--format', choices=['csv', 'json'], default='csv')
+    p_analyze.set_defaults(func=cmd_analyze)
+
+    # vector
+    p_vector = subparsers.add_parser('vector', help='Compute PBP vector')
+    p_vector.add_argument('input', help='Input matrix (CSV/TSV)')
+    p_vector.add_argument('--output', '-o', help='Output CSV file')
+    p_vector.set_defaults(func=cmd_vector)
+
+    # hasse
+    p_hasse = subparsers.add_parser('hasse', help='Export Hasse diagram')
+    p_hasse.add_argument('input', help='Input matrix (CSV/TSV)')
+    p_hasse.add_argument('--output', '-o', help='Output file')
+    p_hasse.add_argument('--format', choices=['json', 'dot'], default='json')
+    p_hasse.set_defaults(func=cmd_hasse)
+
+    # info
+    p_info = subparsers.add_parser('info', help='Matrix info')
+    p_info.add_argument('input', help='Input matrix (CSV/TSV)')
+    p_info.set_defaults(func=cmd_info)
+
+    # version
+    p_version = subparsers.add_parser('version', help='Show version')
+    p_version.set_defaults(func=cmd_version)
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == '__main__':
+    main()