DEV Community: Doraking

Qisquiz: A Quiz App for Learning Qiskit v2.X

Doraking — Fri, 05 Jun 2026 03:18:28 +0000

Qisquiz: A Qiskit v2.X Certification Prep App

I built Qisquiz, a web app for learning Qiskit v2.X and preparing for the IBM Certified Quantum Computation using Qiskit v2.X Developer - Associate certification exam.

You can try the app here:

https://qisquiz.vercel.app/

The GitHub repository is here:

https://github.com/dorakingx/qisquiz

The concept of Qisquiz is simple:

Master Qiskit, one quiz at a time.

In other words, Qisquiz is a quiz-based certification prep app that helps learners study Qiskit one question at a time.

The target exam is:

Exam C1000-179: Fundamentals of Quantum Computing Using Qiskit v2.X Developer

Why I Built Qisquiz

Qiskit is one of the most important development tools for learning and building quantum computing applications.

It is useful for creating quantum circuits, running simulations, using IBM Quantum hardware, and experimenting with quantum algorithms.

However, Qiskit v2.X includes several APIs and concepts that learners need to understand carefully.

For example, certification prep requires knowledge of topics such as:

Qiskit Runtime
SamplerV2
EstimatorV2
PUBs, or Primitive Unified Blocs
BackendV2
backend.target
Transpilation
ISA circuits
Dynamic circuits
OpenQASM 3
Result object handling
Little-endian and big-endian interpretation

These topics can be learned by reading documentation, but I felt that active practice through quizzes is especially useful for exam preparation.

That is why I built Qisquiz, a quiz-based learning app focused on Qiskit v2.X.

What Is Qisquiz?

Qisquiz is an independent quiz-based learning app for Qiskit v2.X.

The current version is organized around the 8 sections of the IBM Qiskit v2.X Developer certification exam.

The current question bank includes:

120 original questions
44 code-based questions
40 hard questions
8 sections
15 questions per section

Qisquiz is not an official IBM or Qiskit product.

It is an independent learning tool that I built to help myself and other learners prepare more effectively.

Covered Exam Sections

Qisquiz covers the following 8 exam sections.

Section 1: Perform Quantum Operations

This section covers the basics of quantum operations.

Topics include:

Pauli operators
Standard quantum gates
Quantum operations
Qubit ordering
Global phase and relative phase

Section 2: Visualize Quantum Circuits, Measurements, and States

This section focuses on visualization of quantum circuits, measurements, and quantum states.

Topics include:

circuit.draw()
Measurement visualization
Statevector
Bloch sphere
Histogram interpretation

Section 3: Create Quantum Circuits

This section covers how to create and manipulate quantum circuits.

Topics include:

QuantumCircuit
Parameterized circuits
Transpilation
ISA circuits
Dynamic circuits
if_test

Section 4: Run Quantum Circuits

This section focuses on Qiskit Runtime and hardware execution.

Topics include:

Qiskit Runtime
BackendV2
Sessions
Batch mode
Job submission
Hardware execution

Section 5: Use the Sampler Primitive

This section covers the Sampler primitive.

Topics include:

SamplerV2
PUBs
Sampler options
Result navigation
Measurement sampling

Section 6: Use the Estimator Primitive

This section covers the Estimator primitive.

Topics include:

EstimatorV2
Observables
Expectation values
PUB format
Precision vs shots

Section 7: Retrieve and Analyze Results of Quantum Circuits

This section focuses on retrieving and analyzing execution results.

Topics include:

Retrieving previous jobs
Result object analysis
Counts
Quasi-distributions
Data extraction

Section 8: Operate with OpenQASM

This section covers OpenQASM 3.

Topics include:

OpenQASM 3 syntax
Data types
Qiskit interoperability
Import and export
Semantic interpretation

Main Features

1. Section Practice

Users can practice questions by section.

They can choose:

Exam section
Difficulty
Number of questions
Sequential or randomized order

For example, if a learner is weak in SamplerV2 or EstimatorV2, they can focus on the related sections instead of studying everything randomly.

2. Full Mock Exam

Qisquiz also includes a mock exam mode.

The current mock exam has:

68 questions
90 minutes
Balanced coverage across the 8 sections
No instant feedback during the exam
Score and explanations after submission

In normal study mode, users can see explanations immediately.

In mock exam mode, feedback is shown only after submission so that the experience feels closer to an actual exam.

3. Dashboard

The Dashboard allows users to check their learning progress saved in the browser.

At the moment, Qisquiz does not use accounts or a database.

Progress is stored with browser LocalStorage.

This keeps the first version simple and frontend-focused, while making it possible to add authentication and cloud sync in the future.

4. Resources Page

The Resources page collects external resources related to Qiskit v2.X and certification preparation.

It includes categories such as:

IBM / Qiskit official resources
Qiskit API documentation
Runtime, Sampler, and Estimator references
OpenQASM references
Community tutorials
Practice exams
Slides

The questions in Qisquiz are original, but I wanted learners to easily access useful official and community resources.

Why I Focused on Code-Reading Questions

For Qiskit, understanding the concept is not enough.

Learners also need to understand how the APIs are actually used in code.

That is why Qisquiz includes many code-based questions.

For example, a question may ask the user to read code like this and understand what it does:

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

sampler = StatevectorSampler()
job = sampler.run([qc], shots=1024)
result = job.result()

For certification prep, I think it is important not only to memorize terms, but also to read code and understand its meaning.

Code-reading questions are especially useful for topics such as:

SamplerV2
EstimatorV2
PUB format
generate_preset_pass_manager
Dynamic circuits
OpenQASM 3
Result object navigation

Tech Stack

Qisquiz is built with:

Next.js 15
App Router
TypeScript
Tailwind CSS v4
prism-react-renderer
Browser LocalStorage
Vercel

I wanted to build and publish the app quickly, so I chose Next.js and Vercel.

For the current version, question data is stored as static TypeScript data, and progress is stored locally in the browser.

This keeps the architecture simple while leaving room for future backend features.

Project Structure

The repository is roughly organized like this:

src/
  app/
    page.tsx
    topics/
    quiz/
    mock-exam/
    dashboard/
    resources/

  components/
    QuizCard.tsx
    AnswerChoice.tsx
    CodeBlock.tsx
    ScoreSummary.tsx
    ResourceCard.tsx

  data/
    questions.ts
    resources.ts

  lib/
    progress.ts

  types/
    quiz.ts

docs/
  question-writing-guidelines.md

scripts/
  validate-questions.ts

The question data is stored in:

src/data/questions.ts

The type definitions are stored in:

src/types/quiz.ts

There is also a validation command for checking the question bank:

npm run validate:questions

As the number of questions grows, it becomes easier to introduce mistakes such as:

Incorrect answer indexes
Missing choices
Duplicate question IDs
Incomplete tags
Missing explanations

Because of this, I added a simple validation script to help maintain question quality.

Question Data Design

The question data in Qisquiz includes more than just question text and choices.

Each question can contain metadata useful for certification prep.

type QuizQuestion = {
  id: string;
  section: number;
  sectionTitle: string;
  difficulty: "easy" | "medium" | "hard";
  question: string;
  code?: string;
  choices: string[];
  correctAnswerIndex: number;
  explanation: string;
  tags: string[];
  sourceReference?: string;
  relatedDocsUrl?: string;
  examSkill?: string;
  commonMistake?: string;
  estimatedTimeSeconds?: number;
  concept?: string;
  objective?: string;
  qiskitVersion?: string;
  lastReviewedAt?: string;
};

This structure makes it easier to support features such as:

Section-based practice
Difficulty-based practice
Tag-based weakness analysis
Reviewing only incorrect questions
Mock exam mode
Question search
Future spaced repetition
Future user-specific learning history

What I Learned While Building It

While building Qisquiz, I realized that quantum computing learning tools should not only explain formulas or theory.

For implementation-oriented tools like Qiskit, learners also need to understand:

API syntax
How to run circuits
How to retrieve results
Differences between versions
How to read official documentation

In particular, Qiskit v2.X includes many practical topics such as SamplerV2, EstimatorV2, Runtime, and OpenQASM 3.

These topics are important both for certification prep and for real development.

That is why I think quiz-based active recall works very well for learning Qiskit.

Current Status and Roadmap

Qisquiz is still a work in progress, but the current version already includes:

120-question question bank
Full Mock Exam mode
Dashboard
Review features
Local progress tracking
Section-based practice
Tag-based weakness analysis

In the future, I want to make it a more complete certification prep app.

Planned improvements include:

Expanding the question bank to 300+ questions
Improving Mock Exam score analysis
Making weak tag visualization more detailed
Adding spaced repetition
Adding user accounts
Adding cloud sync
Adding AI-generated personalized study plans
Supporting community-created question sets
Reviewing questions when Qiskit versions change
Adding explanation pages and mini lessons

I am especially interested in building a system that can analyze incorrect answers and automatically identify which APIs or concepts the learner should review next.

Try It

You can try Qisquiz here:

https://qisquiz.vercel.app/

The GitHub repository is here:

https://github.com/dorakingx/qisquiz

If you are learning Qiskit v2.X, preparing for the IBM Qiskit Developer certification exam, or interested in implementation-oriented quantum computing education, I hope Qisquiz can be useful.

Issues and feedback are very welcome.

Disclaimer

Qisquiz is an independent learning tool.

It is not affiliated with, endorsed by, or officially connected to IBM, Qiskit, or any related official organization.

The questions are original and created for educational purposes only. They are not official exam questions, exam dumps, paid dumps, or copied copyrighted practice questions.

NovelPilot: A Novel Writing Agent Powered by Gemma 4

Doraking — Sat, 23 May 2026 03:50:06 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

Most AI story generators work like this:

prompt in → wall of text out

That is useful, but it does not feel like a real writing process.

When people write fiction, they do not only generate paragraphs. They plan the premise, design characters, build the world, structure the plot, manage foreshadowing, write scenes, edit style, check continuity, and prepare the final piece for readers.

So I built NovelPilot.

NovelPilot is a Gemma 4-powered AI writing room that turns one prompt into a complete story creation pipeline.

One prompt goes in.

Nine agents start working.

A finished story comes out.

What I built

NovelPilot is a web app that helps users create short fiction through a structured multi-agent workflow.

The user starts with a simple prompt, such as:

Write a melancholic sci-fi mystery set in modern Tokyo. A graduate student who lost his memory investigates a disappearance in a quantum computing lab.

Then NovelPilot launches a sequence of specialized AI agents:

Premise Architect
Character Director
World Builder
Plot Strategist
Chapter Architect
Prose Writer
Style Editor
Continuity Detective
Publisher Agent

Each agent performs a specific part of the writing process.

The result is not just a generated story. It is a full creative package:

Story concept
Character profiles
Worldbuilding notes
Plot structure
Chapter outline
Chapter 1 draft
Style editor report
Foreshadowing tracker
Continuity detective report
Title ideas
Publication summary
Browser reading mode
Polished PDF export

NovelPilot is designed to demonstrate Gemma 4 as a multi-agent creative reasoning engine, not just a text completion model.

Demo

Live demo: https://novelpilot.vercel.app

How to try it:

Open the live demo.
Click Run Judge Demo.
Watch the nine-agent pipeline complete.
Read the finished novel in the browser.
Review the Foreshadowing Tracker and Continuity Detective.
Download the final story as a polished PDF.

The Judge Demo works without an API key, so reviewers can test the full experience immediately.

For live generation, NovelPilot supports Gemma 4 through a provider abstraction, with OpenRouter as the recommended provider.

Sample prompt and output

Here is the sample prompt I used to test NovelPilot.

The protagonist is Ren Kanzaki, a 24-year-old graduate student working in a quantum computing laboratory. A few days ago, he lost part of his memory. He cannot remember what he was researching, why his professor suddenly disappeared, or why his own name appears in an old experimental log.

The story begins on a rainy night in Tokyo. Ren enters the university research building after midnight and finds an old experiment log hidden inside a locked drawer. On the final page, he sees the sentence:

“Ren Kanzaki will be removed from the observation target as of today.”

The story should focus on quiet tension, memory gaps, emotional unease, and the unsettling atmosphere of the laboratory. Avoid flashy action. Let the mystery emerge through scenery, silence, dialogue, and small contradictions.

Main theme:
If memories disappear, can a person still remain the same self?

Main characters:
- Ren Kanzaki: A graduate student who lost part of his memory. Calm and intelligent, but emotionally repressed.
- Mio Shiraishi: Ren’s labmate. She knows something about Ren’s memory loss but refuses to tell him the truth.
- Professor Kuon: The missing professor. He was researching quantum memory transfer.
- Associate Professor Kurosaki: The person currently managing the laboratory. He seems helpful, but some of his statements contradict the records.

Tone:
Intellectual, quiet, melancholic, slightly literary, and mysterious.

Language: en
Genre: sci-fi
Tone: melancholic
Target Length: short-story

I also exported the generated story as a polished PDF.

Sample output PDF: Download the generated novel PDF

This PDF was generated directly from NovelPilot’s finished reader view.

Code

GitHub repo: https://github.com/dorakingx/novelpilot

Tech stack:

Next.js App Router
TypeScript
Tailwind CSS
shadcn/ui-style components
Gemma 4 provider abstraction
OpenRouter-compatible live mode
Mock mode for the zero-setup judge demo
Browser-based polished PDF export
Vercel deployment

The app has two main modes:

Mode	Purpose
Demo / Mock Mode	Lets judges try the full workflow without an API key
Live Mode	Uses Gemma 4 through the configured provider

The provider layer is intentionally isolated in lib/gemma.ts, so the model provider can be changed without rewriting the app.

How I used Gemma 4

Gemma 4 is the reasoning engine behind the multi-agent writing pipeline.

NovelPilot uses Gemma 4 for:

structured story concept generation
character design
worldbuilding
plot planning
chapter outlining
prose drafting
style editing
foreshadowing tracking
continuity auditing
publisher copy generation

Each agent receives the accumulated story bible and previous structured outputs.

This means Gemma 4 is not just generating paragraphs. It acts as the structural memory and reasoning layer for the whole novel creation process.

The important design decision was to make every agent return structured data whenever possible. That allows the UI to render the model output as real product features: timelines, cards, reports, trackers, reader views, and exports.

Why I chose this Gemma 4 model

For the live version, NovelPilot is designed to use a Gemma 4 model through OpenRouter.

I chose this approach because the app needs strong reasoning and structured generation across multiple steps. The model must follow JSON schemas, preserve context from earlier agents, and reason about story structure, character consistency, and foreshadowing.

NovelPilot focuses especially on:

long-context creative reasoning
structured JSON generation
story memory across multiple steps
continuity checking
literary planning and drafting

Gemma 4 is a good fit because the project is not only asking the model to write a paragraph. It asks the model to behave as a coordinated writing room.

What makes NovelPilot different

Most AI writing tools generate text.

NovelPilot generates a writing process.

The user does not only receive a draft. They see how the story is built:

Prompt
  ↓
Premise
  ↓
Characters
  ↓
World
  ↓
Plot
  ↓
Chapter outline
  ↓
Draft
  ↓
Style edit
  ↓
Continuity audit
  ↓
Publisher package
  ↓
Reader view
  ↓
PDF export

This makes the output easier to inspect, revise, and trust.

Key feature: Foreshadowing Tracker

One of my favorite parts is the Foreshadowing Tracker.

Instead of only writing a draft, NovelPilot tracks story threads like this:

{
  "item": "The cracked silver watch",
  "introducedIn": "Chapter 1",
  "status": "unresolved",
  "suggestedPayoff": "It reveals the exact time the protagonist's memory was overwritten.",
  "payoffChapter": "Chapter 3",
  "emotionalPurpose": "Connects guilt, identity, and lost time."
}

This makes the output more useful for writers.

It also shows why a structured model workflow matters. The app is not only asking Gemma 4 to write prose. It is asking Gemma 4 to reason about narrative structure.

Key feature: Continuity Detective

The Continuity Detective checks the generated story for structural problems.

It returns issues with:

category
severity
evidence
suggested fix

Example structure:

{
  "category": "foreshadowing",
  "severity": "high",
  "issue": "The experiment log is introduced as important but has no planned payoff.",
  "evidence": "The log appears in Chapter 1 and is referenced in the outline, but no chapter resolves its origin.",
  "suggestedFix": "Reveal in the final chapter that the log was written by an earlier version of the protagonist."
}

This was important to me because many AI writing tools can generate plausible fiction, but fewer tools help the user understand whether the story actually holds together.

Final reader experience

After all agents finish, NovelPilot automatically transitions into a Completed Novel Reader.

The user can read the finished story directly in the browser.

They can also go back to the Agent Workspace to inspect:

agent outputs
story bible
foreshadowing tracker
continuity report
publisher package

The final reader is not a one-way screen. Users can freely move between the production workflow and the finished novel.

PDF export

I also added polished PDF export.

Instead of relying on the browser’s default print layout, NovelPilot generates a designed A4-style manuscript PDF.

The PDF includes:

cover page
novel title
metadata
chapter title
formatted manuscript body
optional story notes

This makes the app feel closer to a complete writing product, not just a demo.

UI/UX design

I wanted the app to feel like an AI creative studio.

The flow has three stages:

1. Prompt Launcher

The first screen is focused.

The user only sees:

prompt input
language
genre
tone
target length
Generate Story
Run Judge Demo

This keeps the experience simple.

2. Agent Workspace

After generation starts, the app transitions into the agent workspace.

This screen shows:

active agent timeline
story bible
foreshadowing tracker
manuscript preview
continuity detective
export tools

3. Completed Novel Reader

When all agents finish, the app opens the final reading screen.

The user can read the story, download a PDF, or go back to review the agent outputs.

Technical architecture

The core architecture is simple:

app/page.tsx
  Main app phase control:
  launcher → workspace → reader

lib/useStoryProject.ts
  Client-side orchestration of the pipeline

app/api/generate-agent/route.ts
  Runs one agent per request

lib/gemma.ts
  Provider abstraction for Gemma 4 / OpenRouter / mock mode

lib/prompts.ts
  Prompt templates for each writing agent

lib/agents.ts
  Merges structured agent outputs into the Story Bible

lib/types.ts
  Shared TypeScript types

components/
  Prompt launcher, agent workspace, reader, trackers, reports, export panels

The app uses a state-first architecture because this is a hackathon project. I intentionally avoided authentication, databases, and user accounts so the core experience stays fast and easy to judge.

Agent workflow

Here is the high-level pipeline:

User Prompt
  ↓
Premise Architect
  ↓
Character Director
  ↓
World Builder
  ↓
Plot Strategist
  ↓
Chapter Architect
  ↓
Prose Writer
  ↓
Style Editor
  ↓
Continuity Detective
  ↓
Publisher Agent
  ↓
Completed Novel Reader + PDF Export

Each step builds on the previous one.

For example, the Character Director does not work from the original prompt alone. It receives the premise and theme created by the Premise Architect.

The Plot Strategist receives the concept, characters, and worldbuilding.

The Continuity Detective receives the story bible, chapter outline, draft, and previous reports.

This makes the app feel like an actual production pipeline rather than a single model call.

What I learned

The biggest lesson was that structured outputs are more powerful than plain prose outputs for creative tools.

A single prose response is hard to inspect.

But structured outputs can become:

timelines
cards
story bibles
trackers
reports
reader views
exports

I also learned that judge experience matters.

That is why I added Run Judge Demo. Reviewers can experience the full product without configuring an API key.

Another lesson was that a creative AI product should not end at “generation complete.” It should end with something the user can actually consume. That is why I added the final reader and PDF export.

Challenges

The biggest challenge was balancing autonomy and control.

If the app is too automatic, it feels like the user has no creative role.

If the app asks for too much input, it stops feeling agentic.

So I designed NovelPilot around this principle:

The AI agents do the heavy lifting, but the user can always review, regenerate, edit, read, and export.

Another challenge was making the final output feel complete. The Completed Novel Reader and PDF export helped turn the generated draft into something closer to a finished product.

What’s next

I would like to add:

full multi-chapter generation
persistent projects
local storage
streaming agent output
genre-specific prompt packs
vertical Japanese reading mode
richer PDF themes
user-editable story bible
side-by-side draft revision

Final thoughts

NovelPilot is my attempt to make AI fiction generation feel less like a chatbot and more like a writing room.

The core idea is simple:

One prompt. Nine agents. A complete story pipeline.

Gemma 4 is the reasoning engine behind the process. It plans, writes, edits, tracks foreshadowing, checks continuity, and packages the final story.

That is what makes NovelPilot more than a story generator.

It is an AI-powered novel production studio.

Re-reading Blockchain "Classics" in 2026: Implementing the Future in the Era of AI & Quantum Computing

Doraking — Thu, 29 Jan 2026 16:24:15 +0000

In the fast-moving Web3 industry, reading technical books published several years ago—now considered "classics"—in 2026 holds significant value.

Why? Because the "Why" (the fundamental philosophy) behind the technology remains far more vivid in early literature than in the latest documentation.

In this article, based on three classic books, I will revisit the foundational theories of blockchain, check the "Future Predictions" made back then against the "Current Solutions (2026 Implementations)," and explore where blockchain is heading now that AI and Quantum Computing have entered the practical stage.

📚 The "Bibles" Referenced

"Blockchain: Theory and Practice" (Similar scope to Mastering Bitcoin) (Japanese Book)
"The Textbook for Understanding Blockchain Structure and Development" (Japanese Book)
"Blockchain Revolution" by Don Tapscott and Alex Tapscott

Chapter 1: The Structure of "Trust" Redefined by Blockchain

Before diving into technical explanations, let's clarify the definition of "Trust" at the root of the architecture.

1.1 Mathematical Assurance of Social Capital

As stated in Blockchain Revolution, an ideal society is one rich in "Social Capital," where "courage worthy of praise is rewarded."

Traditionally, this "courage" (honest behavior) was guaranteed by Centralized Intermediaries (TTP: Trusted Third Parties) like banks and governments. However, these can become "Single Points of Failure (SPOF)" and incur mediation costs.

Blockchain replaced this trust with "Cryptographic Proof" and "Game Theoretic Incentives."

Cost of lying > Profit gained from lying

As long as this inequality holds, the system autonomously continues to record the "truth." This is the true meaning of "Trustless." It doesn't mean "trust no one"; it means "you trust the protocol so you don't have to trust anyone else."

1.2 Web3 and the "Internet of Value"

The concept proposed in early literature has become clearer today:

Web2 (Internet of Information): Copying is easy. Democratization of information.
Web3 (Internet of Value): Copying is impossible (prevention of double-spending). Democratization of value.

"Value" here isn't limited to currency. It includes identity, copyright, voting rights, and the "autonomous economic activities of AI" discussed later.

Chapter 2: Technical Details Supporting Bitcoin's Robustness

Let's look back at the mechanisms of Bitcoin with high resolution.

2.1 The Beauty of State Management: The UTXO Model

In Bitcoin, there is no variable called "Balance" in the database like in a bank account. There is only a collection of UTXOs (Unspent Transaction Outputs).

Input: References a past transaction (where the money came from).
Output: Specifies the new owner (who the rights are transferred to).
Script: A simple program (stack-based language) that verifies the validity of the transaction.

This model has the advantages of "ease of parallel processing" and "high privacy (easy to use disposable addresses)." On the other hand, it is unsuitable for complex state management (stateful processing) like Ethereum.

2.2 The Key to Tamper Detection: Merkle Trees

The block header contains the "Merkle Root," which is a summary value of all transactions included in that block.

Mechanism: A binary tree structure where transaction hashes are paired and hashed repeatedly until finally one hash value (the root) remains.
Benefit (SPV Nodes): Lightweight nodes (SPV) like smartphones can verify "whether a specific transaction is included in a block" using only the Merkle Path ( $O (lo g n)$ complexity) without downloading all data.

2.3 Consensus: The Essence of Proof of Work (PoW)

PoW is not just a calculation competition. It is a converter that transforms "physical world resources (electricity/hardware)" into "digital world security."

Nonce: Searching for a 32-bit integer such that the hash value is less than or equal to the Difficulty Target.
Probabilistic Finality: If you wait for "6 confirmations" (about 1 hour), the probability of the transaction being overturned becomes astronomically low.

Chapter 3: The 2026 "Answer Key" — Scalability and Ethereum

When these books were published (around 2017-2020), the biggest challenge was Scalability. What happened to the "prophecies" of that time?

3.1 The Defeat of Plasma and the Victory of Rollups

"Plasma," a scaling technology that was once considered promising in early technical texts, is almost unused in 2026.

Plasma's Failure: The Data Availability Problem. Because it only wrote the hash of the data to the parent chain, if the Operator maliciously hid the data, users risked being unable to withdraw funds.
Rollup's Victory: They adopted a method of writing "transaction data (compressed)" to L1 (Ethereum) as well as processing results. This allowed them to fully inherit L1 security.

Today, Optimistic Rollups (using fraud proofs) and zk-Rollups (using zero-knowledge proofs) are the center of the ecosystem.

3.2 Account Model and Smart Contracts

Ethereum adopted the Account Model instead of UTXO. This allowed it to hold "State" on the EVM (Ethereum Virtual Machine), enabling complex applications (DApps).

EOA (Externally Owned Account): Users holding private keys.
CA (Contract Account): The code itself.

The trend in 2026 is "Account Abstraction (ERC-4337)," which makes EOAs programmable like CAs. This is solving the biggest UX challenge of Web3: "Loss of Private Key = Loss of Assets."

Chapter 4: AI × Blockchain — The Arrival of the Agentic Economy

From here, based on the knowledge from the books, I will explain the most important topic of 2026: Fusion with AI.

4.1 "Bank Accounts" for AI Agents

The books talked about "IoT × Blockchain," but the true form was "AI Agent × Blockchain."
While it is a high hurdle for humans to operate Web3 wallets, for AI, Smart Contracts are the easiest APIs to handle.

Micropayments: AI pays usage fees for inference APIs in real-time, in units of $0.0001.
Autonomous Asset Management: AI agents manage and operate their own funds using DeFi protocols.

4.2 Proof of Humanity / Content Authenticity

With Generative AI flooding the world, technology to prove "whether this was made by a human or an AI" is essential.
Blockchain (public ledger) plays a vital role here as well. By carving the hash of the creation process into the chain, the Origin of digital content becomes immutable.

Chapter 5: Cryptography in the Quantum Era

Finally, I will touch on "Quantum Resistance," a topic I am particularly watching.
While classical texts state that ECDSA (Elliptic Curve Digital Signature Algorithm) is secure, if a quantum computer capable of implementing Shor's algorithm appears, the security of current blockchains will collapse.

5.1 Specific Threats

Deriving Private Key from Public Key: ECDSA and RSA rely on the difficulty of prime factorization or discrete logarithm problems, but quantum computing can solve these in polynomial time.
Hash Function Collisions: Grover's algorithm reduces the computational complexity of hash searching to $O (N)$ (although this is said to be manageable by doubling the key length).

5.2 The 2026 Countermeasure: Migration to PQC

Currently, major chains like Ethereum are preparing to migrate to Post-Quantum Cryptography (PQC).

Lattice-based cryptography: A leading candidate for quantum resistance.
STARKs: A Zero-Knowledge Proof technology considered quantum-resistant because it relies only on hash functions.

Precisely because blockchain promises to "preserve past records forever," cryptographic design anticipating computational power 10 or 20 years from now is required today.

Conclusion: Know the Theory, Implement the Future

The mathematical beauty told in Blockchain Theory.
The gritty implementation details learned in Textbooks.
The enthusiasm for social change depicted in Revolution.

These three perspectives have not faded even in 2026. Rather, with the addition of new variables like AI and Quantum Technology, their importance has increased.

What engineers need now is the ability to oscillate between the "Micro Perspective" (understanding EVM opcodes) and the "Macro Perspective" (AI economy and Quantum resistance).

The idea of "P2P Electronic Cash" presented by Satoshi Nakamoto in the white paper is now evolving into a "Foundation for an Economic Zone where Autonomous AI flies about." If you are going to participate in this grand experiment, now might be the most exciting time.

Quantum Error Correction Zootopia

Doraking — Wed, 24 Dec 2025 15:26:56 +0000

On the journey of learning quantum computing, there is a vast labyrinth that everyone wanders into at least once. Its name is "Quantum Error Correction (QEC)".

Opening textbooks, you encounter veterans like "Shor codes" and "Surface codes," but once you venture into the sea of research papers, you find countless "new species of codes" inhabiting it. The place that comprehensively collects and classifies such codes is the Error Correction Zoo (EC Zoo), managed by Victor V. Albert and others.

Looking at this site, a certain movie's worldview suddenly overlaps. Yes, it's Zootopia.

Imagine a world where diverse animals, from small mice to giant elephants, coexist under the common law called "Stabilizer Formalism." In this article, I will liken the residents of the EC Zoo to the characters of Zootopia and introduce them along with their mathematical definitions.

1. Topological Square: The Bond of Partners

The center of the story is the duo of topological codes active on the front lines of current quantum computer development (on 2D chips).

🐰 Judy Hopps = Surface Code

"Any hardware can implement me!"
The absolute protagonist of the current QEC world. Defined only by adjacent interactions on a 2D grid, it can be implemented on many hardware platforms such as superconducting circuits and neutral atoms.

【Overview】
The surface code is defined on an $L \times L$ 2D square lattice. Physical qubits are placed on the edges (or vertices) of the lattice, and stabilizer operators are defined at vertices (Star) and faces (Plaquette).

A_{v} = i \in star (v) \prod X_{i}, B_{p} = i \in boundary (p) \prod Z_{i}

All of these commute with each other ( $[A_{v}, B_{p}] = 0$ ), and the code space $C$ is defined as the state having an eigenvalue of +1 for all stabilizers.

C = ∣ ψ ⟩ ∣ A_{v} ∣ ψ ⟩ = ∣ ψ ⟩, B_{p} ∣ ψ ⟩ = ∣ ψ ⟩, \forall v, p

Logical operators $X ˉ_{L}, Z ˉ_{L}$ are formed as strings crossing the lattice. This structure of "protecting the whole with only local checks" is exactly her straightforward investigative style.

Original Paper:
S. B. Bravyi and A. Y. Kitaev, "Quantum codes on a lattice with boundary" (1998)

🦊 Nick Wilde = Color Code

"You guys are simple black and white (X or Z), but I'm three colors."
A topological code like Judy, but with a more complex "trivalent graph (a lattice paintable with three colors)." He has the dexterity to perform specific logical gates like magic.

【Overview】
Color codes are typically defined on 2D hexagonal lattices (like honeycomb structures), where each face is painted with one of three colors (R, G, B).
Unlike the surface code, both $X$ -type and $Z$ -type stabilizers are defined for each face $f$ .

S_{X f} = i \in f \prod X_{i}, S_{Z f} = i \in f \prod Z_{i}

Nick's greatest weapon (his con-artist dexterity) is the ability to implement transversal Clifford gates.
While implementing a Hadamard gate $H$ on a normal surface code requires complex operations, on a color code, a parallel operation $H^{\otimes n}$ on each physical bit directly becomes a logical Hadamard $H ˉ$ .

H ˉ = i = 1 ⨂ n H_{i}

Original Paper:
H. Bombin and M. A. Martin-Delgado, "Topological Quantum Distillation" (2006)

2. Zootopia Police Department (ZPD): Organization and Discipline

The police department protecting the peace of the city has codes with unique but strict structures.

🐆 Benjamin Clawhauser = Steane Code

"I love donuts (holes) and CSS!"
The receptionist is the friendly $[[7, 1, 3]]$ code. A representative CSS code based on the classical Hamming code $[7, 4, 3]$ , it is a basic form loved by everyone.

【Overview】
The Steane code is a CSS code defined using a classical parity check matrix $H_{c l}$ .
For 7 physical bits, it has the following stabilizer generators:

g_{1} g_{2} g_{3} g_{4} g_{5} g_{6} = III XXXX = I XX II XX = X I X I X I X = III ZZZZ = I ZZ II ZZ = Z I Z I Z I Z

The first three are $X$ stabilizers, and the last three are $Z$ stabilizers. He is also used as a building block for Chief Bogo (mentioned later), serving as the beloved mascot and basic unit of the organization.

Original Paper:
A. M. Steane, "Error Correcting Codes in Quantum Theory" (1996)

🐃 Chief Bogo = Quantum Golay Code

"I will not tolerate any objections to my symmetry!"
A heavyweight with a massive and robust structure of [[23, 1, 7]]. A quantum version of the classical Golay code, boasting extremely high symmetry and defensive power.

【Overview】
The quantum Golay code is created from the classical "perfect code," the Golay code $G_{23}$ , using the CSS construction method.
The code parameters are $[[23, 1, 7]]$ . That is, it uses 23 qubits and has a distance of $d = 7$ (can correct up to 3 errors).

Its stabilizer group $S$ is deeply related to sporadic simple groups like the Mathieu groups $M_{23}$ and $M_{24}$ , possessing mathematically extremely beautiful (and strict) symmetry.
While lacking the flexibility of topological codes, it is an old-fashioned tough code that never lets go of an error once caught.

Original Paper:
A. M. Steane, "Error Correcting Codes in Quantum Theory" (1996)

3. City Hall and the Underworld: Light and Shadow

The powerful figures moving this city. Their abilities (formulas) are powerful and distinctive.

🦁 Mayor Lionheart = Shor Code

"I built this paradise (QEC)."
The first quantum error-correcting code in history, $[[9, 1, 3]]$ . The great founder who proved that quantum error correction is possible.

【Overview】
The Shor code is created by concatenating a 3-qubit "bit-flip code" and a "phase-flip code." The logical states $∣ 0_{L} ⟩, ∣ 1_{L} ⟩$ are described as follows:

∣ 0_{L} ⟩ ∣ 1_{L} ⟩ = \frac{( ∣000 ⟩ + ∣111 ⟩) ( ∣000 ⟩ + ∣111 ⟩) ( ∣000 ⟩ + ∣111 ⟩)}{2 2} = \frac{( ∣000 ⟩ - ∣111 ⟩) ( ∣000 ⟩ - ∣111 ⟩) ( ∣000 ⟩ - ∣111 ⟩)}{2 2}

This redundant structure became the first shield to protect quantum states from decoherence.

Original Paper:
P. W. Shor, "Scheme for reducing decoherence in quantum computer memory" (1995)

🐑 Assistant Mayor Bellwether = Bacon-Shor Code

"I look like just an assistant mayor, don't I? But I have 'gauges'."
At first glance, she looks like a normal stabilizer code, but she is a subsystem code that manipulates "gauge degrees of freedom." She has the face of a mastermind who rewrites the system behind the scenes.

【Overview】
The Bacon-Shor code has not only a normal stabilizer group $S$ but also a gauge group $G$ .
In an $L \times L$ lattice, gauge operators act on adjacent two qubits.

G_{ij X} = X_{i, j} X_{i, j + 1}, G_{ij Z} = Z_{i, j} Z_{i + 1, j}

Stabilizers are defined by products of these gauge operators (e.g., $S = G_{i, j X} G_{i, j + 1 X}$ ).
Her terror lies in the ability to apply gauge operators without destroying logical information. This is called "Gauge Fixing," allowing dynamic manipulation of the error correction procedure (or the ending of the story) depending on the situation.

Original Paper:
D. Bacon, "Operator quantum error-correcting subsystems for self-correcting quantum memories" (2006)

🐀 Mr. Big = 5-qubit Code

"Ice 'em." (Wasteful qubits, that is.)
[[5, 1, 3]]. The theoretical minimum size. The don of the underworld with perfect symmetry who allows absolutely no waste.

【Overview】
The smallest code capable of correcting a single qubit error. Its stabilizer generators have a beautiful structure created by cyclically shifting Pauli operators.

g_{1} g_{2} g_{3} g_{4} g_{5} = XZZX I = I XZZX = X I XZZ = ZX I XZ = ZZX I X

Since this code is not a CSS code, $X$ and $Z$ are mixed. Though small, it possesses the strongest correction ability, truly a "small but mighty" existence.

Original Paper:
R. Laflamme et al., "Perfect Quantum Error Correcting Code" (1996)

4. Unique Citizens: The Pinnacle of Diversity

Zootopia also has unique codes adapted to special environments.

🦥 Flash = Floquet Code

"Wait... until... the cycle... ends..."
Incomprehensible in a static picture. A dynamic code defined together with "time".

【Overview】
Floquet codes do not have a fixed stabilizer group but are defined by an Instantaneous Stabilizer Group (ISG) $S (t)$ where the measurement basis changes at each time step $t$ .
For example, on a honeycomb lattice, measurements are switched at each time step as follows:

t (mod 3) = 0 : Check XX on horizontal edges t (mod 3) = 1 : Check YY on diagonal edges t (mod 3) = 2 : Check ZZ on vertical edges

The reaction is slow (you have to wait 3 steps for information to gather), but by continuing observations, logical qubits dynamically emerge.

Original Paper:
M. B. Hastings and J. Haah, "Dynamically Generated Logical Qubits" (2021)

🦊 Finnick = GKP Code

"Thought I was a baby? I'm infinite-dimensional on the inside."
Looks like a single mode (small), but inside possesses an infinite-dimensional Hilbert space of Continuous Variables.

【Overview】
The Gottesman-Kitaev-Preskill (GKP) code is defined in the phase space of position operator $q^$ and momentum operator $p^$ .
Stabilizers are described by the following displacement operators $D (α)$ :

S_{q} = e^{i 2 π q^}, S_{p} = e^{- i 2 π p^}

The logical state (codeword) is expressed as a superposition of "grid points" in phase space.

∣ 0 ˉ ⟩ \propto n \in Z \sum ∣ q = 2 n π ⟩

A con artist of a different species (actually highly functional) with a structure fundamentally different from discrete qubits (other animals).

Original Paper:
D. Gottesman, A. Kitaev, and J. Preskill, "Encoding a qubit in an oscillator" (2001)

Conclusion: Future Star

🎤 Gazelle = qLDPC Codes

"Try Everything! (Break the limits!)"
The new era superstar breaking the trade-off between rate and distance.

【Overview】
Currently, the most attention is on Quantum Low-Density Parity-Check (qLDPC) codes.
The parity check matrix $H$ is a sparse matrix, and the weights of rows and columns are kept to a constant order.

[H_{X}, H_{Z T}] = 0, wt (ro w), wt (co l) = O (1)

Especially recent discoveries like Bivariate Bicycle codes have amazing properties where both logical bit count $k$ and distance $d$ scale linearly with physical qubit count $n$ ( $k, d \propto n$ ).
Researchers around the world are enthusiastic about her stage, which scales efficiently beyond the "limits of surface codes (area law)".

Original Paper:
S. Bravyi et al., "High-threshold and low-overhead fault-tolerant quantum memory" (2024)

The EC Zoo is updated daily, and new species are born.
By deciphering the "DNA" called mathematical formulas, the personality and survival strategy of each code become visible. I hope you will also find your favorite code at the EC Zoo.

Theory and Implementation of AlphaQuoridor

Doraking — Thu, 01 Aug 2024 15:10:39 +0000

In Japan, the board game Quoridor is not well-known. This article applies AlphaZero, a powerful deep reinforcement learning method, to Quoridor. Despite its simple design, AlphaZero has demonstrated the ability to outperform professional players in games like Go and Shogi. The goal is to deepen understanding of both the theoretical and practical aspects of AlphaZero through this application.

What is Quoridor?

According to Wikipedia, Quoridor is a French abstract board game where players aim to reach the opposite side of the board by moving their pieces and placing walls.

Quoirdor — Wikipedia

The setup and rules are as follows:

Setup:

For two players, each starts at opposite ends of the board and has ten walls. For four players, each starts in their own corner with five walls.

Gameplay:

Players take turns either moving their piece one square in any direction or placing a wall on the board. Pieces can jump over other pieces but cannot cross walls. Walls cannot completely block a player’s path.

Winning:

The first player to reach the opposite side wins.
The simple rule that walls cannot completely block paths makes the game exciting until the end.

The simple rule that walls cannot completely block paths makes the game exciting until the end.

Theory of AlphaZero

AlphaZero [1, 2] combines deep learning, search, and reinforcement learning. Let’s explore each component:

Deep Learning:

AlphaZero uses deep learning for intuition, similar to how professional players think about their best moves. It employs ResNet [3], a convolutional neural network used in image analysis. The game board, like an image, is a 2D array of information. The network can be represented as:

ResNet (s) = π (a ∣ s), v (s)

where $s$ 　is the game state, $π (a ∣ s)$ is the policy (probability of action a given state $s$ ), and $v (s)$ is the value (+1 if win,-1 if loss) of state $s$ .

Search:

Games like Shogi, Go, Othello, and Quoridor are two-player zero-sum games with perfect information. The optimal strategy can be found using the minimax method, but it is impractical due to the large number of possible moves. Instead, AlphaZero uses Monte Carlo Tree Search (MCTS) to predict future moves.

MCTS decides the next move based on the Upper Confidence Bound (UCB) value:

UCB (s, a) = Q (s, a) + c \cdot π (a ∣ s) \cdot \frac{N ( s )}{1 + N ( s , a )}

Q (s, a) = \frac{1}{N ( s , a )} i = 1 \sum N (s, a) v_{i} (s \to a s^{'})

where $Q (s, a)$ is the value estimate of action $a$ in state $s$ , averaged over the number of simulations $N (s, a)$ transitioning from state $s$ to $s^{'}$ . $N (s)$ is the total number of simulations for state $s$ . The first term of the equation emphasizes exploiting high-value actions, while the second term focuses on exploring actions that haven't been simulated much, balanced by the hyperparameter $c$ .

By repeating simulations, actions with higher $N (s, a)$ become valuable moves.

In practice, the action $a$ to be taken in a given state $s$ is determined by the probability $π (a ∣ s)$ , weighted by the Boltzmann distribution with temperature $T$ .

π (a ∣ s) = \frac{N ( s , a ) ^{1/ T}}{b \sum N ( s , b ) ^{1/ T}}

Reinforcement Learning:

AlphaZero generates training data through self-play, updating ResNet parameters with this experience to create a more intelligent neural network.

The process involves:

Initializing ResNet parameters.
Obtaining experience data through self-play.
Updating ResNet parameters with the experience data.
Repeating steps 2 and 3 multiple times.

Implementation of AlphaQuoridor

The implementation of AlphaQuoridor involves several steps, with all code available on GitHub:

https://github.com/dorakingx/AlphaQuoridor

Game design (game.py)
Deep learning implementation with ResNet (dual_network.py)
Monte Carlo Tree Search implementation (pv_mcts.py)
Data collection through self-play (self_play.py)
Updating ResNet parameters (train_network.py)
Comparing and updating the best parameters (evaluate_network.py)
Evaluating the best player (evaluate_best_player.py)
Running the entire training cycle (train_cycle.py)
Implementing a game UI to play against the AI (human_play.py)

This project references the Japanese book "AlphaZero: Deep Learning, Reinforcement Learning, and Search" for detailed explanations.

AlphaZero: Deep Learning, Reinforcement Learning, and Search Practical Introduction to Artificial Intelligence Programming

Due to the short training time, the game was trained on a 3x3 board. While this isn't very exciting gameplay-wise, the implementation allows for easy adjustment to larger board sizes, such as the actual 9x9 size, which would demonstrate the reinforcement learning capabilities better.

The actual gameplay screen when running human_play.py looks like this. The number of walls for both the player and the enemy (AI) is set to one, matching the game size. To place a wall, click "Place Wall" below, select the vertical or horizontal direction, and then click the desired location (red grid points).

Initial state

Mid-game

End-game case for winning

End-game case for losing

The AI wasn't very strong this time due to the limited training time. However, with a longer training period, a stronger AI could be developed.

Summary

This article applied AlphaZero to the lesser-known Quoridor board game. AlphaZero can be adapted to any two-player zero-sum game with perfect information by modifying the game design. This could be an interesting project to see how strong an AI can be created for different games. If you enjoyed this article, please like it, and stay tuned for more articles.

References

[1] D. Silver et al., "Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm"
[2] D. Silver et al., "A General Reinforcement Learning Algorithm That Masters Chess, Shogi, and Go through Self-Play"
[3] K. He, X. Zhang, S. Ren, and J. Sun, "Deep Residual Learning for Image Recognition"