Quantum Guitar

Trit: 0 (ERGODIC - coordinator between classical and quantum) Author: Bob Coecke (Quantum Brain Art Ltd / Oxford / Perimeter) arXiv: 2509.04526v1 [quant-ph] 3 Sep 2025

---

Core Principle

"A guitar string represents a wave, and by associating a qubit to each of its playable states we get a quantum wave."

Quantisation: Each playable state of a guitar string → qubit Control: Four limbs like a drummer (hands: guitar, feet: qubit) Transition: Smooth classical ↔ quantum sound continuum

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                        QUANTUM GUITAR                                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  GUITAR (hands)          QUBIT CONTROL (feet)                        │
│  ┌──────────────┐        ┌──────────────────────────────┐           │
│  │ Fishman MIDI │───────▶│ Moth Actias Quantum Synth    │           │
│  │ Pickup       │        │ ┌────────────────────────┐   │           │
│  └──────────────┘        │ │    Bloch Sphere        │   │           │
│                          │ │         |ψ⟩            │   │           │
│  Fernandes               │ │       /    \           │   │           │
│  Sustainer ──────────────│ │    |0⟩     |1⟩        │   │           │
│  (continuous)            │ └────────────────────────┘   │           │
│                          │                               │           │
│                          │ FOOT CONTROLLERS:             │           │
│                          │ • Boss EV-1-WL (X rotation)   │           │
│                          │ • Boss EV-1-WL (Z rotation)   │           │
│                          │ • Boss FS-6 (measurement)     │           │
│                          └──────────────────────────────┘           │
│                                                                      │
│  VOLUME PEDALS                                                       │
│  ┌────────────┐  ┌────────────┐                                     │
│  │ Classical  │  │  Quantum   │                                     │
│  │ FV500L/H   │  │  FV500L/H  │                                     │
│  └────────────┘  └────────────┘                                     │
│       ↓                ↓                                             │
│       └────────┬───────┘                                             │
│                ▼                                                     │
│         FINAL MIX                                                    │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Qubit Operations

Rotations (Foot Controllers)

Controller	Color	Rotation	Pauli Gate
Pedal 1	Orange	X-axis	σₓ
Pedal 2	Blue	Z-axis	σᵤ
(Internal)	Green	Y-axis	σᵧ

Measurement (Foot Switch)

• Boss FS-6 in momentary mode
• Z-measurement (computational basis)
• Suggestion: Add X-measurement primitive

ZX-Calculus Notation

From "Bell" composition [Abdyssagin & Coecke]:

     ┌───┐
 ────┤ Z ├────    Z-spider (phase)
     └───┘
     
     ┌───┐
 ────┤ X ├────    X-spider (phase)
     └───┘
     
     ╲   ╱
      ╲ ╱
       ╳         Hadamard edge
      ╱ ╲
     ╱   ╲

Musical ZX notation: Augmented score for quantum music

GF(3) Mapping

State	Trit	Sound Character
	0⟩	-1
	+⟩	0
	1⟩	+1

Conservation: Classical-Quantum-Classical transitions preserve Σ = 0

Implementation

DisCoPy Integration

from discopy import Ty, Box, Diagram
from discopy.quantum import qubit, Ket, Bra, H, Rx, Rz, Measure

# Guitar string as quantum type
string = Ty('string')
quantum_string = qubit

# Quantisation functor
def quantise_string(classical_note):
    """Map classical guitar note to qubit state."""
    # Frequency → phase
    phase = frequency_to_phase(classical_note)
    return Ket(0) >> Rx(phase)

# Foot controller rotation
def foot_rotation(axis, angle):
    if axis == 'X':
        return Rx(angle)
    elif axis == 'Z':
        return Rz(angle)
    else:
        return Ry(angle)

# Measurement
def measure_qubit():
    return Measure()

Moth Actias Interface

import mido

class ActiasController:
    """Control Moth Actias quantum synth via MIDI."""
    
    def __init__(self, port_name='Actias'):
        self.port = mido.open_output(port_name)
        self.qubit_state = [1, 0]  # |0⟩
    
    def rotate_x(self, angle):
        """X-rotation via expression pedal CC."""
        cc_value = int((angle / (2 * np.pi)) * 127)
        self.port.send(mido.Message('control_change', 
                                     control=1, value=cc_value))
    
    def rotate_z(self, angle):
        """Z-rotation via expression pedal CC."""
        cc_value = int((angle / (2 * np.pi)) * 127)
        self.port.send(mido.Message('control_change', 
                                     control=2, value=cc_value))
    
    def measure(self):
        """Trigger measurement via foot switch."""
        self.port.send(mido.Message('control_change', 
                                     control=64, value=127))

OSC Protocol (SuperCollider)

// Quantum Guitar SynthDef
SynthDef(\quantumString, { |freq=440, theta=0, phi=0, amp=0.5|
    var classical, quantum, mix;
    var prob0, prob1;
    
    // Classical component
    classical = Saw.ar(freq) * EnvGen.kr(Env.perc);
    
    // Qubit probabilities from Bloch sphere
    prob0 = cos(theta/2).squared;
    prob1 = sin(theta/2).squared;
    
    // Quantum superposition sound
    quantum = (SinOsc.ar(freq) * prob0) + 
              (SinOsc.ar(freq * 1.5) * prob1);
    
    // Phase modulation from phi
    quantum = quantum * cos(phi);
    
    // Mix via volume pedals
    mix = XFade2.ar(classical, quantum, \qMix.kr(0));
    
    Out.ar(0, mix * amp ! 2);
}).add;

Performances

Date	Venue	Configuration
2024	Edinburgh Science Festival	First Quantum Guitar
2024	Wacken Open Air	With Black Tish
2024	Lowlands Festival	Industrial Metal
2025	Vienna World Quantum Day	"Bell" with Grand Piano
2025	Berlin UdK Medienhaus	Quantum Guitar + Piano
2025	Merton College Oxford	+ Cathedral Organ
2026	St Giles' Edinburgh	"Quantum Universe" Symphony

Industrial Music Connection

"Industrial Music is the Musique Concrète 'of the people'."

Pioneers using guitar:

• Throbbing Gristle
• Cabaret Voltaire
• Einstürzende Neubauten
• Nine Inch Nails

Black Tish: Recording full album with Quantum Guitar

Tech Rider

quantum_guitar_rider:
  audio:
    - 2x XLR outputs (classical + quantum mix)
    - Quality PA with stage monitor
  visual:
    - Large screen (HDMI) for Actias Bloch sphere
  seating:
    - Armless semi-high chair (adjustable)
    - Foot access to pedal board
  refreshments:
    - "Good quality drinks"

Future Instruments

The hands-free quantum enhancement pattern extends to:

• Quantum Violin: Bow + feet
• Quantum Wind: Breath + feet
• Quantum Percussion: Sticks + additional feet

GF(3) Triad

Component	Trit	Role
zx-calculus	-1	Notation (classical diagrams)
quantum-guitar	0	Performance (superposition)
discopy	+1	Computation (quantum circuits)

Conservation: (-1) + (0) + (+1) = 0 ✓

References

1. Coecke, B. (2025). A Quantum Guitar. arXiv:2509.04526
2. Miranda, E.R. (2022). Quantum Computer Music. Springer
3. Coecke, B. (2023). Basic ZX-calculus. arXiv:2303.03163
4. Abdyssagin & Coecke (2025). Quantum concept music score

Demo

Video: https://www.youtube.com/watch?v=Pr4Wr8fdsL0

---

Skill Name: quantum-guitar Type: Quantum Music / Industrial / ZX-Calculus Trit: 0 (ERGODIC) GF(3): Classical ↔ Quantum transitions conserve

Non-Backtracking Geodesic Qualification

Condition: μ(n) ≠ 0 (Möbius squarefree)

This skill is qualified for non-backtracking geodesic traversal:

1. Prime Path: No state revisited in skill invocation chain
2. Möbius Filter: Composite paths (backtracking) cancel via μ-inversion
3. GF(3) Conservation: Trit sum ≡ 0 (mod 3) across skill triplets
4. Spectral Gap: Ramanujan bound λ₂ ≤ 2√(k-1) for k-regular expansion

Geodesic Invariant:
  ∀ path P: backtrack(P) = ∅ ⟹ μ(|P|) ≠ 0
  
Möbius Inversion:
  f(n) = Σ_{d|n} g(d) ⟹ g(n) = Σ_{d|n} μ(n/d) f(d)