# What Advanced AI Topics Are Included in Chapters 11-20 of the Maths-CS-AI Compendium?

> Explore advanced AI topics like quantum machine learning in chapters 11-20 of the Maths-CS-AI Compendium. Discover bleeding-edge research areas and their impact.

- Repository: [Henry Ndubuaku/maths-cs-ai-compendium](https://github.com/HenryNdubuaku/maths-cs-ai-compendium)
- Tags: deep-dive
- Published: 2026-07-16

---

**Chapters 11-20 correspond to Chapter 20: Bleeding Edge AI in the HenryNdubuaku/maths-cs-ai-compendium repository, covering five cutting-edge research areas including quantum machine learning, neuromorphic computing, and brain-machine interfaces.**

The Maths-CS-AI Compendium organizes advanced artificial intelligence concepts into a structured learning path. When referring to chapters 11-20, the repository maps this range specifically to **Chapter 20: Bleeding Edge AI**, a comprehensive deep-dive into the most advanced AI research areas currently shaping the field. Each topic resides in its own markdown file within the `chapter 20: bleeding edge AI/` directory.

## The Five Advanced AI Topics Covered

The bleeding-edge AI chapter contains five specialized sub-chapters, each addressing a distinct paradigm in next-generation computing.

### Quantum Machine Learning

**Quantum Machine Learning (QML)** explores how quantum computing accelerates classical ML algorithms through hybrid quantum-classical models. The repository covers variational quantum circuits and their integration with PyTorch, demonstrating how to train quantum neural networks on classical hardware.

Source file: `chapter 20: bleeding edge AI/01. quantum machine learning.md`

### Neuromorphic Computing

**Neuromorphic Computing** focuses on brain-inspired hardware architectures utilizing spiking neurons and event-driven processing. This section details ultra-low-power AI implementations that mimic biological neural networks through specialized SNN (Spiking Neural Network) architectures.

Source file: `chapter 20: bleeding edge AI/02. neuromorphic computing.md`

### Data Centres in Space

**Data Centres in Space** examines orbital data-center constellations designed for latency-critical AI services. The documentation discusses sustainability challenges and infrastructure requirements for deploying compute resources in low-earth orbit.

Source file: `chapter 20: bleeding edge AI/03. datacentres in space.md`

### Decentralised AI

**Decentralised AI** covers federated learning frameworks, blockchain-based model marketplaces, and privacy-preserving collaborative AI across distributed edge devices. This section addresses training scenarios where data cannot be centralized due to privacy constraints.

Source file: `chapter 20: bleeding edge AI/04. decentralised AI.md`

### Brain-Machine Interfaces

**Brain-Machine Interfaces (BMI)** details both invasive and non-invasive neural interfaces, including closed-loop AI systems for prosthetics and assistive technologies. The chapter includes ethical considerations and signal processing requirements for real-time neural decoding.

Source file: `chapter 20: bleeding edge AI/05. brain machine interfaces.md`

## Quantum Machine Learning Implementation

The compendium provides executable code demonstrating **Variational Quantum Classifiers (VQC)** using PennyLane. The implementation shows how to construct a quantum circuit that integrates with PyTorch's autograd system.

```python

# Install Pennylane (quantum ML library)

!pip install pennylane[torch]  # ← run in notebook cell

import pennylane as qml
import torch
from pennylane import qnn

# Define a 2-qubit quantum circuit

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev, interface="torch")
def circuit(weights, x):
    qml.RY(x[0], wires=0)
    qml.RY(x[1], wires=1)
    qml.Rot(*weights[0], wires=0)
    qml.Rot(*weights[1], wires=1)
    return [qml.expval(qml.PauliZ(wires=i)) for i in range(2)]

# Build a Torch module around the circuit

class VQC(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.weights = torch.nn.Parameter(0.01 * torch.randn(2, 3))

    def forward(self, x):
        return circuit(self.weights, x)

model = VQC()
optimizer = torch.optim.Adam(model.parameters(), lr=0.05)

# Simple training loop on synthetic binary data

for epoch in range(30):
    optimizer.zero_grad()
    loss = torch.nn.functional.binary_cross_entropy_with_logits(
        model(torch.randn(10, 2)), torch.randint(0, 2, (10,)).float()
    )
    loss.backward()
    optimizer.step()

```

This snippet defines a `VQC` class extending `torch.nn.Module`, enabling standard PyTorch training loops on quantum circuits. The `circuit` function executes on PennyLane's `default.qubit` simulator, making it reproducible without actual quantum hardware.

## Neuromorphic Computing with Spiking Neural Networks

For **neuromorphic computing**, the repository demonstrates Spiking Neural Networks (SNNs) using the BindsNET library. Unlike traditional ANNs, SNNs use discrete spike events rather than continuous activation values.

```python

# Install BindsNET (spiking neural network library)

!pip install bindsnet  # ← run in notebook cell

import torch
from bindsnet.network import Network
from bindsnet.network.nodes import Input, LIFNodes
from bindsnet.network.topology import Connection
from bindsnet.learning import PostPre

# Create a minimal SNN: 100-input → 50-LIF → output

net = Network()
net.add_input_layer = Input(n=100, shape=(10, 10))
net.add_layer = LIFNodes(n=50)

# Connect layers with random weights

conn = Connection(source=net.input_layer, target=net.layer, w=0.1 * torch.randn(100, 50))
net.add_connection(source=net.input_layer, target=net.layer, connection=conn)

# Define a simple STDP learning rule

stdp = PostPre(connection=conn, nu=(1e-4, 1e-2))
net.add_learning_rule(stdp)

# Run the network for a single timestep

inputs = torch.bernoulli(0.1 * torch.ones(1, 100))
net.run(inputs=inputs, time=1)

# Inspect spikes of the LIF layer

spikes = net.layer.spike_record
print("Spikes generated:", spikes.sum().item())

```

The code constructs a network with **LIFNodes** (Leaky Integrate-and-Fire neurons) and implements **STDP** (Spike-Timing-Dependent Plasticity) learning rules. This approach mirrors the event-driven processing found in actual neuromorphic hardware like Intel's Loihi or IBM's TrueNorth.

## Source File Structure

The bleeding-edge AI content is organized within the HenryNdubuaku/maths-cs-ai-compendium repository under the following paths:

- `chapter 20: bleeding edge AI/01. quantum machine learning.md`
- `chapter 20: bleeding edge AI/02. neuromorphic computing.md`
- `chapter 20: bleeding edge AI/03. datacentres in space.md`
- `chapter 20: bleeding edge AI/04. decentralised AI.md`
- `chapter 20: bleeding edge AI/05. brain machine interfaces.md`

Each markdown file contains conceptual explanations, mathematical foundations, and links to the executable notebooks referenced in the code examples above.

## Summary

- **Chapters 11-20** in the Maths-CS-AI Compendium specifically map to **Chapter 20: Bleeding Edge AI**, covering five advanced research domains.
- The repository includes **quantum machine learning** implementations using PennyLane and PyTorch integration.
- **Neuromorphic computing** examples utilize BindsNET to demonstrate spiking neural networks with STDP learning.
- Additional topics include **data centres in space**, **decentralised AI** (federated learning and blockchain), and **brain-machine interfaces**.
- All content resides in the `chapter 20: bleeding edge AI/` directory with separate markdown files for each sub-topic.

## Frequently Asked Questions

### Why do chapters 11-20 refer to Chapter 20 in the repository?

The Maths-CS-AI Compendium uses a specific numbering system where the range 11-20 corresponds to the twentieth chapter focused on bleeding-edge AI topics. This organizational structure consolidates multiple advanced concepts under a single comprehensive chapter rather than distributing them across ten separate chapters.

### What quantum computing libraries does the compendium recommend?

The repository utilizes **PennyLane** with PyTorch integration for quantum machine learning examples. The `quantum machine learning.md` file demonstrates variational quantum classifiers using the `default.qubit` simulator, allowing execution on classical hardware while maintaining compatibility with actual quantum devices.

### How does neuromorphic computing differ from traditional deep learning in the examples?

According to the source files, **neuromorphic computing** employs **spiking neural networks (SNNs)** with LIF (Leaky Integrate-and-Fire) neurons and event-driven processing, contrasting with traditional deep learning's continuous activation functions. The BindsNET examples implement **STDP** (Spike-Timing-Dependent Plasticity) learning rules, which adjust synaptic weights based on precise spike timing rather than backpropagation.

### Are there practical implementations for space-based data centres?

The `datacentres in space.md` file focuses primarily on architectural vision and sustainability considerations for orbital compute infrastructure. While the chapter discusses latency-critical AI services and satellite constellations, it emphasizes conceptual frameworks and engineering challenges rather than executable code implementations.