Smithery is now a part of Arcade.dev! Read more in our announcement here
Category theory for compositional computing with string diagrams, quantum circuits, and QNLP...
Use Discopy when you need:
Sweet Spot: Research at the mathematics-computer science interface, QNLP experiments, compositional semantics modeling, and educational tools for category theory.
Not For: Production NLP systems (use spaCy/Transformers), large-scale quantum compilation (use Qiskit/Cirq), or standard ML pipelines (use PyTorch/scikit-learn).
Discopy treats computation as information flow through typed channels:
Text ā Parse ā Diagram ā Functor ā Tensor/Circuit ā Evaluate ā Result
Category (objects + morphisms)
ā
Monoidal (>> sequential, @ parallel)
ā
Symmetric (swap wires)
ā
Rigid (duals)
ā
Compact (cups/caps)
ā
Traced (feedback loops)
Each level adds capabilities while maintaining composition guarantees.
# Sequential composition (then)
f >> g # "f then g"
# Parallel composition (and)
f @ g # "f and g simultaneously"
# Dagger (adjoint/inverse)
f.dagger()
# Tensor product
f.tensor(g)
# Feedback
f.feedback()
# Basic installation
pip install discopy
# With quantum features
pip install discopy[quantum]
# With all backends
pip install discopy[pytorch,tensorflow,jax]
from discopy import Ty, Box
# Define types (objects)
x = Ty('X')
y = Ty('Y')
z = Ty('Z')
# Define operations (morphisms)
f = Box('f', x, y) # f: X ā Y
g = Box('g', y, z) # g: Y ā Z
# Sequential composition
diagram = f >> g # X ā Y ā Z
# Parallel composition
parallel = f @ g # XāY ā YāZ
# Visualize
diagram.draw()
from discopy.matrix import Functor
import numpy as np
# Define semantics
F = Functor(
ob={x: 2, y: 3, z: 4}, # Dimensions
ar={
f: np.random.rand(3, 2), # Y=3, X=2
g: np.random.rand(4, 3) # Z=4, Y=3
}
)
# Evaluate
result = F(diagram)
print(result.array.shape) # (4, 2)
from discopy.quantum.circuit import Circuit, gates
# Build circuit
circuit = (
gates.H @ Circuit.id(1) # Hadamard on qubit 0
>> gates.CNOT # CNOT on qubits 0,1
>> gates.Rx(0.5) @ gates.Ry(0.3) # Rotations
)
# Visualize
circuit.draw()
# Export to other frameworks
qiskit_circuit = circuit.to_qiskit()
DisCoPy follows a 7-level progression from simple pipelines to formally verified systems.
ā EXAMPLES-L1-L2.md - Basic >> pipelines
ā EXAMPLES-L1-L2.md - Parallel @ + evaluation
ā EXAMPLES-L3-L4.md - Diagram.swap() for routing
ā EXAMPLES-L3-L4.md - Cups, caps, quantum circuits
ā EXAMPLES-L5-L7.md - .trace() for state feedback
ā EXAMPLES-L5-L7.md - GPU acceleration, custom semantics
ā EXAMPLES-L5-L7.md - Proof-carrying code
ā USE-CASES.md - Complete use cases across all levels
# 1. Build diagram (syntax)
diagram = f >> g >> h
# 2. Define functor (semantics)
functor = Functor(ob={...}, ar={...})
# 3. Evaluate
result = functor(diagram)
# 1. Parse text
from discopy.grammar.pregroup import Diagram as Grammar
sentence = parse("Alice loves Bob")
# 2. Convert to quantum
from discopy.quantum.circuit import Functor as CircuitFunctor
to_circuit = CircuitFunctor(word_circuits, grammar_ops)
circuit = to_circuit(sentence)
# 3. Execute
result = circuit.eval()
class DomainFunctor(Functor):
def __init__(self, domain_mappings):
self.mappings = domain_mappings
def __call__(self, diagram):
# Custom interpretation logic
return self.interpret(diagram)
ā REFERENCE.md - Complete API lookup
ā PATTERNS.md - Design patterns and idioms
ā TROUBLESHOOTING.md - Common issues and solutions
ā INTEGRATION.md - Using Discopy with other libraries
ā Production NLP: Use spaCy, Transformers (Discopy is research-focused) ā Large Quantum Circuits: Use Qiskit, Cirq (better optimization) ā Standard Deep Learning: Use PyTorch, TensorFlow directly ā High-Performance Numerics: Use NumPy, SciPy (less overhead) ā Commercial Applications: Wait for hardware maturity (QNLP still experimental)
Discopy inverts traditional programming:
The categorical approach provides:
pip install discopy