Category theory has been a topic that has interested me in the periphery.

Ever since picking up that C programming language book in the Uppsala University library and then exploring functional languages - Haskell, Clojure, others - and discovering the elusive monad, category theory has been a topic that has interested me in the periphery. I keep coming back to the topic on conversations with certain minded friends. Another language on top of the language? What else is in that box?

It isnt a box. It is deep rabbit hole - abstract, sprawling. A mine of connected rooms, spaces, tunnels.

A thought started to brew after Christmas this year - how can i apply category theory to quantum computing and what might come out of that?.

This easter holiday I got the Shim codebase to a state where I think its time to start sharing. This journal entry describes the result of the work.

This entry is a an overview of the code examples (shorter bits of demonstrative code that use the Shim library) that I have implemented. It is technical. It is assumed that this is perhaps not the first time the reader has heard of category theory. The reading will benefit greatly from basic prior knowledge of concepts like monads, functors (ofc how can we otherwise grok monads), categories. Basic knowledge of quantum computing is needed but I set the level of the text to not assume deep prior expertise.

What im hoping is that for someone active in category theory research, ML, or quantum computing can read this post and understand why I started writing Shim and see its value as a research tool. Please do contact me should you find this interesting and if any inaccuracies (I know quite a few in the code already) exist. Im happy to collaborate and discuss.

It may be the case that reading the below examples in reverse order suites you better. That entirely depends on your background.

Shim is a Rust library (https://github.com/erikkallman/shim, distributed under the MIT license) that provides a mathematical foundation for quantum machine learning using category theory. It aims to describe quantum computation and machine learning through categorical structures, enabling composition of quantum operations and data transformations.

In the repo there are three larger illustrative examples that showcase its usage. This is just a highlight of some of the categorical concepts used in Shim. For a full read, clone the git repo and run the examples that come with extensive documentation.

This entry will show how quantum neural networks can be implemented using category theoretical structures. In particular it demonstrates how higher category theory—particularly bicategories, adjunctions, and 2-morphisms—provides a interesting framework for quantum machine learning.

Shim represents quantum machine learning as a bicategorical structure with three levels:

• Objects (0-cells): Qubit systems (representing the quantum state space)
• Morphisms (1-cells): Quantum circuits and transformations
• 2-morphisms: Parameter updates and gradient transformations

This hierarchical structure isn't just mathematical abstraction—it provides a formal language for expressing how quantum neural networks learn and evolve. The bicategory serves as the mathematical box (for lack of a better word) in which our quantum neural network exists. The network itself is structured as an instance of HigherCategoricalQuantumNN, which organizes quantum operations into composable units.

In the sections below, the categorical side of the demo are described as this could provide a potentially novel perspective for those active in either related research areas (quantum computing and/or machine learning).

Shim represents quantum neural network layers as adjunctions. In category theory, an adjunction is a pair of functors with special properties that ensure information flows properly in both directions. In quantum machine learning, this naturally maps to:

• Forward pass: Transforming input quantum states to output states
• Backward pass: Propagating gradients backward for parameter updates

The function build_variational_layer illustrates this concept:

fn build_variational_layer(qubit_count: usize, name: &str, init_param: f64) -> QuantumNeuralLayer {
    // Build the forward circuit
    let mut forward_builder = CircuitBuilder::new(qubit_count);
 
    // Add parameterized rotation gates
    for q in 0..qubit_count {
        forward_builder.rx(q, init_param).unwrap();
        forward_builder.ry(q, init_param).unwrap();
    }
 
    // Add entanglement
    if qubit_count > 1 {
        forward_builder.cnot(0, 1).unwrap();
    }
 
    // Build the backward circuit (conceptually for gradient computation)
    let mut backward_builder = CircuitBuilder::new(qubit_count);
 
    // ... backward circuit construction ...
 
    // Create the layer as an adjunction
    QuantumNeuralLayer {
        forward: forward_builder.build(),
        backward: backward_builder.build(),
        name: name.to_string(),
        parameters,
    }
}

This approach ensures that each layer satisfies the “triangle identities” of adjunctions, which the code verifies:

let verification = layer.verify_triangle_identities(&bicategory);
println!("First layer satisfies triangle identities: {}", verification);

The verification of these identities isn't just a mathematical curiosity—it ensures that the information flow through the quantum neural network during training is coherent and well-defined.

Shim represts parameter updates as 2-morphisms. In traditional neural networks, parameter updates are typically represented as simple numeric changes. In Shim, they are mathematical objects that can be composed and transformed.

Here's how parameter updates are represented:

fn create_parameter_update(
    circuit: &QuantumCircuit,
    param_name: &str,
    update_value: f64
) -> CircuitTransformation {
    let mut parameter_changes = HashMap::new();
    parameter_changes.insert(param_name.to_string(), update_value);
 
    CircuitTransformation {
        source: circuit.clone(),
        target: circuit.clone(),  // Would be different in a real implementation
        description: format!("Parameter update for {}", param_name),
        parameter_changes,
    }
}

Each update is a CircuitTransformation with source and target circuits, allowing us to think of parameter updates as transitions between quantum circuits. This representation enables compositional operations.

In Shim, backpropagation emerges as vertical composition of 2-morphisms. When we compose update transformations vertically, we're effectively passing gradient information backward through the network:

// Vertically compose the gradients (representing backpropagation)
let composed_gradient = bicategory.vertical_compose(&layer2_gradient, &layer1_gradient).unwrap();

This vertical composition represents the chain rule of calculus in a categorical form. The bicategorical structure handles the propagation of gradient information through the network.

Shim also provides horizontal composition for representing parallel or concurrent updates:

// Create two parallel gradients
let parallel_grad1 = create_parameter_update(&qnn.layers[0].forward, "parallel_rx0", 0.01);
let parallel_grad2 = create_parameter_update(&qnn.layers[1].forward, "parallel_rx0", 0.02);
 
// Horizontally compose them (happens in parallel)
let horizontal_composed = bicategory.horizontal_compose(&parallel_grad1, &parallel_grad2).unwrap();

This operation represents independent updates occurring in parallel, which is particularly useful for quantum systems where certain subsystems might evolve independently.

(Here be minor dragons - more speculative stuff.)

The framework introduces the concept of whiskers for propagating gradients through specific layers:

// Create a gradient for the first layer
let grad1 = create_parameter_update(&qnn.layers[0].forward, "grad_rx0", 0.03);
 
// Add a right whisker (propagate through the second layer)
let whisker = bicategory.right_whisker(&grad1, &qnn.layers[1].forward).unwrap();

Whiskers represent how changes in one part of the network affect the whole system. This operation is useful for modular update strategies and understanding how gradients flow through quantum circuits.

Moving beyond our exploration of quantum neural networks, this chapter examines how Shim provides formal verification for categorical structures in quantum computation. The categorical framework expresses quantum operations and their compositions, ensuring that quantum algorithms maintain algebraic properties.

The code example demonstrates Shim's verification capabilities in how it applies mathematical laws to quantum computing abstractions.

Shim implements categories - collections of objects and morphisms with composition operations that satisfy identity and associativity laws:

// Create a category
let finset = FinSet;
println!("\nCategory being tested: FinSet");
println!("FinSet is the category of finite sets and functions between them.");
println!("In quantum computing, this models classical data transformations.");
 
// Create some test objects
let set_a = FiniteSet::range(1, 5);  // {1, 2, 3, 4}
let set_b = FiniteSet::range(10, 15); // {10, 11, 12, 13, 14}
// ...
 
// Verify category laws
let category_laws_hold = verify_category_laws(&finset, &test_objects, &test_morphisms);

The verification confirms two essential properties:

• Identity Law: For any morphism f: A → B, id_B ∘ f = f = f ∘ id_A
• Associativity Law: For morphisms f, g, h, we have (h ∘ g) ∘ f = h ∘ (g ∘ f)

These more “basic” properties ensure that quantum operations can be composed reliably, with the identity operation (doing nothing) behaving as expected and sequential operations grouping consistently regardless of evaluation order.

Quantum computation frequently involves tensor products of states and operations. Shim models these through monoidal categories, which add tensor products and unit objects with appropriate laws:

// Verify monoidal laws
let monoidal_laws_hold = verify_monoidal_laws(&finset, &test_objects);

The verification checks these key properties:

• Unit Laws: The unit object combines with any object to yield that object again
• Associativity: Different ways of associating tensor products yield isomorphic results
• Triangle and Pentagon Identities: Coherence conditions ensuring consistent behavior

For quantum computing, these laws ensure that multiple qubits can be combined consistently, with operations on composite systems working predictably regardless of how the systems are grouped.

Quantum algorithms often require exchanging qubits, which Shim models through symmetric monoidal categories:

// Verify symmetric monoidal laws
let symmetric_laws_hold = verify_symmetric_monoidal_laws(&finset, &test_objects);
 
// Verify naturality of braiding
let braiding_naturality_holds = verify_braiding_naturality(&finset, &test_objects, &test_morphisms);

These verifications ensure:

• Symmetry: The braiding operation (qubit swap) is its own inverse
• Hexagon Identities: Braiding interacts correctly with associativity
• Naturality: Braiding commutes with other operations

In quantum circuits, these properties guarantee that SWAP gates behave predictably and consistently with other quantum gates, allowing flexible qubit routing without affecting computational outcomes.

Functors map between categories while preserving their structure. Shim implements and verifies functor laws:

let power_set_functor = PowerSetFunctor;
 
// 1. F preserves identity
let id_a = finset.identity(&set_a);
let f_id_a = power_set_functor.map_morphism(&finset, &finset, &id_a);
let id_f_a = finset.identity(&power_set_functor.map_object(&finset, &finset, &set_a));
 
println!("F preserves identity: {}", f_id_a == id_f_a);
 
// 2. F preserves composition
// ... (code that verifies composition preservation)

The functor laws ensure:

• Identity Preservation: F(id_A) = id_F(A)
• Composition Preservation: F(g ∘ f) = F(g) ∘ F(f)

For quantum computing, functors provide ways to transform quantum protocols while preserving their structural properties, enabling systematic derivation of related quantum algorithms.

Quantum measurement introduces probabilistic effects into computation. Shim models these effects using monads:

let list_monad = ListMonad;
 
// 1. Left identity: μ ∘ η_T = id_T
let eta_t_a = list_monad.unit(&finset, &set_a);
let mu_a = list_monad.join(&finset, &set_a);
 
if let Some(mu_eta_t_a) = finset.compose(&eta_t_a, &mu_a) {
    let id_t_a = finset.identity(&list_monad.map_object(&finset, &finset, &set_a));
    let left_identity_holds = mu_eta_t_a == id_t_a;
    println!("Left identity (μ ∘ η_T = id_T): {}", left_identity_holds);
}

The monad laws verified include:

• Left Identity: μ ∘ η_T = id_T
• Right Identity: μ ∘ T(η) = id_T
• Associativity: μ ∘ μ_T = μ ∘ T(μ)

In quantum computing, monads can represent state preparation (unit), measurement (join), and probabilistic computations, providing a formal framework for reasoning about quantum effects.

The categorical verification in Shim offers several practical benefits for quantum programming:

• Error Detection: Violations of categorical laws could indicate implementation bugs or inconsistencies
• Correctness: Verified categorical structures ensure quantum operations behave as mathematically expected
• Compositional Reasoning: Category theory enables reasoning about complex quantum algorithms through their compositional structure
• Protocol Verification: Categorical laws provide a basis for verifying quantum communication and cryptographic protocols

The example demonstrates how to use these verification tools:

// Testing for violations and diagnosing issues
if !category_laws_hold {
    println!("POTENTIAL FAILURE REASONS:");
    println!("- Identity morphisms might not be properly implemented");
    println!("- Composition might not be preserving associativity");
    println!("- The category structure might be inconsistent");
}

This helps quantum algorithm developers identify and fix structural issues in their implementations using category theory as a toolset for formal verification.

The categorical verification framework complements the quantum neural network architecture we explored earlier. While QNNs rely on adjunctions and 2-morphisms, these structures themselves depend on the fundamental categorical properties verified in this example.

The integration spans basic quantum operations and complex learning systems:

• Verified Base Categories: Ensure quantum operations satisfy basic compositional properties
• Monoidal Structure: Enables correct handling of multi-qubit systems in QNNs
• Functors: Allow systematic transformations of quantum learning algorithms
• Monadic Effects: Provide formal handling of measurement in quantum learning

This final chapter explores how Shim implements a complete quantum machine learning pipeline using categorical principles. The code can be used as a base for experimenting with different quantum architectures under categorical formalism.

The framework is organized into three interconnected components:

• Dataset parameters: Parametrization of synthetic data
• Quantum model parameters: Quantum resources and encoding strategies
• Circuit design parameters: Architectural patterns for quantum operations

// Dataset parameters
struct DatasetParams {
    n_samples_per_class: usize,  // Number of samples per class
    n_classes: usize,            // Number of classes to generate
    n_rotations: f64,            // Number of spiral rotations
    noise_level: f64,            // Amount of noise to add (0.0-1.0)
}
 
// Quantum model parameters
struct QuantumModelParams {
    qubit_count: usize,              // Number of qubits in the circuit
    num_var_layers: usize,           // Number of variational layers
    encoding_strategy: EncodingStrategy,  // Strategy for encoding classical data
    batch_size: usize,               // Number of samples to process in batch demo
}
 
// Circuit design parameters
struct CircuitDesignParams {
    use_cyclic_entanglement: bool,   // Whether to add cycle connection between last and first qubit
    use_non_local_gates: bool,       // Whether to add non-adjacent connections
    gate_pattern: GatePattern,       // Pattern of gates to use in variational layers
}

Four main categories are used in the demo:

• DataCategory: For classical data and transformations
• CircuitCategory: For quantum circuits and their compositions
• ModelCategory: For quantum machine learning models
• PredictionCategory: For measurement outcomes and predictions

// Create category instances
let data_category = DataCategory;
let circuit_category = CircuitCategory;
let model_category = ModelCategory;
let prediction_category = PredictionCategory;

These categories are connected by functors that preserve their structures:

// DataToCircuit functor
let data_to_circuit = DataToCircuitFunctor::new(qubit_count, encoding_strategy.clone());
 
// CircuitToModel functor
let circuit_to_model = CircuitToModelFunctor::new(2, decoding_strategy.clone());

The functors formalize how classical data is encoded into quantum states and how quantum measurements are decoded into predictions.

Natural transformations represent the interfaces between different categories. Two key transformations in the framework are:

// Create natural transformations
let state_prep = StatePreparationTransformation::new(encoding_strategy);
let model_prediction = ModelPredictionTransformation::new(decoding_strategy.clone());

The state preparation transformation formalizes how classical data is encoded into quantum states, while the model prediction transformation formalizes how quantum measurements are interpreted as predictions. The implementation of these transformations ensures that they interact consistently with the underlying categorical structures.

The framework provides a flexible approach to constructing parameterized quantum circuits. The circuit consists of interleaved rotation and entanglement layers:

fn build_variational_circuit(
    quantum_params: &QuantumModelParams,
    circuit_params: &CircuitDesignParams
) -> QuantumCircuit {
    let qubit_count = quantum_params.qubit_count;
    let num_layers = quantum_params.num_var_layers;
 
    let mut builder = CircuitBuilder::new(qubit_count);
 
    // Initial Hadamard layer
    for q in 0..qubit_count {
        builder.h(q).unwrap();
    }
 
    // Build variational layers
    for layer in 0..num_layers {
        // Parameterized rotation gates
        add_rotation_gates(&mut builder, layer, qubit_count, &circuit_params.gate_pattern);
 
        // Entanglement layer
        add_entanglement_gates(
            &mut builder,
            layer,
            qubit_count,
            circuit_params.use_cyclic_entanglement,
            circuit_params.use_non_local_gates
        );
    }
 
    builder.build()
}

The circuit construction supports different rotation gate patterns:

fn add_rotation_gates(
    builder: &mut CircuitBuilder,
    layer: usize,
    qubit_count: usize,
    gate_pattern: &GatePattern
) {
    // Generate angles that are deterministic but different for each qubit and layer
    let base_angles = [PI/4.0, PI/3.0, PI/5.0, PI/7.0, PI/11.0, PI/13.0, PI/17.0, PI/19.0];
 
    match gate_pattern {
        GatePattern::RyRz => {
            for q in 0..qubit_count {
                let angle_idx = (q + layer) % base_angles.len();
                let angle = base_angles[angle_idx];
                // Ry gate
                builder.ry(q, angle).unwrap();
                // Rz gate with a slightly different angle
                builder.rz(q, angle / (layer as f64 + 2.0)).unwrap();
            }
        },
        // Other patterns omitted for brevity
    }
}

It also supports different entanglement patterns:

fn add_entanglement_gates(
    builder: &mut CircuitBuilder,
    layer: usize,
    qubit_count: usize,
    use_cyclic: bool,
    use_non_local: bool
) {
    // Linear nearest-neighbor entanglement
    for q in 0..qubit_count-1 {
        builder.cnot(q, q+1).unwrap();
    }
 
    // Optional: Add cycle connection
    if use_cyclic && qubit_count > 2 {
        builder.cnot(qubit_count-1, 0).unwrap();
    }
 
    // Optional: Add non-local connections based on layer
    if use_non_local && qubit_count > 3 {
        // Different pattern for each layer to create more complex entanglement
        match layer % 3 {
            0 => {
                // Connect even qubits to odd qubits
                for q in 0..qubit_count/2 {
                    if 2*q+1 < qubit_count {
                        builder.cnot(2*q, 2*q+1).unwrap();
                    }
                }
            },
            // Other patterns omitted for brevity
        }
    }
}

These circuit construction functions demonstrate how the framework can systematically generate and experiment with different quantum ansatz architectures.

A critical aspect of the framework is verifying that the implementation satisfies the categorical laws:

fn verify_category_laws(
    circuit_category: &CircuitCategory,
    data_category: &DataCategory,
    variational_circuit: &QuantumCircuit,
    data_to_circuit: &DataToCircuitFunctor,
    qubit_count: usize
) {
    println!("Validating categorical structure...");
 
    // Verify identity law for CircuitCategory
    let identity_circuit = circuit_category.identity(&qubit_count);
    let composed_with_id = circuit_category.compose(&identity_circuit, variational_circuit).unwrap();
    assert_eq!(composed_with_id.qubit_count, variational_circuit.qubit_count);
    assert_eq!(composed_with_id.gate_count(), variational_circuit.gate_count());
    println!("Identity law verified for CircuitCategory");
 
    // Verify functoriality of data_to_circuit
    let data_obj = 2; // 2D input data
    let circuit_obj = data_to_circuit.map_object(data_category, circuit_category, &data_obj);
    assert_eq!(circuit_obj, qubit_count);
    println!("Functoriality verified for DataToCircuitFunctor");
}

This verification ensures that the categorical structure is properly maintained for the mathematical consistency of the quantum machine learning pipeline.

The framework includes a complete inference pipeline for evaluating the quantum model on test data:

fn run_inference_demo(
    dataset: &TabularDataset,
    variational_circuit: &QuantumCircuit,
    prediction_circuit: &CircuitPredictionTransformation,
    batch_size: usize,
    qubit_count: usize
) -> f64 {
    println!("\nRunning inference on quantum model...");
 
    // Create a small batch for inference demonstration
    let batch_indices = (0..batch_size).collect::<Vec<_>>();
    let (batch_x, batch_y) = dataset.get_batch(&batch_indices).unwrap();
 
    println!("Processing batch of {} samples through quantum pipeline...", batch_size);
    let start_time = Instant::now();
 
    // Process each sample through the quantum pipeline
    let mut correct_predictions = 0;
    for (i, sample) in batch_x.iter().enumerate() {
        // Create initial quantum state
        let initial_state = StateVector::zero_state(qubit_count);
 
        // Prepare the input state using angle encoding
        let mut state_prep_circuit = CircuitBuilder::new(qubit_count);
 
        // Encode features into quantum state
        state_prep_circuit.ry(0, sample[0] * PI).unwrap();
        state_prep_circuit.ry(1, sample[1] * PI).unwrap();
 
        // Apply additional encoding across remaining qubits
        // ...code omitted for brevity...
 
        let prepared_state = state_prep_circuit.build().apply(&initial_state).unwrap();
 
        // Apply the variational circuit
        let output_state = variational_circuit.apply(&prepared_state).unwrap();
 
        // Get prediction
        let prediction = prediction_circuit.apply(&output_state).unwrap();
 
        // Check if prediction is correct (argmax)
        let pred_class = if prediction[0] > prediction[1] { 0 } else { 1 };
        let true_class = if batch_y[i][0] > batch_y[i][1] { 0 } else { 1 };
 
        if pred_class == true_class {
            correct_predictions += 1;
        }
    }
 
    let elapsed = start_time.elapsed();
    let accuracy = (correct_predictions as f64) / (batch_size as f64);
 
    println!("\nProcessed batch in {:.2?}", elapsed);
    println!("Accuracy on batch: {:.1}% ({}/{} correct)",
        accuracy * 100.0, correct_predictions, batch_size);
 
    accuracy
}

This inference pipeline processes classical data through the entire quantum machine learning workflow, from data encoding to prediction.

The code further demonstrates how to compose the entire quantum machine learning pipeline using categorical operations:

fn demonstrate_categorical_composition(
    x_data: &Array2<f64>,
    y_data_flat: &Array1<f64>,
    data_category: &DataCategory,
    circuit_category: &CircuitCategory,
    data_to_circuit: &DataToCircuitFunctor,
    variational_circuit: &QuantumCircuit,
    prediction_circuit: &CircuitPredictionTransformation,
    batch_size: usize,
    qubit_count: usize
) {
    println!("\nDemonstrating categorical composition of the full quantum ML pipeline...");
 
    // Map a test sample through the entire pipeline using categorical composition
    let test_sample_idx = batch_size;  // A sample we haven't used yet
    let test_sample = x_data.row(test_sample_idx).to_owned();
 
    // Step 1: Use the data to circuit functor to map the classical data to a quantum circuit
    let circuit_morphism = data_to_circuit.map_morphism(
        data_category,
        circuit_category,
        &Array2::from_shape_vec((1, 2), vec![test_sample[0], test_sample[1]]).unwrap()
    );
 
    // Step 2: Compose with the variational model circuit
    let composed_circuit = circuit_category.compose(&circuit_morphism, variational_circuit).unwrap();
 
    // Step 3: Apply the circuit to get a quantum state
    let test_state = StateVector::zero_state(qubit_count);
    let composed_output_state = composed_circuit.apply(&test_state).unwrap();
 
    // Step 4: Apply the prediction transformation to get the final output
    let final_prediction = prediction_circuit.apply(&composed_output_state).unwrap();
 
    // Result evaluation
    // ...code omitted for brevity...
}

This demonstration shows how the categorical framework enables formal reasoning about the composition of the entire quantum machine learning pipeline, from data preparation to prediction.

The framework also verifies that the implementation respects functorial properties:

fn verify_functorial_properties(
    data_category: &DataCategory,
    circuit_category: &CircuitCategory,
    model_category: &ModelCategory,
    data_to_circuit: &DataToCircuitFunctor,
    circuit_to_model: &CircuitToModelFunctor,
    state_prep: &StatePreparationTransformation<EncodingStrategy>,
    model_prediction: &ModelPredictionTransformation,
    qubit_count: usize
) {
    println!("\nDemonstrating how category theory enables formal reasoning...");
 
    // Create the component morphisms for our model
    let prep_morphism = state_prep.prepare_state(
        data_category,
        circuit_category,
        data_to_circuit,
        &data_to_circuit.identity_functor(),
        &2
    );
 
    // ...code omitted for brevity...
 
    // Verify F(id_A) = id_F(A)
    let id_data = data_category.identity(&2);
    let mapped_id = data_to_circuit.map_morphism(data_category, circuit_category, &id_data);
    let id_circuit = circuit_category.identity(&data_to_circuit.map_object(data_category, circuit_category, &2));
 
    // The circuit dimensions should match (both should be qubit_count)
    assert_eq!(mapped_id.qubit_count, id_circuit.qubit_count);
    println!("✓ Functorial property F(id_A) = id_F(A) verified");
}

This verification confirms that the functors properly preserve categorical structure, which is essential for ensuring that the transformations between classical data, quantum circuits, and predictions maintain mathematical consistency.

A critical aspect of quantum machine learning is encoding classical data into quantum states. The framework supports different encoding strategies:

• Angle Encoding: Classical features are encoded as rotation angles
• Amplitude Encoding: Classical features are encoded as amplitudes in the quantum state
• Basis Encoding: Classical features are encoded as basis states

The angle encoding implementation demonstrates how classical data can be systematically mapped to quantum operations:

// Prepare the input state using angle encoding
let mut state_prep_circuit = CircuitBuilder::new(qubit_count);
 
// Always encode first two dimensions directly
state_prep_circuit.ry(0, sample[0] * PI).unwrap();
state_prep_circuit.ry(1, sample[1] * PI).unwrap();
 
// Extra rotations to spread the encoding across all qubits
for q in 2..qubit_count {
    let encoding_angle = match q % 4 {
        0 => sample[0] * PI,                        // Original x feature
        1 => sample[1] * PI,                        // Original y feature
        2 => (sample[0] + sample[1]) * PI/2.0,      // Sum of features
        _ => (sample[0] - sample[1]).abs() * PI/2.0 // Difference of features
    };
 
    state_prep_circuit.ry(q, encoding_angle).unwrap();
}

Here, via the above encoding strategy, classical features can be systematically mapped to quantum operations, creating a well-defined interface between classical and quantum data.

What I wanted to demonstrate with the implementation of Shim is that that category theory provides a useful mathematical language for quantum computing with specific applications towards machine learning.

By formalizing quantum operations, data transformations, and their compositions, Shim enables:

• Mathematical Verification: Formal verification of categorical properties ensures correctness
• Compositional Design: Natural composition of quantum operations and transformations
• Systematic Experimentation: Parameterized framework for exploring different architectures
• Formal Interfaces: Well-defined interfaces between classical data and quantum operations

The categorical approach provides a bridge between the mathematical foundations of quantum mechanics and the practical requirements of machine learning.

As quantum computing continues to advance, Im hoping Shim and implementations like it (there are a others) that provide formal mathematical foundations will be essential for ensuring the provable correctness and reliability of quantum machine learning systems.

There are many potential future applications and research directions for this work that Im hoping to explore in part, with a none exhaustive and unsorted list below:

• Categorical Quantum Error Mitigation: Development of formal frameworks for quantum error correction and mitigation using categorical techniques. This could include modeling noise channels as endofunctors and error mitigation strategies as natural transformations between these functors.

• Categorical Quantum Resource Theories: Formalization of quantum resources (entanglement, coherence, non-Gaussianity) using categorical resource theories. This would enable rigorous accounting of resource consumption in quantum algorithms.

• Categorical Complexity Measures: Development of categorical complexity measures for quantum circuits that provide formal bounds on computational power. These measures could formalize the relationship between circuit depth, entanglement structure, and expressivity.

• Functorial Learning Theory: A categorical learning theory that characterizes the generalization capabilities of quantum models in terms of functorial properties. This would establish formal conditions under which quantum models generalize beyond training data.

• Categorical No-Free-Lunch Theorems: Formal proofs of quantum versions of no-free-lunch theorems using categorical methods. These would establish fundamental limitations on quantum learning algorithms and identify the precise conditions under which quantum advantages can exist.

• Computational Trinity: Formal equivalences between quantum computational models, type systems, and categorical structures. This trinity could establish a correspondence between quantum circuits, dependent type systems, and higher categorical structures.

• Compositional Quantum Advantage: Rigorous characterization of how compositional quantum structures can provide computational advantages. This would identify precisely where quantum advantages emerge in composite systems.

• Categorical Barren Plateaus: Formal characterization of barren plateaus in quantum optimization landscapes using categorical gradient flow. This would precisely identify circuit architectures immune to vanishing gradients.

• Monoidal Bisimulation: Development of bisimulation relations for quantum processes using monoidal categories. This would provide formal methods for proving equivalence between quantum algorithms.

• Categorical Circuit Synthesis: Investigation of whether categorical specifications can be used to automate the synthesis of optimal quantum circuits directly from their mathematical description.