# Teaching Quantum Computing through Lab-Integrated Learning: Bridging Conceptual and Computational Understanding
**Authors**: Umar Farooq, Krishna Upadhyay
> Louisiana State UniversityBaton RougeLAUSAufarooq@lsu.edu
> Louisiana State UniversityBaton RougeLAUSAkupadh4@lsu.edu
(2025)
Abstract.
Quantum computing education requires students to move beyond classical programming intuitions related to state, determinism, and debugging, and to develop reasoning skills grounded in probability, measurement, and interference. This paper reports on the design and delivery of a combined undergraduate and graduate course that employed a lab-integrated learning model to support conceptual change and progressive understanding. The course paired lectures with weekly programming labs that served as environments for experimentation and reflection. These labs enabled students to confront misconceptions and refine their mental models through direct observation and evidence-based reasoning. Instruction began with Quantum Without Linear Algebra (QWLA), which introduced core concepts such as superposition and entanglement through intuitive, dictionary representations. The course then transitioned to IBM Qiskit, which provided a professional framework for circuit design, noise simulation, and algorithm implementation. Analysis of student work and feedback indicated that hands-on experimentation improved confidence, conceptual clarity, and fluency across representations. At the same time, it revealed persistent challenges in debugging, reasoning about measurement, and understanding probabilistic outcomes. Our findings highlight which quantum concepts benefit most from lab-based experimentation and where programming support remains insufficient.
quantum computing, quantum programming, curriculum, case study journalyear: 2025 copyright: none
1. Introduction
Quantum computing (QC) is redefining the limits of computation by applying quantum-mechanical principles such as superposition, entanglement, and interference to process information in fundamentally new ways. These principles enable algorithms that can outperform classical methods on problems such as integer factorization (Shor, 1994), unstructured search (Grover, 1996), and molecular simulation (Low et al., 2019). As both research and industry accelerate progress toward scalable quantum hardware, the demand for a workforce proficient in both the theory and practice of quantum computing is growing rapidly.
Meeting this demand presents a distinct challenge for computer science education. Most existing quantum computing courses are offered at the graduate level and focus heavily on mathematical derivations or the physical implementation of qubits. While these topics provide theoretical depth, they often limit accessibility for students with backgrounds in programming and algorithmic reasoning. On the other hand, courses that focus solely on software may encourage superficial reproduction of circuits without fostering conceptual understanding. Addressing this gap requires pedagogical approaches that integrate experimentation with conceptual learning and link abstract ideas to computational representations.
At the Louisiana State University (LSU), we designed and taught a course titled Introduction to Quantum Computing, open to both undergraduate and graduate computer science students. The course follows a lab-integrated learning model that combines conceptual instruction with hands-on programming every week. Students begin with Quantum Without Linear Algebra (QWLA) (Albarghouthi, 2025), a lightweight simulation framework that supports intuitive engagement with core quantum ideas without requiring prior knowledge of matrix algebra. Once students build foundational fluency, the course transitions to IBM Qiskit (Wille et al., 2019) for constructing and analyzing quantum circuits and algorithms. Each weekly lab targets a specific learning objective, such as superposition, entanglement, or noise mitigation, and reinforces it through executable experiments and guided reflection.
This instructional approach aims to balance accessibility with intellectual rigor. By grounding theoretical concepts in programming and experimentation, students develop an understanding of quantum program behavior, error sources, and the relationship between abstractions and hardware execution. In this report, we share our experience designing and teaching this lab-integrated course. We describe the motivations behind its instructional design, present the core components of the curriculum, and reflect on student outcomes and feedback. Our goal is to offer a replicable framework that integrates conceptual learning and programming practice in quantum computing education.
2. Background
Traditional approaches to teaching quantum computing often emphasize theoretical foundations, typically delivered through physics or mathematics departments. Courses offered in physics programs tend to focus on the behavior of quantum systems and hardware implementation (cal, 2019; ber, 2014), while those in mathematics departments emphasize formal aspects of information theory and linear algebra (ber, 2007; wat, 2019). In both cases, assessment usually relies on written assignments, exams, and final projects presented as reports or oral presentations on selected algorithms.
These courses are generally targeted at graduate students. Undergraduate quantum computing offerings within computer science departments remain relatively uncommon (ut-, 2017; ucl, 2019). However, there has been increasing interest in developing programming-oriented and software-focused quantum computing courses that prioritize algorithmic thinking, practical experimentation, and computational abstraction. Notable examples include the University of Washington’s course Introduction to Quantum Computing and Quantum Programming in Q# (uw, 2019; Mykhailova and Svore, 2020), and the work by Seegerer and others (Seegerer et al., 2021), which explores how core ideas such as superposition, entanglement, and quantum algorithms can be taught through computing education frameworks.
These efforts represent a meaningful shift toward integrating theory with practice. Programming-based instruction has shown that active experimentation can make quantum concepts more accessible to computer science students. Nevertheless, many current courses still lack dedicated laboratory components that allow students to formulate hypotheses, visualize results, and debug their understanding through code. By comparison, classical computing education often begins with hands-on programming, then progresses toward algorithms and theory through iterative practice. Quantum computing education stands to benefit from a similar approach, where theoretical concepts are grounded in coding and experimentation rather than introduced as purely abstract content. In contrast to prior programming-oriented courses, our work places sustained, weekly laboratory experimentation at the center of conceptual development rather than as a supplement to lectures.
3. Theoretical Foundation
The course design was guided by three perspectives: (1) the core ideas that define conceptual understanding in quantum computing, (2) a learning process centered on conceptual change through experimentation and reflection, and (3) a progressive framework that moves from QWLA to Qiskit, linking intuitive understanding with practical programming experience.
3.1. Core Ideas in QC Education
Seegerer and others (Seegerer et al., 2021) identify five core ideas that underpin conceptual understanding in quantum computing: superposition, entanglement, quantum computation, quantum algorithms, and quantum cryptography. These ideas define the mental models students must develop to think quantum mechanically. For example, superposition introduces probabilistic reasoning about state, entanglement extends beyond classical correlation, and quantum algorithms demonstrate how interference and measurement can be used to amplify correct outcomes.
Traditional instruction often presents these ideas through dense mathematics or physical analogies, which can obscure their computational relevance. Our course builds on this conceptual framework by embedding each idea within a lab sequence that combines explanation, simulation, and hands-on experimentation. Students first engage with these concepts intuitively, then explore their formal structure through programming exercises that reveal their computational meaning.
3.2. Conceptual Change and Evolution
Learning quantum computing involves more than absorbing new content; it requires reconfiguring existing knowledge. Students often bring classical intuitions about computation and probability that conflict with quantum principles. For instance, they may believe that measurement reveals a pre-existing value rather than collapsing a probabilistic state, or assume that correlations imply hidden communication instead of entanglement.
<details>
<summary>x1.png Details</summary>
### Visual Description
# Technical Document Extraction: Comparison of Classical vs. Quantum Computing Concepts
This document provides a detailed technical extraction of the provided infographic, which contrasts classical computing principles with quantum computing principles. The image is structured as a 2x2 grid of conceptual blocks, separated by "not equal to" symbols ($\neq$) to denote fundamental differences.
---
## 1. Document Structure and Layout
The image is divided into two primary columns:
* **Left Column (Blue Label):** Classical
* **Right Column (Green Label):** Quantum
The image contains four distinct modules (two per column) that compare specific states and behaviors. Red "not equal to" symbols ($\neq$) are positioned centrally between the left and right modules to indicate that the concepts are not equivalent.
---
## 2. Component Analysis
### Region 1: State Representation (Top Row)
| Feature | Classical (Top-Left) | Quantum (Top-Right) |
| :--- | :--- | :--- |
| **Primary Label** | *Classic bit* | *qubit* |
| **Visual Representation** | Two distinct circles: a blue circle containing "0" and a red circle containing "1". | A single translucent sphere containing a cloud of small red and blue dots. |
| **State Description** | State: Either 0 or 1 | State: Both 0 and 1 |
| **Technical Term** | Binary | Superposition |
**Trend/Logic Check:** The classical side shows a discrete choice between two states. The quantum side shows a unified sphere where both states coexist simultaneously, representing the transition from discrete bits to probabilistic qubits.
---
### Region 2: Probability and Observation (Bottom Row)
| Feature | Classical (Bottom-Left) | Quantum (Bottom-Right) |
| :--- | :--- | :--- |
| **Primary Label** | Classical Probability | Measurement Collapse |
| **Visual Representation** | A black line icon of a bar chart with an upward-sloping arrow. | An illustration of a cat in a box with question marks (Schrödinger's cat), an arrow pointing to a "0" in a circle, and an eye icon labeled "OBSERVER". |
| **Technical Flow** | Represents standard statistical outcomes and predictable growth. | Represents the process where a quantum state (cat in box) collapses into a single state (0) upon observation. |
**Trend/Logic Check:** The classical side uses a standard mathematical chart to represent probability. The quantum side uses a narrative diagram to show that the act of "Observation" forces a system out of superposition into a definite state.
---
### 3. Textual Transcriptions
#### Left Column (Classical)
* **Header (Top Box):**
* *Classic bit*
* 0 (inside blue circle)
* 1 (inside red circle)
* State: Either 0 or 1
* Binary
* **Footer (Bottom Box):**
* Classical Probability
* **Column Label:** Classical (in blue text)
#### Right Column (Quantum)
* **Header (Top Box):**
* *qubit*
* State: Both 0 and 1
* Superposition
* **Footer (Bottom Box):**
* Measurement Collapse
* OBSERVER (next to an eye icon)
* **Column Label:** Quantum (in green text)
---
## 4. Summary of Key Data Points
* **The "Not Equal" ($\neq$) Relationship:** The diagram explicitly states that Binary states $\neq$ Superposition, and Classical Probability $\neq$ Measurement Collapse.
* **Color Coding:**
* **Blue/Red:** Used to distinguish the "0" and "1" states in both classical and quantum representations.
* **Blue Text:** Used for the "Classical" category label.
* **Green Text:** Used for the "Quantum" category label.
* **Red Symbols:** Used for the mathematical "not equal" signs to highlight the contrast.
</details>
Figure 1. Classical versus quantum computational models. A side-by-side comparison showing how classical bits exist in definite states of 0 or 1, while quantum qubits exist in superposition of both states until measurement collapses the state to a single outcome. This illustrates the fundamental shift from deterministic classical reasoning to probabilistic quantum reasoning that students must develop.
Figure 1 illustrates this shift in perspective by comparing classical and quantum models of computation. In classical reasoning, a bit exists in a definite state, either 0 or 1. A qubit can exist in a superposition of both states until it is measured. Measurement collapses the superposition, producing a single outcome. The figure highlights how classical views based on determinism and discrete probability differ from quantum reasoning, where computation depends on amplitudes, interference, and probabilistic results.
The course supports this conceptual evolution by placing students in situations where classical assumptions are challenged through direct experimentation. Each lab provides opportunities for students to observe mismatches between their expectations and actual quantum behavior, which encourages reflection and refinement of their mental models. Experiences such as seeing measurement collapse or encountering non-classical correlations in code serve as turning points that deepen understanding.
This process reflects the broader concept of conceptual change in science education. Students move from initial, often classical, interpretations to more accurate quantum models. In our course, this conceptual evolution was operationalized through labs that required students to predict outcomes, run experiments, and reconcile discrepancies between expectation and observation.
3.3. Progressive Shift to Quantum Programming
Teaching quantum programming presents several fundamental challenges that differ from classical programming. (1) Quantum basis states cannot be directly inspected or debugged, because measurement collapses the state and eliminates traditional feedback mechanisms. (2) Students must reason across multiple representations, including Dirac notation, matrices, Bloch sphere visualizations, and circuit diagrams, with each offering a distinct perspective on quantum operations. (3) Entanglement introduces non-local dependencies, which undermine the modular reasoning that is central to classical programming. (4) Correctness cannot be inferred from single runs. Due to probabilistic outputs and noise, repeated trials and comparison with theoretical expectations are required.
These constraints motivated our decision to introduce quantum programming gradually, using early labs to build intuition before requiring students to reason about full-scale circuits and algorithms. The course begins with QWLA, which offers an accessible introduction for students with limited backgrounds in quantum mechanics. QWLA enables students to model key phenomena, such as superposition, measurement, and entanglement, using simple Python constructs. This stage builds foundational intuition without requiring advanced mathematics, allowing all students to meaningfully engage with early course content.
Following the introductory phase, the course transitions to IBM Qiskit, which serves as the primary platform for quantum algorithm design, circuit implementation, and experimental analysis. Qiskit offers a professional-grade development environment that enables students to translate conceptual understanding into executable quantum programs. Through systematic comparison of simulation outputs with theoretical predictions, students develop the ability to interpret algorithmic behavior, assess the influence of noise, and reason about computational performance.
This progression from intuitive modeling in QWLA to formal development in Qiskit demonstrates how effective scaffolding can lower entry barriers while guiding students toward conceptual maturity. The integration of core ideas, conceptual evolution, and graduated tooling forms the theoretical foundation of our lab-integrated approach to quantum computing education. As discussed in Section 6, this progression revealed both benefits and limitations.
4. Instructional Design
Building on the theoretical foundations described earlier, the instructional design emphasized accessibility, experimentation, and progressive abstraction. The goal was not only to introduce the mechanics of quantum programming but also to help students internalize the reasoning behind quantum phenomena through guided observation and reflection.
4.1. Learning Approach
The course followed a lab-integrated learning model in which lectures and labs were closely connected. Each week included one 80-minute lecture and one 80-minute lab session. Lectures introduced key ideas and demonstrated important algorithms and principles. Labs provided guided opportunities for students to apply, test, and extend those ideas. This structure enabled conceptual understanding and computational skills to develop in parallel.
To make the course accessible, instruction began with QWLA, which allowed students to explore foundational concepts such as superposition, measurement, and entanglement using intuitive, code-based representations. Initially, quantum states were introduced as Python dictionaries that mapped basis states to amplitudes, providing a simple and concrete way to reason about superposition and measurement without requiring matrix algebra. This representation helped students visualize state transformations and probabilities in a familiar programming context. After students became comfortable with these behaviors, the course transitioned to IBM Qiskit, which served as the main platform for designing algorithms, building circuits, and running experiments. This progression allowed students to move from informal reasoning to formal implementation, connecting conceptual learning with practical skill development. While this progression was designed to reduce early cognitive load, Sec. 6 reflects on the trade-offs introduced by transitioning between frameworks.
Each lab was explicitly aligned with the concepts introduced in the corresponding lecture. For example, after covering entanglement and measurement correlations, students built and tested Bell-state circuits, analyzed measurement results, and explored the effects of noise and decoherence. These lab activities served as formative checkpoints that helped students connect code and circuits with quantum behavior.
4.2. Course Structure
The course was offered over sixteen weeks to both undergraduate and graduate students who had completed an introductory algorithms course. No prior background in quantum mechanics was required. The curriculum (Table 1) advanced gradually from foundational concepts to more complex algorithms and applications, balancing theoretical instruction with experimental practice.
Table 1. Weekly lecture topics and laboratory activities
| Qubits, superposition, and measurement | Exploring single-qubit states using QWLA |
| --- | --- |
| Entanglement and correlations | Building and testing Bell states |
| Phase and interference | Phase kickback |
| Quantum circuits and the Deutsch-Jozsa algorithm | IBM Qiskit circuits and implementing Deutsch-Jozsa |
| Grover’s search | Comparing quantum and classical search performance |
| Noise, and error mitigation | Simulating noise models in Qiskit |
| Quantum Fourier Transform and Phase Estimation | Coding QFT and analyzing frequency outputs |
| Shor’s algorithm and applications | Factorization and scaling analysis |
A two-column table showing the alignment between weekly lecture topics and corresponding laboratory activities. The table progresses from foundational concepts like qubits and superposition to advanced algorithms like Shor’s algorithm, demonstrating the gradual increase in complexity throughout the sixteen-week course.
This structure reinforced the idea that each theoretical topic should have a corresponding experimental activity. The gradual increase in complexity helped students build algorithmic thinking alongside scientific reasoning about quantum systems.
4.3. Assessment and Learning Outcomes
Assessment combined formative and summative methods to evaluate both conceptual understanding and technical proficiency. Laboratory assignments were assessed automatically using provided testing scripts. The final project required teams of two or three students to design, implement, and evaluate a quantum algorithm or application. Project presentations were evaluated manually based on implementation quality, conceptual insight, and clarity of communication. Example projects included executing Grover’s search under noisy conditions and developing small-scale quantum optimization tasks. Additional assessment components included quizzes, a midterm examination, and class participation.
By the end of the course, students were expected to:
- Explain core quantum concepts such as superposition, entanglement, and measurement using both descriptive and computational reasoning.
- Design and implement quantum circuits and algorithms using Qiskit.
- Analyze the effects of noise, error, and decoherence on quantum computation.
- Relate theoretical operations to their practical implementations and observable outcomes.
The alignment between lectures and labs, along with the gradual progression from intuitive simulation to professional development tools, created a learning environment in which students engaged with quantum computing through experimentation, analysis, and reflection.
5. Implementation and Delivery
The course was delivered over a sixteen-week semester in Fall 2025. It enrolled 9 undergraduate and 6 graduate students in computer science and software engineering. The class met twice weekly, with one 80-minute lecture focused on conceptual foundations and algorithm design, followed by an 80-minute lab session dedicated to hands-on programming and experimentation.
5.1. Student Background
A pre-course survey assessed student preparation across demographics, programming experience, mathematical foundations, and quantum computing familiarity. Most students were senior undergraduates or early-career graduate students seeking exposure to emerging computing paradigms. Figure 2 shows the distribution across academic levels, with fourth-year and beyond undergraduates forming the largest cohort.
<details>
<summary>x2.png Details</summary>
### Visual Description
# Technical Document Extraction: Student Distribution by Academic Level and Year
## 1. Image Overview
This image is a stacked bar chart illustrating the distribution of students across three academic levels, further categorized by their year of study. The chart uses color-coded segments to represent different years and provides numerical labels for both individual segments and total counts per category.
## 2. Component Isolation
### A. Header / Legend
* **Location:** Top-center [approx. x=0.5, y=0.15 relative to the chart area].
* **Title:** "Year"
* **Categories & Colors:**
* **1st Year:** Blue (#0072B2)
* **2nd Year:** Gold/Yellow (#E69F00)
* **3rd Year:** Green (#009E73)
* **4th Year+:** Burnt Orange (#D55E00)
### B. Main Chart Area (Axes)
* **Y-Axis Label:** "Number of Students"
* **Y-Axis Scale:** 0 to 10, with major tick marks every 2 units (0, 2, 4, 6, 8, 10). Horizontal dashed grid lines extend from these ticks.
* **X-Axis Label:** "Academic Level"
* **X-Axis Categories:** Undergraduate, Masters, PhD.
### C. Data Visualization (Stacked Bars)
The chart consists of three vertical bars. Each bar has a total count label in **bold black text** at the top and individual segment counts in **white text** centered within the colored blocks.
---
## 3. Data Table Reconstruction
| Academic Level | 1st Year (Blue) | 2nd Year (Gold) | 3rd Year (Green) | 4th Year+ (Orange) | Total Students |
| :--- | :---: | :---: | :---: | :---: | :---: |
| **Undergraduate** | 0 | 1 | 1 | 8 | **10** |
| **Masters** | 1 | 1 | 1 | 2 | **5** |
| **PhD** | 2 | 3 | 2 | 0 | **7** |
---
## 4. Trend Verification and Analysis
### Undergraduate Trend
* **Visual Trend:** Heavily skewed toward senior students. The "4th Year+" segment dominates the bar, taking up 80% of the total height.
* **Composition:** There are no 1st-year students shown. The population is primarily 4th Year+ (8), with minimal representation in 2nd and 3rd years (1 each).
### Masters Trend
* **Visual Trend:** Relatively even distribution with a slight lean toward later years. This is the shortest bar in the chart.
* **Composition:** A total of 5 students. The distribution is nearly uniform: 1st Year (1), 2nd Year (1), 3rd Year (1), and 4th Year+ (2).
### PhD Trend
* **Visual Trend:** Skewed toward early-to-mid-stage students. Unlike the other categories, there are no students in the "4th Year+" category for PhDs in this dataset.
* **Composition:** A total of 7 students. The largest group is 2nd Year (3), followed by an equal split between 1st Year (2) and 3rd Year (2).
---
## 5. Summary of Facts
* **Total Student Population:** 22 students (10 Undergraduate + 5 Masters + 7 PhD).
* **Largest Single Group:** Undergraduate 4th Year+ students (8).
* **Smallest Non-Zero Groups:** Undergraduate 2nd/3rd Year and Masters 1st/2nd/3rd Year (all with 1 student).
* **Absences:** There are 0 1st-year Undergraduates and 0 4th Year+ PhD students represented in the data.
</details>
Figure 2. Student enrollment by academic level and year. A stacked bar chart showing student distribution across three academic levels: Undergraduate, Masters, and PhD. The Undergraduate category shows 8 students in fourth year or beyond and 2 in earlier years. The Masters category shows 5 students, and the PhD category shows 7 students. The chart demonstrates that most enrollees were advanced undergraduates or graduate students.
Programming proficiency varied considerably. Python was the most common language, with most students rating their skills as intermediate. Figure 3 shows language preferences and Python comfort levels. Nearly all students had prior experience with Jupyter Notebooks, which aligned well with the lab-based format.
<details>
<summary>x3.png Details</summary>
### Visual Description
# Technical Data Extraction: Programming Language Proficiency and Python Comfort Level
This document provides a comprehensive extraction of the data contained within the provided image, which consists of a horizontal bar chart and a segmented progress bar.
## 1. Component Isolation
The image is divided into two primary sections:
* **Main Chart (Top):** A horizontal bar chart showing the distribution of students across different programming languages.
* **Footer Legend/Scale (Bottom):** A segmented bar representing the "Python Comfort Level" of the surveyed group.
---
## 2. Main Chart: Programming Language Distribution
### Chart Specifications
* **Type:** Horizontal Bar Chart.
* **X-Axis Label:** "Number of Students"
* **X-Axis Scale:** 0 to 20, with major markers and vertical dashed grid lines at intervals of 5 (0, 5, 10, 15, 20).
* **Y-Axis Labels:** Programming language names.
### Data Table Extraction
The bars are arranged in descending order of frequency.
| Programming Language (Y-Axis) | Bar Color | Numerical Value (Label) | Visual Trend Check |
| :--- | :--- | :--- | :--- |
| **Python** | Blue | **17** | Longest bar; extends past the 15 grid line. |
| **Java** | Orange/Gold | **13** | Second longest; ends between 10 and 15. |
| **C / C++** | Green | **11** | Third longest; ends just past the 10 grid line. |
| **JavaScript** | Burnt Orange | **5** | Fourth longest; aligns exactly with the 5 grid line. |
| **Rust** | Purple | **1** | Shortest bar; ends just past the 0 marker. |
---
## 3. Footer: Python Comfort Level
This section uses a segmented horizontal bar to represent the proficiency levels specifically for Python.
### Segmented Bar Data
The total represents 100% of the Python-using cohort.
| Category | Segment Color | Percentage | Spatial Position |
| :--- | :--- | :--- | :--- |
| **Beginner** | Burnt Orange | **18%** | Leftmost segment |
| **Intermediate** | Gold/Orange | **64%** | Center (largest) segment |
| **Advanced** | Green | **18%** | Rightmost segment |
### Text Transcription
* **Header Label:** "Python Comfort Level" (located to the left of the bar).
* **Category Labels:** "Beginner", "Intermediate", "Advanced" (located directly beneath their respective segments).
---
## 4. Summary of Key Findings
* **Dominant Language:** Python is the most popular language among the students surveyed, with 17 individuals.
* **Least Common Language:** Rust is the least common, with only 1 student.
* **Python Proficiency:** The vast majority of Python users (64%) identify as "Intermediate," while the "Beginner" and "Advanced" groups are equally represented at 18% each.
* **Total Sample Size (Calculated):** Based on the bar chart, the total number of student responses across all languages is 47 (17+13+11+5+1). Note: This assumes students chose only one primary language.
</details>
Figure 3. Programming language preferences and Python proficiency. Two horizontal charts showing programming background. The top chart displays absolute counts for preferred languages, with Python most prevalent at 17 students, followed by Java, C and C++, JavaScript, and Rust. The bottom chart shows Python comfort levels as proportions, with 64 percent at intermediate level, 23 percent advanced, and 14 percent beginner.
Mathematical preparation was mixed. Nearly all students had taken linear algebra, though most reported it was from several years earlier. Table 2 summarizes comfort levels with linear algebra and probability. Most students reported moderate comfort, suggesting that targeted review would be beneficial throughout the course. Almost no students had formal quantum mechanics training beyond introductory physics.
Table 2. Mathematical preparation and comfort levels
| Linear Algebra - Course Taken: | |
| --- | --- |
| Yes, recently | 18% |
| Yes, but long ago | 82% |
| No | 0% |
| Linear Algebra - Comfort Level: | |
| Slightly comfortable | 14% |
| Somewhat comfortable | 41% |
| Comfortable | 32% |
| Very Comfortable | 14% |
| Probability & Statistics - Comfort Level: | |
| Not comfortable at all | 9% |
| Slightly comfortable | 9% |
| Somewhat comfortable | 41% |
| Comfortable | 32% |
| Very Comfortable | 9% |
A table showing mathematical background preparation for 22 students. Most students took linear algebra long ago rather than recently. Comfort levels for both linear algebra and probability cluster around somewhat comfortable and comfortable, with few students at either extreme. This indicates moderate mathematical preparation that would benefit from supplementary review.
Student familiarity with quantum concepts was limited at the start. Figure 4 shows awareness decreased for more advanced concepts. Most students had heard of qubits but did not understand them. Familiarity with superposition and entanglement was weaker, and knowledge of quantum algorithms was minimal. This distribution confirmed the need to build algorithmic understanding from foundational principles.
<details>
<summary>x4.png Details</summary>
### Visual Description
# Technical Data Extraction: Student Familiarity with Quantum Computing Concepts
## 1. Image Overview
This image is a grouped bar chart illustrating the self-reported familiarity levels of students regarding four specific concepts in quantum computing. The data is presented as a percentage of the total student population surveyed.
## 2. Component Isolation
### A. Header / Legend
* **Location:** Top-center, slightly right-aligned within the chart area.
* **Title:** "Familiarity Level"
* **Categories (Color-Coded):**
* **Blue (#0072B2):** Never heard of it
* **Yellow/Gold (#E69F00):** Heard but don't understand
* **Green (#009E73):** Somewhat familiar
* **Orange (#D55E00):** Comfortable with the idea
* **Pink/Purple (#CC79A7):** Very comfortable
### B. Main Chart Area (Axes)
* **Y-Axis Title:** Percentage of Students (%)
* **Y-Axis Scale:** 0 to 60, with major tick marks and light-gray dashed grid lines every 10 units (0, 10, 20, 30, 40, 50, 60).
* **X-Axis Categories:**
1. Qubit
2. Superposition
3. Entanglement
4. Quantum Algorithms
## 3. Data Table Reconstruction
The following table represents the estimated numerical values based on the bar heights relative to the Y-axis grid lines.
| Concept | Never heard of it (Blue) | Heard but don't understand (Gold) | Somewhat familiar (Green) | Comfortable with the idea (Orange) | Very comfortable (Pink) |
| :--- | :---: | :---: | :---: | :---: | :---: |
| **Qubit** | ~9% | 50% | ~23% | ~14% | ~5% |
| **Superposition** | ~14% | ~36% | ~32% | ~9% | ~9% |
| **Entanglement** | ~27% | ~36% | ~23% | ~9% | ~5% |
| **Quantum Algorithms** | ~32% | 50% | ~18% | 0% | 0% |
## 4. Trend Analysis and Observations
### General Trends
* **Dominant Category:** Across all four concepts, the most common response is "Heard but don't understand" (Gold), peaking at 50% for both "Qubit" and "Quantum Algorithms."
* **Low Advanced Proficiency:** The "Very comfortable" (Pink) and "Comfortable with the idea" (Orange) categories consistently represent the smallest portions of the student population, never exceeding 15% individually.
* **Knowledge Gap:** There is a visible trend where more complex or specific topics (like Quantum Algorithms) show a higher percentage of students who have "Never heard of it" compared to foundational terms like "Qubit."
### Concept-Specific Observations
* **Qubit:** Shows the highest level of "awareness" (lowest "Never heard of it" at ~9%), but the majority (50%) still lack understanding.
* **Superposition:** This concept has the highest "Somewhat familiar" rating (~32%) compared to the other three topics, suggesting it may be a more frequently explained introductory concept.
* **Entanglement:** Shows a relatively high "Never heard of it" rate (~27%) compared to Qubit and Superposition.
* **Quantum Algorithms:** This category shows the most significant lack of depth. While 50% have heard of it, ~32% have never heard of it, and 0% of students reported being "Comfortable" or "Very comfortable" with the idea.
## 5. Technical Metadata
* **Language:** English (100%)
* **Visual Style:** Scientific/Academic bar chart with a clean white background and dashed horizontal grid lines for readability.
* **Color Palette:** High-contrast qualitative color scheme (likely Colorblind-friendly).
</details>
Figure 4. Pre-course familiarity with quantum computing concepts. A grouped bar chart showing familiarity levels across four quantum concepts: Qubit, Superposition, Entanglement, and Quantum Algorithms. For each concept, five bars represent levels from never heard of it to very comfortable. The most common response across concepts is heard but don’t understand, ranging from 36 to 50 percent. Familiarity decreases for more advanced concepts, with Quantum Algorithms showing 32 percent who never heard of it and zero percent very comfortable.
Students expressed primary interest in machine learning applications of quantum computing, followed by optimization and cryptography. Several voiced concerns about mathematical prerequisites and the perceived difficulty of quantum mechanics, which informed our emphasis on computational intuition and hands-on experimentation in early weeks. A teaching assistant provided individualized support during lab sessions to address setup issues and technical questions.
5.2. Lecture and Laboratory Format
Lectures introduced theoretical foundations through visualizations and live coding demonstrations. For example, superposition and interference were illustrated with diagrams and probability plots before step-by-step implementation in code. All materials, including slides and annotated Jupyter notebooks, were made available after each session for self-paced review. The format emphasized intuitive understanding before practical implementation and formal mathematics.
Laboratory sessions were designed to extend lecture material through structured experimentation and were informed by prior work on quantum computing education. Early labs employed QWLA to introduce qubits, superposition, and measurement using dictionary-based representations, allowing students to develop intuition without reliance on matrix algebra. Beginning in week four, IBM Qiskit served as the primary platform for circuit construction and algorithm simulation, with an automated testing framework providing immediate feedback on correctness. In line with recommendations by Mykhailova and Svore (Mykhailova and Svore, 2020), all laboratory sessions included in-person teaching assistant support from an individual with quantum computing experience. Student feedback consistently identified teaching assistant availability as a valuable component of the course, particularly for addressing technical issues and supporting debugging during laboratory exercises.
5.3. Student Progress and Confidence
By mid-semester, most students reported feeling somewhat to extremely confident with the material. Understanding of qubits, gates, and measurement was rated well or very well. Entanglement and different representations received slightly lower but still positive ratings. Labs were identified as the most effective component, with students valuing how they reinforced lecture concepts through independent application. Several students noted that creating specific quantum states independently required deep understanding of gate operations.
The most challenging aspects at this stage included creating custom quantum states by combining gates and understanding multi-qubit operations. Technical setup issues consumed significant time in early labs, reducing time for actual problem solving. After the initial learning curve, students found the process more manageable. Some found the custom QWLA API awkward before transitioning to Qiskit, though this early phase proved valuable for building intuition.
Students suggested more examples in slides showing gate operations and their internal workings. They also recommended better integration between lectures and labs, such as dedicating time in the first lecture to review lab logistics and setup. This would allow teaching assistants to focus on conceptual support rather than troubleshooting basic technical issues.
5.4. Final Projects and Presentations
The course concluded with team-based final projects where students investigated topics related to quantum algorithms or applications. Example topics included comparing classical and quantum search, analyzing noise mitigation strategies, and implementing small-scale QAOA instances. Each team maintained a GitHub repository with code, documentation, and analysis. Projects were evaluated on implementation correctness, communication clarity, originality, and depth of reflection. The final two sessions featured student presentations demonstrating their work and discussing development challenges.
5.5. Post-Course Outcomes
End-of-semester surveys revealed strong understanding of foundational topics. Nearly all students strongly agreed they understood the difference between classical bits and qubits, could describe basic quantum gates, and could explain superposition, entanglement, and measurement outcomes. Students expressed confidence in using both QWLA and IBM Qiskit to build and run quantum circuits.
Understanding of advanced topics showed more variation. Table 3 summarizes student confidence across complex concepts. Most students agreed or strongly agreed they understood Grover’s algorithm and amplitude amplification. Phase estimation in Shor’s algorithm and noise mitigation received more mixed responses, with some indicating only moderate understanding. Understanding of quantum threats to cryptography and post-quantum algorithms was strong overall.
Table 3. Understanding of advanced quantum topics
| Phase estimation in Shor’s | 0% | 10% | 10% | 50% | 30% |
| --- | --- | --- | --- | --- | --- |
| Grover’s amplitude amplification | 0% | 10% | 30% | 20% | 40% |
| Noise and error mitigation | 0% | 0% | 30% | 40% | 20% |
| Quantum threats to RSA/ECC | 0% | 0% | 0% | 40% | 50% |
| Post-quantum algorithms | 0% | 10% | 10% | 50% | 20% |
A table showing student self-reported understanding of five advanced quantum computing topics. Each row represents a topic with percentage distributions across five agreement levels. Most responses cluster in the agree and strongly agree categories, though phase estimation, noise mitigation, and Grover’s algorithm show more neutral responses than cryptography-related topics. No topic received any strongly disagree responses.
Course design and delivery received highly positive ratings. Figure 5 shows student satisfaction across five key aspects. Nearly all students agreed or strongly agreed that pacing was appropriate, connections between materials were clear, and instructor feedback was timely. Visuals and circuit diagrams were particularly valued for aiding understanding. Integration of IBM Qiskit resources received unanimous positive feedback.
<details>
<summary>x5.png Details</summary>
### Visual Description
# Technical Document Extraction: Student Feedback Survey Results
## 1. Component Isolation
* **Header (Legend):** Located at the top of the image, spanning the width of the chart. It defines five Likert-scale categories with associated colors.
* **Main Chart (Body):** A horizontal stacked bar chart showing five distinct survey questions/statements on the Y-axis and percentages on the X-axis.
* **Footer (X-Axis Label):** Located at the bottom, defining the unit of measurement.
---
## 2. Legend Data (Spatial Grounding: Top Center)
The legend maps colors to sentiment levels. The categories are ordered from negative to positive sentiment (left to right):
| Color | Label |
| :--- | :--- |
| **Dark Blue** | Strongly disagree |
| **Golden Yellow** | Disagree |
| **Teal Green** | Neutral |
| **Burnt Orange** | Agree |
| **Lavender/Pink** | Strongly agree |
---
## 3. Chart Data Extraction
The chart displays the "Percentage of Students (%)" on the X-axis, ranging from 0 to 100 with markers every 20 units.
### Data Table Reconstruction
| Survey Statement (Y-Axis) | Strongly disagree (Blue) | Disagree (Yellow) | Neutral (Teal) | Agree (Orange) | Strongly agree (Pink) |
| :--- | :---: | :---: | :---: | :---: | :---: |
| **Qiskit integration helpful** | 0% | 0% | 0% | 10% | 90% |
| **Visuals helpful** | 0% | 0% | 0% | 20% | 80% |
| **Feedback timely** | 0% | 10% | 10% | 30% | 50% |
| **Connection clear** | 0% | 10% | 0% | 30% | 60% |
| **Pacing appropriate** | 0% | 10% | 10% | 40% | 40% |
---
## 4. Trend Verification and Analysis
### Overall Sentiment
The visual trend across all five categories is heavily skewed toward the right (positive sentiment). The "Strongly agree" (Pink) and "Agree" (Orange) segments dominate every bar, while "Strongly disagree" (Blue) is entirely absent (0%) from all responses.
### Category Specifics
1. **Qiskit integration helpful:** This item received the highest satisfaction rating, with 100% positive sentiment (90% Strongly agree, 10% Agree).
2. **Visuals helpful:** Highly positive, with 100% of students agreeing or strongly agreeing (80% Strongly agree).
3. **Connection clear:** Shows 90% total agreement, with a small 10% "Disagree" segment. Notably, there were no "Neutral" responses for this item.
4. **Feedback timely:** Shows 80% total agreement. This item, along with "Pacing," has the highest diversity of opinion, including 10% Neutral and 10% Disagree.
5. **Pacing appropriate:** While still majority positive (80% total agreement), this item has the lowest "Strongly agree" percentage (40%) and the highest "Agree" percentage (40%), suggesting pacing is the most varied experience among students.
---
## 5. Axis and Labels
* **X-Axis Title:** Percentage of Students (%)
* **X-Axis Markers:** 0, 20, 40, 60, 80, 100
* **Y-Axis Labels (Statements):**
* Qiskit integration helpful
* Visuals helpful
* Feedback timely
* Connection clear
* Pacing appropriate
</details>
Figure 5. Student ratings of course design and delivery. A horizontal stacked bar chart showing satisfaction ratings for five course aspects using a five-point Likert scale. Qiskit integration received 90 percent strongly agree and 10 percent agree. Visual aids received 80 percent strongly agree and 20 percent agree. Connection between materials received 60 percent strongly agree, 30 percent agree, and 10 percent disagree. Timely feedback received 50 percent strongly agree, 30 percent agree, 10 percent neutral, and 10 percent disagree. Appropriate pacing received 40 percent each strongly agree and agree, with 10 percent each neutral and disagree. All aspects show predominantly positive responses with no strongly disagree ratings.
The most engaging topics varied by student interest. The Deutsch-Jozsa algorithm was frequently cited for demonstrating quantum speedup and connecting well from lecture to lab. Grover’s algorithm appealed to many due to practical applications, though some acknowledged difficulty creating oracles and quantum circuit versions of classical verification logic. Foundational content on qubits and gates was appreciated for establishing groundwork. Transpilation and circuit optimization topics interested students who enjoyed seeing how circuits transformed for execution on different backends. Shor’s algorithm engaged students curious about modular exponentiation, period finding, and factor extraction.
The most challenging aspects included cryptography sections, Lab 6 on implementing quantum circuits for function evaluation, and mathematical foundations underlying algorithms. Several students noted a difficulty spike between course halves, with later topics demanding more linear algebra and complex number knowledge. Lab 6 stood out for difficulty in defining functions as quantum circuits and converting binary operations to quantum gates. The first lab was challenging due to limited initial understanding of Qiskit, though it seemed less difficult in retrospect. Final project scoping was challenging, particularly identifying novel contributions with limited subject knowledge.
Students overwhelmingly found hands-on labs extremely useful for learning and reported feeling extremely confident implementing small quantum circuits from scratch. Many expressed pride in mastering the Qiskit library and gaining skills valuable for quantum-related positions. Understanding quantum gates and grasping classical components of Shor’s algorithm were identified as significant accomplishments. Several felt confident in fundamentals and capable of independently investigating algorithms beyond course content.
Phase estimation and Fourier transforms remained unclear for some due to reliance on linear algebra not covered deeply. Phase kickback mechanics, particularly why circuits must be reversed, needed more clarity. Aspects of quantum-safe cryptography and Grover’s algorithm implementation required further explanation. Most students indicated likelihood to continue exploring quantum computing, and all either recommended the course or might recommend it with reservations.
Key suggestions for improvement included starting with Qiskit earlier rather than using QWLA, better alignment between lectures and labs in early weeks, more foundational linear algebra material on tensor products and state representations, less guided labs requiring more independent problem solving, improved final project guidance with concrete examples and clearer scope expectations, and adjusted pacing to allow more time for advanced topics in the second half.
5.6. Assessment Results and Performance Analysis
Assessment combined formative and summative methods, with laboratory assignments contributing the largest portion of the final grade, followed by the final project, an examination, quizzes, and participation. Graduate students performed consistently well across all assessments, with everyone earning A or above. In contrast, undergraduate performance showed greater variation, with final grades ranging from C- to A+. Only one undergraduate student achieved A+, two earned A, and the remaining students received grades between C- and A-. This performance gap reflected differences in mathematical preparation and study habits.
Designing effective laboratory exercises presented notable challenges. Labs needed to be accessible enough for completion within the allocated time while requiring genuine engagement with quantum concepts. To address this, lab exercises provided skeleton code with clearly marked sections for student implementation and inline hints about appropriate quantum operations. This scaffolding achieved high completion rates, but some students felt that the labs were too guided and wished for more independent problem-solving.
Lab 6 proved to be the most challenging one. This lab required students to implement quantum oracles for hash function evaluation. Although students understood the conceptual requirements for reversible computation and could explain oracle purposes, translating this understanding into correct gate sequences proved extremely difficult. The primary challenge was converting classical boolean logic into reversible quantum circuits. While students generally understood the intended behavior of the oracles, they struggled with constructing them using quantum gates. We noticed an interesting pattern that students often demonstrated solid conceptual understanding in quizzes and explanations, but struggled to translate that understanding into working code. This gap between conceptual knowledge and implementation ability appeared across multiple topics, suggesting that quantum programming requires explicit attention to the translation between understanding and practice.
6. Lessons Learned
The first offering of this course provided several insights into how students engage with quantum computing in a lab-integrated instructional setting. The lessons below are ordered by instructional significance, based on their observed impact on student learning and their implications for future course design. Evidence was drawn from pre-course surveys, mid-semester feedback, end-of-semester surveys, written reflections, assignment outcomes, and instructional observations.
Lesson 1: Conceptual Understanding Does Not Translate Directly to Implementable Quantum Programs. The most consequential observation was a persistent gap between students’ conceptual understanding of quantum principles and their ability to implement those principles correctly in code. Many students exhibited solid understanding of superposition, entanglement, and measurement in quizzes and written explanations. However, they frequently encountered difficulty when translating this understanding into correct quantum circuits. This gap was particularly evident in tasks involving multi-qubit composition and reversible logic.
These observations indicate that quantum programming involves skills that extend beyond conceptual knowledge. Students must reason at the level of individual gates, track qubit states across circuit execution, manage qubit indexing, decide when measurements are appropriate, and interpret probabilistic outcomes. Such abilities did not emerge automatically from conceptual mastery and therefore require deliberate instructional attention through practice and feedback.
Lesson 2: Oracle Implementation Presents Distinct Challenges. Oracle construction emerged as the most challenging programming task in the course. Lab 6, which required students to implement quantum oracles for hash-based evaluation, resulted in lower performance and greater difficulty relative to other labs. Although students generally understood the conceptual role of oracles within quantum algorithms, many struggled to convert classical boolean logic into reversible quantum circuits.
Students often attempted to directly map classical control flow into quantum circuits, resulting in incorrect or non-reversible implementations. Debugging these errors proved difficult, as mistakes frequently became apparent only when the oracle was composed within a larger algorithm such as Grover’s search. These observations suggest that oracle implementation introduces conceptual and practical challenges that differ from earlier quantum programming tasks. Future offerings will address this gap by introducing targeted preparatory activities focused on reversible computation and incremental oracle construction prior to full algorithmic integration.
Lesson 3: Transitions Between Programming Frameworks Introduce Cognitive Overhead. Beginning the course with QWLA and later transitioning to IBM Qiskit introduced substantial cognitive overhead. While QWLA was intended to reduce early barriers by avoiding matrix algebra, many students reported difficulty adapting to a new programming framework midway through the semester. The transition required relearning syntax, adjusting to new application programming interfaces, and reconciling different representational conventions.
Differences in qubit ordering conventions contributed significantly to confusion. QWLA employed a big-endian representation, whereas Qiskit uses little-endian indexing. Students who developed intuitions about multi-qubit states in QWLA often found that these intuitions did not carry over reliably to Qiskit. Several students suggested beginning directly with Qiskit. Based on this feedback, future offerings will adopt Qiskit from the start and rely on its simulation and visualization features to support early intuition building.
Lesson 4: Scaffolding Within Laboratories Should Be Reduced Over Time. Laboratory design required balancing guided instruction with opportunities for independent reasoning. Early labs included substantial scaffolding through skeleton code, inline hints, and step-by-step instructions. This approach supported early progress and helped students acclimate to quantum programming. As the semester progressed, some students reported that this level of guidance limited opportunities for independent problem solving.
Future offerings will reduce within-lab scaffolding over time. Early labs will remain highly structured to support initial skill development. Subsequent labs will provide less embedded guidance and place greater responsibility on students to make design and implementation decisions. Later labs will emphasize synthesis and open-ended problem solving. The final project already followed this approach and showed that students were able to work independently when adequately prepared.
Lesson 5: Experimental Interaction Plays a Central Role in Confidence Development. Weekly laboratory experiments contributed substantially to students’ confidence and understanding of quantum concepts. Writing small programs, executing them repeatedly, and observing empirical outcomes allowed students to compare expectations with observed behavior. Labs that produced visual or statistical feedback, such as statevector plots and Bell-state measurement distributions, were particularly effective.
This iterative process was especially valuable for students who initially lacked confidence in their ability to engage with quantum mechanics. Continued interaction with executable experiments supported a gradual shift from passive reception to active exploration. At the same time, increased confidence did not consistently translate into success on more complex programming tasks, indicating the need for sustained practice as task complexity increased.
Lesson 6: Course Pacing should Reflect Nonlinear Increases in Cognitive Demand. Student feedback indicated that the cognitive demands of the course increased sharply in the later weeks. Early topics, including single-qubit operations and measurement, were generally perceived as manageable. In contrast, later topics involving Grover’s algorithm, noise modeling, and Shor’s algorithm required greater integration of concepts and more extensive debugging effort. Many students described these topics as compressed and cognitively demanding.
These observations suggest that while scaffolding within individual labs should decrease over time, course-level structural support should increase for implementation-intensive material. Future offerings will compress early material to allocate additional instructional time to advanced algorithms. Planned adjustments include extended timelines for later labs, additional checkpoints, and short preparatory tutorials focused on debugging strategies and algorithmic structure.
Lesson 7: Technical Infrastructure Can Consume Disproportionate Instructional Time. Technical setup and environment configuration required more instructional time than anticipated. Students encountered difficulties related to Python environments, Jupyter configuration, package dependencies, and Qiskit installation. Time spent addressing these issues reduced the time available for engaging with quantum concepts and programming tasks.
To limit this overhead, future offerings will prioritize cloud-based Jupyter environments that reduce local configuration requirements. When local installation is unavoidable, a dedicated setup session and detailed configuration guides will be provided before the first programming lab.
Lesson 8: Teaching Assistant Support Is Essential for Technical Troubleshooting. The presence of a teaching assistant with quantum computing knowledge during lab sessions proved valuable for student learning. Students identified teaching assistant support as among the most helpful course components. Direct access to technical support during programming activities enabled students to resolve implementation challenges and debug code errors efficiently.
This observation aligns with prior quantum computing courses where Mykhailova and Svore (Mykhailova and Svore, 2020) argued that dedicated programming lab time with in-person access to quantum computing experts greatly improves learning experience. Teaching assistant support was particularly important for addressing technical setup issues, environment configuration problems, and debugging assistance that would otherwise consume significant instructional time.
Summary.
Taken together, these lessons indicate that lab-integrated instruction can support conceptual development and confidence building in quantum computing education when instructional design choices are aligned with student capabilities. The findings also point to the need for explicit instructional support when moving from conceptual understanding to executable quantum programs.
7. Conclusions
This paper reported on the design and evaluation of a lab-integrated quantum computing course that used sustained programming-based experimentation to support conceptual development. Coupling lectures with weekly laboratories helped students build intuition and confidence for foundational quantum concepts, including superposition, measurement, and entanglement. Hands-on interaction with executable quantum programs played a central role in shaping how students reasoned about quantum behavior.
The course also revealed clear limitations of lab-based instruction. A persistent gap emerged between conceptual understanding and correct program implementation, particularly for reversible logic and oracle construction. These findings indicate that quantum programming introduces implementation challenges that require targeted instructional support beyond exploratory experimentation. Instructional design choices related to framework selection, scaffolding, and pacing also substantially influenced student engagement with complex programming tasks.
Future offerings will begin directly with Qiskit to avoid framework transitions, introduce preparatory instruction for reversible computation and oracle implementation, and reduce laboratory scaffolding over time. Course pacing will be adjusted to allocate additional instructional time to implementation-intensive topics in the later part of the semester.
References
- (1)
- cal (2019) 1997-2019. Course Information for ”Quantum Computation” (Caltech). http://www.theory.caltech.edu/~preskill/ph219/index.html
- ber (2007) 2007. Course Information for ”Quantum Computation” (Berkeley). https://people.eecs.berkeley.edu/~vazirani/quantum.html
- ber (2014) 2014. Course Information for ”Qubits, Quantum Mechanics, and Computers” (Berkeley). https://inst.eecs.berkeley.edu/~cs191/fa14/
- ut- (2017) 2017. Course Information for ”Introduction to Quantum Information Science” (UT Austin). https://www.scottaaronson.com/cs378/
- ucl (2019) 2019. Course Information for ”Current Topics in Computer Science: Programming Languages and Systems: Quantum Programming” (UCLA). https://ccle.ucla.edu/course/view/19S-COMSCI239-1?show_all=1
- uw (2019) 2019. Course Information for ”Introduction to Quantum Computing and Quantum Programming in Q#” (University of Washington). https://courses.cs.washington.edu/courses/cse490q
- wat (2019) 2019. Course Information for ”Introduction to Quantum Information Processing” (University of Waterloo). http://cleve.iqc.uwaterloo.ca/qic710.html
- Albarghouthi (2025) Aws Albarghouthi. 2025. Quantum Computing without the Linear Algebra. Cryptology ePrint Archive, Paper 2025/1091. https://eprint.iacr.org/2025/1091
- Grover (1996) Lov K. Grover. 1996. A fast quantum mechanical algorithm for database search. In Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing (Philadelphia, Pennsylvania, USA) (STOC ’96). Association for Computing Machinery, New York, NY, USA, 212–219. doi: 10.1145/237814.237866
- Low et al. (2019) Guang Hao Low, Nicholas Bauman, Christopher Granade, Bo Peng, Nathan Wiebe, Eric Bylaska, Dave Wecker, Sriram Krishnamoorthy, Martin Roetteler, Karol Kowalski, Matthias Troyer, and Nathan A. Baker. 2019. Q# and NWChem: Tools for Scalable Quantum Chemistry on Quantum Computers.
- Mykhailova and Svore (2020) Mariia Mykhailova and Krysta M. Svore. 2020. Teaching Quantum Computing through a Practical Software-driven Approach: Experience Report. In Proceedings of the 51st ACM Technical Symposium on Computer Science Education (Portland, OR, USA) (SIGCSE ’20). Association for Computing Machinery, New York, NY, USA, 1019–1025. doi: 10.1145/3328778.3366952
- Seegerer et al. (2021) Stefan Seegerer, Tilman Michaeli, and Ralf Romeike. 2021. Quantum Computing As a Topic in Computer Science Education. In Proceedings of the 16th Workshop in Primary and Secondary Computing Education (Virtual Event, Germany) (WiPSCE ’21). Association for Computing Machinery, New York, NY, USA, Article 13, 6 pages. doi: 10.1145/3481312.3481348
- Shor (1994) P.W. Shor. 1994. Algorithms for quantum computation: discrete logarithms and factoring. In Proceedings 35th Annual Symposium on Foundations of Computer Science (Santa Fe, NM, USA). IEEE. doi: 10.1109/SFCS.1994.365700
- Wille et al. (2019) Robert Wille, Rod Van Meter, and Yehuda Naveh. 2019. IBM’s Qiskit Tool Chain: Working with and Developing for Real Quantum Computers. In 2019 Design, Automation & Test in Europe Conference & Exhibition (DATE). 1234–1240. doi: 10.23919/DATE.2019.8715261